polyhedron.hpp

Go to the documentation of this file.

/*****************************************************************************
    
    polyhedron.hpp -- a representation of a convex polyhedron and operations on it.

    This file is a part of the Arageli library.

    Copyright (C) Sergey S. Lyalin, 2006
    University of Nizhni Novgorod, Russia, 2005--2006

*****************************************************************************/

#ifndef _ARAGELI_polyhedron_hpp_
#define _ARAGELI_polyhedron_hpp_

#include "config.hpp"

#include "gcd.hpp"
#include "big_int.hpp"
#include "rational.hpp"
#include "cone.hpp"
#include "sideset.hpp"
#include "vector.hpp"
#include "matrix.hpp"


namespace Arageli
{

struct fromempty_t {};
const fromempty_t fromempty = fromempty_t();

struct fromivert_t {};
const fromivert_t fromivert = fromivert_t();

struct fromvert_t {};
const fromvert_t fromvert = fromvert_t();


template <typename T, typename M, typename C> class polyhedron_default_config {};



template
<
    typename T = big_int,
    typename M = matrix<big_int>,
    typename C = cone<T, M>,
    typename CFG = polyhedron_default_config<T, M, C>
>
class polyhedron
{
public:

    //typedef matrix<R> vertices_type;

    typedef C cone;

    typedef typename C::inequation_element_type inequation_element_type;
    typedef typename C::equation_element_type equation_element_type;
    typedef typename C::generatrix_element_type generatrix_element_type;
    typedef typename C::basis_element_type basis_element_type;

    typedef typename C::inequation_type inequation_type;
    typedef typename C::equation_type equation_type;
    typedef typename C::generatrix_type generatrix_type;
    typedef typename C::basis_type basis_type;

    typedef typename C::size_type size_type;
    typedef typename C::dim_type dim_type;
    typedef typename C::difference_type difference_type;



    polyhedron () : cone_m(1, fromnull) {}

    

    template <typename D>
    polyhedron (const D& dim, const fromempty_t&)
    :   cone_m(dim + 1, fromnull)
    {}
         


    template <typename D>
    polyhedron (const D& dim, const fromspace_t&);



    template <typename M1>
    polyhedron (const M1& ineqmat, const fromineq_t&);


    template <typename M1>
    polyhedron (const M1& vert, const fromivert_t&);



    template <typename M1>
    polyhedron (const M1& vert, const fromvert_t&);


    sideset sides () const;


    // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



    bool is_implicit_valid () const
    { return cone_m.is_implicit_valid(); }

    bool is_parametric_valid () const
    { return cone_m.is_parametric_valid(); }

    bool is_all_valid () const
    { return cone_m.is_all_valid(); }


    bool is_implicit_normal () const
    { return cone_m.is_implicit_normal(); }


    bool is_parametric_normal () const
    { return cone_m.is_parametric_normal(); }

    bool is_all_normal () const
    { return cone_m.is_all_normal(); }




    // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++




    void validate_implicit () const
    { cone_m.validate_implicit(); }


    void validate_parametric () const
    { cone_m.validate_parametric(); }

    void validate_all () const
    { cone_m.validate_all(); }
    

    void normalize_implicit () const
    { cone_m.normalize_implicit(); }


    void normalize_parametric () const
    { cone_m.normalize_parametric(); }
    
    void normalize_all () const
    { cone_m.normalize_all(); }




    // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


    

    void set_valid_implicit ()
    { cone_m.set_valid_implicit(); }


    void set_valid_parametric ()
    { cone_m.set_valid_parametric(); }


    void set_valid_all ()
    { cone_m.set_valid_all(); }


    void set_normal_implicit ()
    { cone_m.set_normal_implicit(); }


    void set_normal_parametric ()
    { cone_m.set_normal_parametric(); }


    void set_normal_all ()
    { cone_m.set_normal_all(); }



    // Brrrrr!
    template <typename M1>
    M1 vertices () const
    {
        normalize_parametric();
        M1 res = cone_m.generatrix_matrix();

        for(std::size_t i = 0; i < res.nrows();)
            if(Arageli::is_null(res(i, 0)))
                res.erase_row(i);
            else
            {
                res.div_row(i, safe_reference(res(i, 0)));
                ++i;
            }

        res.erase_col(0);

        return res;
    }

    // Brrrrr!
    const T& inequation_matrix (std::size_t i, std::size_t j) const
    { return cone_m.inequation_matrix()(i, j); }

    // Brrrrr!
    vector<T> facet_normal (std::size_t i) const
    {
        vector<T> res = cone_m.inequation_matrix().copy_row(i);
        res.pop_front();
        return res;
    }

    std::size_t space_dim () const { return cone_m.space_dim() - 1; }

private:

    C cone_m;

};


template
<
    typename Out, 
    typename T,
    typename R,
    typename M,
    typename CFG
>
void output_vrml (Out& out, const polyhedron<T, R, M, CFG>& p);


class pstricks_color_map
{
public:

    pstricks_color_map
    (
        double rstart_a,
        double gstart_a,
        double bstart_a,
        double rend_a,
        double gend_a,
        double bend_a,
        std::size_t n_a,
        const std::string& name_a
    );

    const std::string& name (double x) const;

};



template
<
    typename Out,
    typename P,
    typename X1, typename Y1, typename X2, typename Y2,
    typename Viewdir,
    typename Colormap
>
void output_polytope_pstricks_3d
(
    Out& out,
    const P& p,
    double x1,
    double y1,
    double x2,
    double y2,
    double linewidth,
    const Viewdir& viewdir,
    const Colormap& colormap
);


} // namesapce Arageli


#ifdef ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE
    #define ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_polyhedron
    #include "polyhedron.cpp"
    #undef  ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_polyhedron
#endif

#endif  // #ifndef _ARAGELI_polyhedron_hpp_

---