MC_segment.hpp

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2009  Damien Rohmer
**
**    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 3 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 _MC_SEGMENT_HPP_
#define _MC_SEGMENT_HPP_


#include <stdlib.h>
#include <iostream>

#include <MC_v3d.hpp>
#include <vector>

namespace mesh_conv
{

    class MC_double_vector;
    class MC_int_pair;


    class MC_segment
    {
        public:


        //*********************************************//
        //*********************************************//
        // CONSTRUCTORS
        //*********************************************//
        //*********************************************//

        MC_segment();
        MC_segment(const MC_v3d& start_point,const MC_v3d& end_point);
        MC_segment(const MC_segment& s);

        ~MC_segment();


        //*********************************************//
        //*********************************************//
        // Manipulation
        //*********************************************//
        //*********************************************//

        MC_v3d unit_vector() const;
        MC_v3d vector() const;

        MC_segment fliped() const;

        // ***************************************************** //
        // ***************************************************** //
        // Build
        // ***************************************************** //
        // ***************************************************** //

        static std::vector<MC_segment> build_segment_vector(const MC_v3d_vector& vertices,const std::vector<MC_int_pair>& constraints);



        //*********************************************//
        //*********************************************//
        // Information
        //*********************************************//
        //*********************************************//

        double length() const;

        MC_v3d closest_point(const MC_v3d& x) const;

        double distance_to_point(const MC_v3d& x) const;

        MC_segment closest_to_segment(const MC_segment& s) const;


        double distance_to_segment(const MC_segment& s) const;

        MC_v3d plane_intersection(const MC_v3d& n,const MC_v3d& x0,int *type=0) const;

        bool is_belonging(const MC_v3d& x,int *type=0) const;

        bool is_aligned(const MC_v3d& x) const;


        double relative_position(const MC_v3d& x,bool *is_aligned=0) const;


        void assert_bounds(const int& u) const;


        //************************************************//
        //************************************************//
        //Get value
        //************************************************//
        //************************************************//

        MC_v3d  operator()(const int& index) const;
        MC_v3d& operator()(const int& index);
        MC_v3d  operator[](const int& index) const;
        MC_v3d& operator[](const int& index);

        MC_v3d value(const double& t) const;

        MC_v3d_vector value(const MC_double_vector& t) const;

        std::pair<MC_v3d_vector,MC_double_vector> linear_sampling_intervals(const double& d_L) const;

        std::pair<MC_v3d_vector,MC_double_vector> linear_sampling(const int& N) const;



        //************************************************//
        //************************************************//
        //Math operator
        //************************************************//
        //************************************************//


        friend MC_segment operator+(const MC_segment& s,const MC_v3d& x);
        friend MC_segment operator+(const MC_v3d& x,const MC_segment& s);
        friend MC_segment operator*(const MC_segment& s,const double& a);
        friend MC_segment operator*(const double& a,const MC_segment& s);


        //************************************************//
        //************************************************//
        //OUTPUT
        //************************************************//
        //************************************************//

        friend std::ostream& operator << (std::ostream& stream, const MC_segment& s);

    private:

        MC_v3d x0,x1;

    };
}

#endif