a_curve.h

Go to the documentation of this file.

/*
         Copyright 2010-2011 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 _WE_CURVE_H_
#define _WE_CURVE_H_
 
#include "a_point.h"
#include "a_segment.h"
 
#include <iostream>
#include <vector>
#include <deque>
 
class a_curve
{
        public:
                a_curve(double da = 1e-6);
                a_curve(const a_curve&);
                virtual ~a_curve();
                //      a_curve& construct_axis() {return this->construct_z_axis().construct_y_axis().construct_x_axis();}
                a_curve& construct_axis();
 
                void addpoint(a_point * pt) {x_.push_back(pt); initialised_=false; n_pts_++;}
                //      void addpoint(a_point * pt) {x_.push_back(pt); initialised_=false; this->init();}
                int size() const {return x_.size();} 
                a_point * operator[](int i) const {return x_[i];}
                std::deque<a_point *>&  x() {return x_;}
                virtual a_point operator()(double a) const = 0;
                virtual a_point dx_axis(double a) const;
                virtual a_point dy_axis(double a) const;
                virtual a_point dz_axis(double a) const;
                /*change the orientation of the z axis*/
                void invert() {orient_ = -1; this->construct_axis();}
                bool is_closed() const;
                void set_horiz(const a_point& p) {horiz_ = p;}
                a_point get_horiz() const {return horiz_;}
 
                //      a_curve& invert();
                a_curve& translate(const a_point & p);
                a_curve& translate(double x, double y, double z);
                a_point origin() const {return *x_[0];}
                a_curve& origin(a_point & p);
                a_curve& origin(double x, double y, double z);
                a_point centre() const;
                a_curve& flatten();
                a_curve& flatten2D();
                a_curve& place3D(a_point& origin, a_point& x_axis, a_point& y_axis);
                a_point x_axis() const {return x_axis_;}
                a_point y_axis() const {return y_axis_;}
                a_point z_axis() const {return z_axis_;}
                double da() const {return da_;}
                void da(double da) {da_ = da;}
 
                double dist(const a_point &, int & ref) const;
                double dist2(const a_point &, int & ref, double & m) const;
                double dist_last(const a_point &, int & ref) const;
                double dist(const a_curve &, int & ref1, int & ref2) const;
                double dist_last(const a_curve &, int & ref1, int & ref2) const;
                double dist2(const a_curve &, int & ref1, int & ref2, double& m1, double& m2) const;
                a_segment shortest(const a_curve & fn, int & ref1, int & ref2, double& m1, double& m2) const;
 
                friend   std::istream&    operator>> (std::istream& i, a_curve& m);
                friend   std::ostream&    operator<< (std::ostream& o, const a_curve& m);
 
                class range_error {};
                class pattern_incompatible_error {};
 
        protected:
                bool                                    initialised_;
                std::deque<a_point *>   x_;
                double da_; //an 'infinitesimal' value
                int                                             n_pts_;
                a_point                                 x_axis_;
                a_point                                 y_axis_;
                a_point                                 z_axis_;
                int                                             orient_;
                a_point                                 horiz_;
 
                a_curve& construct_x_axis();
                a_curve& construct_y_axis();
                a_curve& construct_z_axis();
 
                virtual a_curve& init();
};
 
#endif