gr_parapiped.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_PARAPIPED_H
#define KJB_PARAPIPED_H

#include <iosfwd>
#include <vector>

#include <inttypes.h>

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

namespace kjb {


class Parapiped : public kjb::Polymesh
{
    public:

        Parapiped
        (
            double x1, double y1, double z1,
            double x2, double y2, double z2,
            double x3, double y3, double z3,
            double x4, double y4, double z4
        );


        Parapiped
        (
            const kjb::Vector & p1,
            const kjb::Vector & p2,
            const kjb::Vector & p3,
            const kjb::Vector & p4
        )
        throw (kjb::Illegal_argument);


        Parapiped(const Parapiped& p);


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


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


        virtual ~Parapiped() { };


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


        virtual Parapiped* 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
        (
            double x1, double y1, double z1,
            double x2, double y2, double z2,
            double x3, double y3, double z3,
            double x4, double y4, double z4
        );

        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_CMU_orientation_map() const;

        void draw_geometric_context_map() const;

        static int get_num_edges()
        {
            return 24;
        }

        static void get_edge_indexes
        (
            std::vector<int> & base_edge_indexes,
            std::vector<int> & vertical_edge_indexes,
            std::vector<int> & top_edge_indexes
        )
        {
            base_edge_indexes.push_back(2);
            base_edge_indexes.push_back(4);
            base_edge_indexes.push_back(12);
            base_edge_indexes.push_back(13);
            base_edge_indexes.push_back(14);
            base_edge_indexes.push_back(15);
            base_edge_indexes.push_back(18);
            base_edge_indexes.push_back(23);

            //TODO Double check this
            vertical_edge_indexes.push_back(1);
            vertical_edge_indexes.push_back(3);
            vertical_edge_indexes.push_back(5);
            vertical_edge_indexes.push_back(7);
            vertical_edge_indexes.push_back(17);
            vertical_edge_indexes.push_back(19);
            vertical_edge_indexes.push_back(20);
            vertical_edge_indexes.push_back(22);

            top_edge_indexes.push_back(0);
            top_edge_indexes.push_back(6);
            top_edge_indexes.push_back(8);
            top_edge_indexes.push_back(9);
            top_edge_indexes.push_back(10);
            top_edge_indexes.push_back(11);
            top_edge_indexes.push_back(16);
            top_edge_indexes.push_back(21);
        }

    protected:

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

        kjb::Vector center;

    private:

       Int_matrix _adjacency;

       void create_adjacency_matrix();

};


}


#endif