st_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:
|     Luca Del Pero
|
* =========================================================================== */


#ifndef ST_PARAPIPED_H_
#define ST_PARAPIPED_H_

#include <gr_cpp/gr_parapiped.h>
#include <g_cpp/g_quaternion.h>
#include <m_cpp/m_vector.h>
#include <st_cpp/st_renderable_model.h>
#include <gr_cpp/gr_parametric_frustum.h>

#define ST_PARAPIPED_PITCH 0
#define ST_PARAPIPED_YAW 1
#define ST_PARAPIPED_ROLL 2
#define ST_PARAPIPED_DISTANCE_FROM_THE_FLOOR 0.002

namespace kjb
{

class Perspective_camera;
class Manhattan_corner;
class Vanishing_point;

class Parametric_parapiped : public Renderable_model, public Readable, public Writeable
{
public:

    Parametric_parapiped(double ix = 0.0, double iy = 0.0, double iz = 0.0, double iw = 1.0, double ih = 1.0, double il = 1.0,
                         double ipitch = 0.0, double iyaw = 0.0, double iroll = 0.0) throw(kjb::Illegal_argument);

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

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

    Parametric_parapiped(const Parametric_parapiped & src);
    virtual Parametric_parapiped & operator = (const Parametric_parapiped & src);

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

    virtual void read(const char * fname) throw (kjb::IO_error,  kjb::Illegal_argument)
    {
        Readable::read(fname);
    }

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

    virtual void write(const char * fname) const
       throw (kjb::IO_error)
    {
        Writeable::write(fname);
    }

    virtual Abstract_renderable & get_rendering_interface() const;

    Polymesh & get_polymesh() const
    {
        update_if_needed();
        return rendering_interface;
    }

    virtual void update_rendering_representation() const throw(kjb::KJB_error);

    virtual Parametric_parapiped * clone() const;
    virtual ~Parametric_parapiped() { }

    inline double get_width() const {return width; }
    inline double get_height() const {return height; }
    inline double get_length() const {return length; }

    inline double get_pitch() const {return rotation_angles(ST_PARAPIPED_PITCH);}
    inline double get_yaw() const {return rotation_angles(ST_PARAPIPED_YAW);}
    inline double get_roll() const {return rotation_angles(ST_PARAPIPED_ROLL);}

    inline const Vector & get_centre() const {return centre;}
    inline double get_centre_x() const {return centre(0); }
    inline double get_centre_y() const {return centre(1); }
    inline double get_centre_z() const {return centre(2); }

    void set_width(double iwidth) throw(kjb::Illegal_argument);
    void set_height(double iheight) throw(kjb::Illegal_argument);
    void set_length(double ilength)throw(kjb::Illegal_argument);

    void set_pitch(double ip);
    void set_yaw(double iy);
    void set_roll(double ir);

    virtual void rotate_around_x_axis(double theta);

    virtual void rotate_around_y_axis(double theta);

    virtual void rotate_around_z_axis(double theta);

    virtual void rotate_around_parapiped_axes(double thetax, double thetay, double thetaz);

    void set_centre(const kjb::Vector & icentre) throw(kjb::Illegal_argument);
    void set_centre_x(double ix) throw(kjb::Illegal_argument);
    void set_centre_y(double iy) throw(kjb::Illegal_argument);
    void set_centre_z(double iz) throw(kjb::Illegal_argument);

    virtual void set_angles_from_quaternion(const kjb::Quaternion & q);

    inline const kjb::Quaternion & get_rotations_as_a_quaternion() const
    {
        update_rendering_representation();
        return rendering_interface.get_orientation();
    }

    void set_rotation_mode(kjb::Quaternion::Euler_mode imode)
    {
        KJB(UNTESTED_CODE());
        rendering_interface.set_rotation_mode(imode);
    }

    void stretch_along_axis(unsigned int axis,  double amount, bool direction);

    void get_point_in_parapiped_coordinates
    (
        const kjb::Vector & point_in_world_coordinates,
        kjb::Vector & point_in_parapiped_coordinates
    ) const;

    void get_point_in_world_coordinates
    (
        const kjb::Vector & point_in_parapiped_coordinates,
        kjb::Vector & point_in_world_coordinates
    ) const;

    void draw_orientation_map() const;

    void draw_left_right_orientation_map() const;

    void draw_CMU_orientation_map() const;

    void draw_geometric_context_map() const;

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

    void get_vertices(std::vector<Vector> & vertices);

    static int get_num_rendering_interface_edges()
    {
        return Parapiped::get_num_edges();
    }

    static void get_rendering_interface_edge_indexes
    (
        std::vector<int> & base_edge_indexes,
        std::vector<int> & vertical_edge_indexes,
        std::vector<int> & top_edge_indexes
    )
    {
        Parapiped::get_edge_indexes(base_edge_indexes,
                vertical_edge_indexes, top_edge_indexes);
    }

private:

    void compute_new_euler_angles_on_rotations(double dpitch, double dyaw, double droll);

    double width;
    double height;
    double length;

    kjb::Vector centre;

    /* The rotation angle around the object's x axis (pitch), the
     * object's y axis (yaw) and the object's z axis (roll). Stored
     * in this order */
    kjb::Vector rotation_angles;

    mutable Parapiped rendering_interface;

};

double propose_parapiped_and_camera_from_orthogonal_corner_good
(
    kjb::Parametric_parapiped &pp,
    kjb::Perspective_camera & camera,
    const kjb::Manhattan_corner & corner,
    double focal_length,
    unsigned int num_rows,
    unsigned int num_cols,
    double corner_3D_z_position,
    double p_width_ratio,
    double p_height_ratio,
    double p_length_ratio
);

bool propose_parapiped_inside_parapiped_from_orthogonal_corner
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & imin_desired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    double distance_from_camera,
    bool expand_room = true
);

