a_segment.h

Go to the documentation of this file.

/*
         Copyright 2010-2017 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_SEGMENT_H_
#define _A_SEGMENT_H_
 
#include <iostream>
#include "a_point.h"
#include "a_mat_sq.h"
 
class a_segment: public a_geom_base
{
        public:
                a_segment() : p1_(), p2_() {};
                a_segment(const a_point p1, const a_point p2) : p1_(p1), p2_(p2) {}
                a_segment(const a_segment& s) {p1_ = s.p1_; p2_ = s.p2_;}
 
                virtual const std::string classname() { return "a_segment";}
                static const std::string help();
                inline a_point   p1() const { return p1_; }
                inline a_point   p2() const { return p2_; }
                inline a_point   vec() const {return (p2_-p1_);}
                inline a_point   dir() const {return (p2_-p1_).normalise();}
                inline a_point c() const {return (p1_+p2_)/2.;}
                inline void     p1(const a_point v) { p1_ = v; }
                inline void     p2(const a_point v) { p2_ = v; }
                inline a_segment& translate(double x, double y, double z) {p1_.translate(x,y,z); p2_.translate(x,y,z); return *this;}
                a_segment& rotate(const a_point& x_axis, const a_point& y_axis, const a_point& z_axis);
 
                bool operator==(const a_segment& p);
                a_segment& operator=(const a_segment& v);
 
                inline double length() const { return (p2_-p1_).norm();}
                a_mat_sq inertia() const;
                double project(const a_point v) const;
                a_point closestl(const a_point& p) const;
                a_point closest(const a_point& p) const;
                double distl(const a_point& p) const;
                double dist(const a_point& p) const;
                a_segment intersect(const a_segment& s, double& m1, double& m2) const;
                a_segment shortest(const a_segment& s, double& m1, double& m2) const;
                double distl(const a_segment& s) const;
                double dist(const a_segment& s) const;
 
                //: input/output
                virtual void read(std::istream &i);
                virtual void write(std::ostream &o) const;
 
                class null_segment_error  {};
                class denomin_error  {};
 
 
        protected:
                a_point p1_;
                a_point p2_;
};
 
#endif