gr_polymesh.h

Go to the documentation of this file.

/* $Id$ */
/* =========================================================================== *
|
|  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_POLYMESH_H
#define KJB_POLYMESH_H

#include <inttypes.h>

#include <l_cpp/l_exception.h>
#include <gr_cpp/gr_polygon.h>
#include <gr_cpp/gr_rigid_object.h>
#include <vector>
#include <gr_cpp/gr_renderable.h>

#include "l_cpp/l_readable.h"
#include "l_cpp/l_writeable.h"

namespace kjb{


class Base_gl_interface;
class Polymesh: public kjb::Abstract_renderable,
                public kjb::Rigid_object,
                public kjb::Readable,
                public kjb::Writeable
{
    public:

        Polymesh()
        : Abstract_renderable(), Rigid_object(), Readable(), Writeable()
        {

        }

        Polymesh(unsigned int n);


        Polymesh(const char* fname) throw (kjb::Illegal_argument, kjb::IO_error);


        Polymesh(std::istream& in) throw (kjb::Illegal_argument, kjb::IO_error);


        Polymesh(const Polymesh& t);


        virtual Polymesh& operator= (const Polymesh& t);

        virtual Polymesh * clone() const;

        virtual ~Polymesh();


        unsigned int num_faces() const;

        const std::vector<kjb::Polygon>& get_faces() const;
        
         const kjb::Polygon& get_face(unsigned int i) const throw (kjb::Index_out_of_bounds);

        kjb::Polygon& get_face_ref(unsigned int i) throw (kjb::Index_out_of_bounds);

        //virtual void add_face(const Polygon & face, uint32_t id) throw (kjb::Illegal_argument);

        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 & ost)
        const throw(kjb::IO_error);

        virtual void write(const char *filename) const throw (IO_error);


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

        /* @brief Translates this mesh */
        virtual void translate(double x, double y, double z);

        /* @brief translates this mesh around an axis */
        virtual void rotate(double phi, double x, double y, double z);

        virtual void rotate(double dpitch, double dyaw, double droll)
        {
            Rigid_object::rotate(dpitch, dyaw, droll);
        }

        /* @brief scales this mesh */
        virtual void scale(double scale_x, double scale_y, double scale_z);

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

        void get_faces(std::vector<const Polygon *> & ifaces) const;

        virtual void wire_render() const;

        unsigned int wire_render_with_sequential_ids(unsigned int start_id = 1) const;

        unsigned int solid_render_with_sequential_ids(unsigned int start_id = 1) const;

        virtual void wire_occlude_render() const;

        /*
         * @brief Renders this mesh as a solid object
         */
        virtual void solid_render() const;

        virtual void silhouette_render(const kjb::Base_gl_interface & camera, double iwidth = 1.0) const;

        /*
         * @brief Projects all the polygons in this mesh using
         * onto the image plane
         */
        virtual void project();

        double compute_surface_area() const;

        void get_all_vertices(std::vector<Vector> & vertices) const;
        
        void get_all_edges(std::vector<std::vector<Vector> >& edges) const;

        void get_lines(std::vector<Line3d> & lines);

        /*
         * @brief  Iterates through all the vertices of the mesh and
         *         stores the smallest and largest x,y,z values.
         */
        void find_bounds();

        /*
         * @brief  Returns the center point of the mesh based on the
         *         midpoint of the smallest and largest bounds.
         */
        kjb::Vector get_center();

        /*
         * @brief  Returns the largest z-value of the points in the 
         *         polymesh.
         */
        double get_largest_z_bound();

        /*
         * @brief  Returns the largest x, y, and z bounds in the polymesh.
         */
        kjb::Vector get_largest_bounds() const;

        /*
         * @brief  Returns the smallest x, y, and z bounds in the polymesh.
         */
        kjb::Vector get_smallest_bounds() const;


    protected:
       std::vector<kjb::Polygon> _faces;
       Vector smallest_bounds;
       Vector largest_bounds;

       inline bool is_same_vertex(const kjb::Vector& p1,const kjb::Vector& p2) const
       {
           return p1 == p2;
       }

       bool is_shared_edge(const Polygon & f1, unsigned int e1, const Polygon & f2, unsigned int e2) const
       throw (Index_out_of_bounds);

       /*
        * @brief Returns true if face f2 contains contains edge e of face 1, false otherwise.
        * If f2 contains the edge, index will contain the index of the shared edge in face f2.
        */
       bool edge_index_in_polygon(const Polygon &f1, unsigned int e, const Polygon &f2, unsigned int & index)
           throw (Index_out_of_bounds);

       friend class GL_Polymesh_Renderer;

};


}


#endif