bool propose_frame_inside_parapiped_from_orthogonal_corner
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    unsigned int & face_number,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & idesired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols
);

bool propose_frame_inside_parapiped_from_orthogonal_corner_good
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    unsigned int & face_number,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & idesired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    bool wall_x,
    bool expand_to_the_ground
);

bool propose_parapiped_at_different_depth_from_orthogonal_corner
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped & pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & imin_desired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    double distance_from_camera,
    bool expand_room // if it is allowed to expand the room box 
);

bool propose_parapiped_onside_parapiped_from_orthogonal_corner
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped & pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & imin_desired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    double distance_from_camera,
    bool expand_sp_obj, // if it is allowed to expand the supporting object
    kjb::Vector & sp_obj_centre, // centre of the supporting object
    kjb::Vector & sp_obj_dimensions // dimensions of the supporting object
);

bool propose_supported_parapiped_inside_parapiped_from_orthogonal_corner
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    //kjb::Vector & expansion_deltas,
    //st::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped & pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & imin_desired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    double distance_from_camera,
    bool expand_sp_obj, // if it is allowed to expand the supporting object
    /*bool expand_right,
    bool expand_z_up,
    bool expand_towards_camera,*/
    kjb::Vector & sp_obj_centre, // centre of the supporting object
    kjb::Vector & sp_obj_dimensions // dimensions of the supporting object
);

bool propose_parapiped_inside_parapiped_from_orthogonal_corner_against_wall
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & imin_desired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    double distance_from_camera,
    bool expand_room,
    bool expand_right,
    bool expand_z_up,
    bool expand_towards_camera
);

bool propose_supported_parapiped_inside_parapiped_from_three_corners
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner1,
    const Manhattan_corner & corner2,
    const Manhattan_corner & corner3,
    double desired_height,
    unsigned int num_rows,
    unsigned int num_cols,
    double base_height
);

bool propose_parapiped_inside_parapiped_from_three_corners_on_the_floor
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner1,
    const Manhattan_corner & corner2,
    const Manhattan_corner & corner3,
    double desired_height,
    unsigned int num_rows,
    unsigned int num_cols
);

bool propose_parapiped_inside_parapiped_from_two_corners_on_the_floor
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner1,
    const Manhattan_corner & corner2,
    double desired_height,
    double desired_other_dimension_ratio,
    bool direction,
    bool & is_diagonal,
    bool & is_dx,
    unsigned int num_rows,
    unsigned int num_cols
);

    bool propose_parapiped_onside_parapiped_from_one_corner_in_the_center
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped & pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    const kjb::Vector & imin_desired_dimensions,
    unsigned int num_rows,
    unsigned int num_cols,
    double distance_from_camera,
    bool expand_sp_obj, // if it is allowed to expand the supporting object
    kjb::Vector & sp_obj_centre, // centre of the supporting object
    kjb::Vector & sp_obj_dimensions // dimensions of the supporting object
);

bool propose_parapiped_inside_parapiped_from_one_corner_in_the_centre_on_the_floor // one peg in the centre
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    kjb::Vector & expansion_deltas,
    std::vector<bool> & expansion_directions,
    Parametric_parapiped & new_pp,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    double desired_height,
    double desired_width,
    double desired_length,
    bool & is_dx,
    unsigned int num_rows,
    unsigned int num_cols
);

//bool propose_frustum_inside_parapiped_from_bounding_box_on_the_supporter // eg., the table lamp
//(
//    kjb::Vector & centre,
//    kjb::Vector & dimensions,
//    kjb::Vector & expansion_deltas,
//    std::vector<bool> & expansion_directions,
//    Parametric_parapiped & new_pp,
//    const Parametric_parapiped &pp,
//    const Perspective_camera & camera,
//    const kjb::Vector & bottom_center, // bottom center of the bounding box in the image plane
//    const kjb::Vector & top_center,
//    const int supporter_height           // the height of the supporter relative to the room box
//);

void expand_towards_camera
(
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & corner,
    unsigned int num_rows,
    unsigned int num_cols,
    bool & expand_tw_camera,
    bool & expand_right,
    bool & expand_z_up
);

double propose_parapiped_and_camera_from_vanishing_points
(
    kjb::Parametric_parapiped & pp,
    kjb::Perspective_camera & camera,
    const std::vector<Vanishing_point> & vpts,
    double focal_length,
    unsigned int num_rows,
    unsigned int num_cols
);

bool find_height_from_two_corners
(
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    const Manhattan_corner & floor_corner,
    const Manhattan_corner & top_corner,
    double & desired_height,
    unsigned int num_rows,
    unsigned int num_cols
);

bool shift_parapiped_to_match_corner
(
    kjb::Parametric_parapiped & pp,
    kjb::Perspective_camera & camera,
    unsigned int num_rows,
    unsigned int num_cols,
    const kjb::Vector & corner
);

bool propose_frame_inside_parapiped_from_three_corners_on_the_wall
(
    kjb::Vector & centre,
    kjb::Vector & dimensions,
    const Parametric_parapiped &pp,
    const Perspective_camera & camera,
    unsigned int & face_number,
    const Manhattan_corner & corner1,
    const Manhattan_corner & corner2,
    const Manhattan_corner & corner3,
    unsigned int num_rows,
    unsigned int num_cols
);

bool backproject_point_to_plane // find out the intersection between the view line and a plane in room coordinate
(
    kjb::Vector & intersection,
    kjb::Vector point2D,
    kjb::Vector plane,
    const Parametric_parapiped & pp,
    const Perspective_camera & camera,
    int num_rows,
    int num_cols
);

void update_focal_with_position(Perspective_camera& cam, double ifocal, Parametric_parapiped & pp);


}

#endif