gr_parametric_frustum.h

Go to the documentation of this file.

/* =========================================================================== *
|
|  Copyright (c) 1994-2008 by Kobus Barnard (author).
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT cs DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
| Authors:
|     Joseph Schlecht, Luca Del Pero
|
* =========================================================================== */

#ifndef KJB_Frustum_H
#define KJB_Frustum_H

#include <vector>
#include <iosfwd>

#include <inttypes.h>

#include <gr_cpp/gr_polymesh.h>
#include <gr_cpp/gr_polymesh_renderer.h>

namespace kjb {


class Frustum : public kjb::Polymesh
{
    public:

        Frustum
        (
            unsigned int inv,
                        double ix, double iy, double iz,
                        double iw, double il, double iratio_top_bottom, double ih,
                        double ipitch, double iyaw, double iroll
        );


        Frustum
        (
            const std::vector<kjb::Vector> & p
        )
        throw (kjb::Illegal_argument);


        Frustum(const Frustum& p);


        Frustum(const char* fname, unsigned int inv) throw (kjb::Illegal_argument,
                kjb::IO_error);


        Frustum(std::istream& in, unsigned int inv) throw (kjb::Illegal_argument,
                kjb::IO_error);


        virtual ~Frustum() { };


        virtual Frustum& operator= (const Frustum& p);


        virtual Frustum* clone() const;

        virtual void transform(const kjb::Matrix & M)
            throw (kjb::Illegal_argument);


        const kjb::Vector & get_point(size_t i) const
            throw (kjb::Illegal_argument);


        const kjb::Vector & get_center() const;

        virtual void add_face(const Polygon & face) throw (kjb::Illegal_argument);


        virtual void read(std::istream& in) throw (kjb::IO_error,
                kjb::Illegal_argument);

        virtual void write(std::ostream& out) const
            throw (kjb::IO_error);

        void set_points
        (
            unsigned int inv,
                        double ix, double iy, double iz,
                        double iw, double il, double iratio_top_bottom, double ih
        );

        virtual unsigned int adjacent_face(unsigned int f, unsigned int e) const
                       throw (Index_out_of_bounds,KJB_error);

        void draw_orientation_map() const;

/*        void draw_left_right_orientation_map() const;

        void draw_geometric_context_map() const;*/

        static int get_num_edges(int num_facets)
        {
            //KJB_THROW(kjb::Not_implemented);
            return 0; //TODO implement
        }

        static int get_edge_indexes
        (
            std::vector<int> & base_edge_indexes,
            std::vector<int> & vertical_edge_indexes,
            std::vector<int> & top_edge_indexes,
            int num_facets
        )
        {
            //TODO implement
            //KJB_THROW(kjb::Not_implemented);
            return 0;
        }

    protected:

        unsigned int nv;

        std::vector<kjb::Vector > points;

        kjb::Vector center;

    private:

       Int_matrix _adjacency;

       void create_adjacency_matrix();

};


}


#endif