MC_v3d_vector.hpp

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2008 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_V3D_VECTOR_HPP_
#define MC_V3D_VECTOR_HPP_



#include <MC_v3d.hpp>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <algorithm>



namespace mesh_conv
{
    class MC_double_vector;
    class MC_int_vector;
    class MC_matrix;
    class MC_connectivity_index;
    class MC_mesh_index_vector;
    class MC_segment;


    class MC_v3d_vector
    {


    protected:

        std::vector <MC_v3d> v;


    public:


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

        MC_v3d_vector();
        MC_v3d_vector(const int& new_size);
        MC_v3d_vector(const MC_v3d& v0);
        MC_v3d_vector(const MC_v3d& v0,const MC_v3d& v1);
        MC_v3d_vector(const MC_v3d& v0,const MC_v3d& v1,const MC_v3d& v2);
        MC_v3d_vector(const MC_v3d& v0,const MC_v3d& v1,const MC_v3d& v2,const MC_v3d& v3);
        MC_v3d_vector(const MC_v3d& v0,const MC_v3d& v1,const MC_v3d& v2,const MC_v3d& v3,const MC_v3d& v4);
        MC_v3d_vector(const MC_v3d_vector& vec);
        MC_v3d_vector(const std::vector <MC_v3d>& vec);
        MC_v3d_vector(const std::set <MC_v3d,MC_v3d_less> set);
        MC_v3d_vector(const std::map <MC_v3d,int,MC_v3d_less> map);
        MC_v3d_vector(const MC_double_vector& x_vector,const MC_double_vector& y_vector,const MC_double_vector& z_vector);
        static MC_v3d_vector build_from_concatenated_vector(const MC_double_vector& X);

        virtual ~MC_v3d_vector(){}

        //************************************************//
        //************************************************//
        //Asserts
        //************************************************//
        //************************************************//

        void assert_bounds(const int& u) const;



        //*********************************************//
        //*********************************************//
        // Attribute
        //*********************************************//
        //*********************************************//

        int size() const;

        //*********************************************//
        //*********************************************//
        // Manipulate
        //*********************************************//
        //*********************************************//

        void clear();

        MC_v3d_vector& resize(const int& new_size);

        MC_v3d_vector& add(const MC_v3d& x);
        MC_v3d_vector& add(const MC_v3d_vector& v_x);
        friend MC_v3d_vector operator<<(const MC_v3d_vector& vec,const MC_v3d& value);
        friend MC_v3d_vector operator<<(const MC_v3d_vector& vec,const MC_v3d_vector& value);


        MC_v3d_vector& set(const int& k_index,const MC_v3d& x);
        MC_v3d_vector& set(const mesh_conv::MC_int_vector& k_index,const MC_v3d_vector& x);


        const MC_v3d& first() const;
        MC_v3d& first();

        const MC_v3d& last() const;
        MC_v3d& last();

        MC_double_vector component(const int& k_dim) const;


        MC_v3d_vector removed(const MC_int_vector& index_to_remove) const;

        //************************************************//
        //************************************************//
        //Initialize value
        //************************************************//
        //************************************************//


        static MC_v3d_vector zeros(const int& new_size);

        static MC_v3d_vector build_duplicate(const unsigned int& N,const MC_v3d& value_to_duplicate);


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




        MC_v3d_vector operator-() const;


        friend MC_v3d_vector operator+(const MC_v3d_vector& vec,const MC_v3d& to_add);
        friend MC_v3d_vector operator+(const MC_v3d& to_add,const MC_v3d_vector& vec);
        friend MC_v3d_vector operator-(const MC_v3d_vector& vec,const MC_v3d& to_sub);

        friend MC_v3d_vector operator*(const MC_v3d_vector& vec,const double& to_mult);
        friend MC_v3d_vector operator*(const double& to_mult,const MC_v3d_vector& vec);
        friend MC_v3d_vector operator/(const MC_v3d_vector& vec,const double& to_subdiv);



        friend MC_v3d_vector operator+(const MC_v3d_vector& vec,const MC_v3d_vector& to_add);
        friend MC_v3d_vector operator-(const MC_v3d_vector& vec,const MC_v3d_vector& to_sub);



        MC_v3d_vector& operator+=(const MC_v3d& to_add);
        MC_v3d_vector& operator-=(const MC_v3d& to_sub);
        MC_v3d_vector& operator*=(const double& to_mult);
        MC_v3d_vector& operator/=(const double& to_subdiv);

