MC_polygon.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_POLYGON_HPP_
#define MC_POLYGON_HPP_

#include <MC_v3d.hpp>
#include <MC_v3d_vector.hpp>
#include <MC_int_vector.hpp>

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



namespace mesh_conv
{
    class MC_segment;
    class MC_mesh_index_vector;


    class MC_polygon : public MC_v3d_vector
    {
    public:

        //************************************************//
        //************************************************//
        //Constructor
        //************************************************//
        //************************************************//

        MC_polygon();
        MC_polygon(const MC_v3d& v0,const MC_v3d& v1,const MC_v3d& v2);
        MC_polygon(const MC_v3d& v0,const MC_v3d& v1,const MC_v3d& v2,const MC_v3d& v3);
        MC_polygon(const MC_v3d& v0,const MC_v3d& v1,const MC_v3d& v2,const MC_v3d& v3,const MC_v3d& v4);
        MC_polygon(const MC_v3d_vector& vec);
        MC_polygon(const std::vector <MC_v3d>& vec);
        MC_polygon(const MC_polygon& p);


        //************************************************//
        //************************************************//
        //Informations
        //************************************************//
        //************************************************//

        bool is_planar() const;

        MC_v3d normal() const;

        MC_v3d barycenter() const;

        bool is_inside(const MC_v3d& _x) const;
        bool is_outside(const MC_v3d& _x) const;


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


        MC_double_vector barycentric_coordinates(const MC_v3d& x) const;


        MC_int_vector position(const MC_v3d& x) const;





        //************************************************//
        //************************************************//
        //Geometry transform (intersection, ...)
        //************************************************//
        //************************************************//


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

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

        MC_v3d segment_intersection(const MC_segment& s,int *type=0) const;


        std::pair <MC_v3d,std::pair<int,std::pair<int,double> > > projected_direction(const MC_v3d& x0,const MC_v3d& d,const MC_int_vector& forbidden_edge=MC_int_vector(-1)) const;



        bool is_degenerated() const;
        std::pair<MC_polygon,std::pair<bool,bool> > undegenerated() const;



        std::pair <MC_polygon,MC_matrix> rotate_to_plane(const MC_v3d& normal) const;


        //************************************************//
        //************************************************//
        //Subdivision
        //************************************************//
        //************************************************//.

        std::pair<std::vector <MC_polygon>,std::pair<MC_mesh_index_vector,std::pair<MC_int_vector,MC_int_vector> > >  subdivide_mid_edge(const MC_int_vector& constraint_edges=MC_int_vector()) const;



        std::pair<std::vector <MC_polygon>,std::pair<MC_mesh_index_vector,std::pair<MC_int_vector,MC_int_vector> > > subdivide_barycenter_mid_edge(const MC_int_vector& constraint_edges=MC_int_vector()) const;

        std::pair<std::vector <MC_polygon>,std::pair<MC_mesh_index_vector,std::pair<MC_int_vector,MC_int_vector> > > subdivide_mixed_mid_edge(const MC_int_vector& constraint_edges=MC_int_vector()) const;


        //************************************************//
        //************************************************//
        //Get
        //************************************************//
        //************************************************//

         MC_segment segment(const int& edge_number) const;


    private:

        std::vector <MC_polygon> subdivide_mid_edge_no_constraint() const;
        std::vector <MC_polygon> subdivide_barycenter_mid_edge_no_constraint() const;


    };


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

}




#endif