        MC_v3d_vector& operator+=(const MC_v3d_vector& to_add);
        MC_v3d_vector& operator-=(const MC_v3d_vector& to_sub);

        static MC_v3d sum(const MC_v3d_vector& vec);

        friend MC_v3d_vector operator*(const MC_matrix& M,const MC_v3d_vector& vec);
        MC_v3d_vector& operator*=(const MC_matrix& M);

        friend MC_v3d_vector operator*(const MC_double_vector w,const MC_v3d_vector& vec);
        friend MC_v3d_vector operator*(const MC_v3d_vector& vec,const MC_double_vector& w);
        MC_v3d_vector& operator*=(const MC_double_vector& w);

        static MC_double_vector norm(const MC_v3d_vector& vec);

        MC_v3d_vector normalized() const;

        MC_v3d_vector& scale(const MC_v3d_vector& s);

        std::pair <MC_v3d_vector,double> scaled_to_unit() const;

        MC_v3d barycenter() const;

        std::pair<MC_v3d_vector,MC_matrix> scaled_to_unit_and_center() const;


        //*********************************************//
        //*********************************************//
        // get Operators
        //*********************************************//
        //*********************************************//

        const MC_v3d& operator()(const int& k_index) const ;
        MC_v3d& operator()(const int& k_index) ;
        const MC_v3d& operator[](const int& k_index) const ;
        MC_v3d& operator[](const int& k_index) ;
        
        MC_v3d_vector operator()(const MC_int_vector& index) const; 
        MC_v3d_vector operator[](const MC_int_vector& index) const;

        const MC_v3d* pointer() const;
        MC_v3d* pointer_unprotected();

        //************************************************//
        //************************************************//
        //change type
        //************************************************//
        //************************************************//

        std::map <MC_v3d,int,MC_v3d_less> to_map() const;
        std::set <MC_v3d,MC_v3d_less> to_set() const;
        std::list <MC_v3d> to_list() const;


        //*********************************************//
        //*********************************************//
        // Bounding box
        //*********************************************//
        //*********************************************//

        std::pair <MC_v3d,MC_v3d> bounding_box_elements() const;

        MC_v3d bounding_box_length() const;

        std::vector <MC_segment> bounding_box_segment(const double& length_ratio=0.1) const;

        //*********************************************//
        //*********************************************//
        // Laplacian
        //*********************************************//
        //*********************************************//

        static MC_v3d_vector laplacian_deformation(const MC_v3d_vector& vertex_input,const std::map<int,std::pair<MC_int_vector,MC_double_vector> >& laplacian_mean_value,const std::pair<MC_int_vector,MC_v3d_vector>& constraints);



        
        //*********************************************//
        //*********************************************//
        // INPUT OUTPUT
        //*********************************************//
        //*********************************************//

        friend std::ostream& operator<<(std::ostream& output,const MC_v3d_vector& in);

        std::ostream& export_stream(std::ostream& output) const;
        MC_v3d_vector& read_stream(std::istream& input);



//        //*********************************************//
//        //*********************************************//
//        // Points contained in volume
//        //*********************************************//
//        //*********************************************//
//
//        /** \brief Points contained in a given box */
//        MC_int_vector contained_in_box(const MC_v3d& x0,const MC_v3d& x1);


        //************************************************//
        //************************************************//
        //Closest
        //************************************************//
        //************************************************//

        std::pair<MC_v3d,int> closest(const MC_v3d& x) const;


        //************************************************//
        //************************************************//
        //Change position
        //************************************************//
        //************************************************//

        MC_v3d_vector inverted_position() const;

    private:
    };


    class MC_v3d_vector_less
    {
    public:
        bool operator()(const MC_v3d_vector& v0,const MC_v3d_vector& v1) const
        {
            MC_v3d_less L;
            if(v0.size()<v1.size())
                return true;
            else if(v0.size()>v1.size())
                return false;
            else //equal size compare by values
            {
                int N=v0.size();
                for(int k=0;k<N;++k)
                {
                    if(L(v0[k],v1[k])==true)
                        return true;
                    else if(L(v1[k],v0[k])==true)
                        return false;
                }
                //complete equality
                return false;
            }
        }
    };

}

#endif