defines a symmetric view with the following quantities: More...
#include <view.h>
Public Member Functions | |
| view () | |
| construct a parallel view with focus in the world origin looking in negative z-direction and the y-direction as up-direction with an extent of +-1 | |
getter and setter methods of view defining parameters | |
| const dvec3 & | get_focus () const |
| query focus point | |
| virtual void | set_focus (const dvec3 &foc) |
| set a new focus point keeping y extent at focus and y view angle fix, such that the eye position is also changed | |
| void | set_focus (const vec3 &foc) |
| void | set_focus (double x, double y, double z) |
| set focus from coordinates | |
| dvec3 & | ref_focus () |
| write access to focus point | |
| const dvec3 & | get_view_dir () const |
| query current view direction | |
| virtual void | set_view_dir (const dvec3 &vd) |
| set view direction without ensuring orthogonality to view up direction | |
| void | set_view_dir (const vec3 &vd) |
| void | set_view_dir (double x, double y, double z) |
| set view direction from coordinates | |
| dvec3 & | ref_view_dir () |
| write access to view dir | |
| const dvec3 & | get_view_up_dir () const |
| query current view up direction | |
| virtual void | set_view_up_dir (const dvec3 &vud) |
| set view up direction without ensuring orthogonality to view direction | |
| void | set_view_up_dir (const vec3 &vud) |
| void | set_view_up_dir (double x, double y, double z) |
| set view up direction from coordinates | |
| dvec3 & | ref_view_up_dir () |
| write access to view up direction | |
| double & | ref_y_extent_at_focus () |
| write access to extent at focus | |
| double | get_y_view_angle () const |
| query opening angle (degrees) of view in y-direction | |
| virtual void | set_y_view_angle (double angle) |
| set opening angle (degrees) of view in y-direction keeping y extent at focus resulting in a dolly zoom | |
| double | get_y_extent_at_focus () const |
| query y extent of viewing window at focus point | |
| virtual void | set_y_extent_at_focus (double ext) |
| set y extent of viewing window at focus point keeping y view angle resulting in a zoom | |
| double & | ref_y_view_angle () |
| write access to view angle | |
derived quantities | |
| double | get_tan_of_half_of_fovy (bool ensure_non_zero) const |
| compute tan of half of y view angle, if ensure_non_zero is true, replace y view angles < 0.1 with 0.1 | |
| double | get_y_extent_at_depth (double depth, bool ensure_non_zero) const |
| get y extent of viewing window at an arbitrary depth, if ensure_non_zero is true, replace y view angles < 0.1 with 0.1 | |
| double | get_depth_of_focus () const |
| return the depth of the focus point | |
| void | put_coordinate_system (dvec3 &x, dvec3 &y, dvec3 &z) const |
| construct coordinate system with z in negative view direction and x and y aligned with the right and up direction of the viewed image | |
| void | put_coordinate_system (vec3 &x, vec3 &y, vec3 &z) const |
| int | compute_axis_and_angle (const dvec3 &target_view_dir, const dvec3 &target_view_up_dir, dvec3 &axis, double &angle) |
| compute axis and angle of a rotation that the current view_dir and view_up_dir to the given target_view_dir and target_view_up_dir | |
| bool | is_parallel () const |
| return whether the y view angle is zero | |
| const dvec3 | get_eye () const |
| query the eye point, which is computed from focus, view dir, y extent at focus and y view angle | |
| bool | set_eye_keep_extent (const dvec3 &eye) |
| set view dir and y view angle keeping focus and y extent such that get_eye() returns the passed point, return whether this was successful. | |
| bool | set_eye_keep_view_angle (const dvec3 &eye) |
| set the view dir and y extent at focus keeping focus and y view angle such that get_eye() returns the passed point, return whether this was successful. | |
| void | view_look_at_keep_view_angle (const dvec3 &eye, const dvec3 &foc, const dvec3 &vud) |
| set the view according to the standard view lookat definition from eye, focus and view up direction keeping the y-extent at the focus point constant | |
| void | view_look_at_keep_extent (const dvec3 &eye, const dvec3 &foc, const dvec3 &vud) |
| set the view according to the standard view lookat definition from eye, focus and view up direction keeping the y-view angle constant | |
view control | |
| void | roll (double angle) |
| roll view around view direction by angle | |
| void | rotate (double axis_direction_x, double axis_direction_y, double axis_point_depth) |
| rotated view around axis by angle | |
| void | move (double step) |
| move along view direction by given step length in world coordinates | |
| void | pan (double step_x, double step_y) |
| move in screen x and screen y directions by given step lengths in world coordinates | |
| void | zoom (double factor) |
| zoom by given factor | |
viewport splitting | |
| virtual void | enable_viewport_splitting (unsigned nr_cols, unsigned nr_rows) |
| call this function before a drawing process to support viewport splitting inside the draw call via the activate/deactivate functions | |
| virtual bool | is_viewport_splitting_enabled (unsigned *nr_cols_ptr=0, unsigned *nr_rows_ptr=0) const |
| check whether viewport splitting is activated and optionally set the number of columns and rows if corresponding pointers are passed | |
| virtual void | disable_viewport_splitting () |
| disable viewport splitting | |
| virtual void | activate_split_viewport (context &ctx, unsigned col_index, unsigned row_index) |
| inside the drawing process activate the sub-viewport with the given column and row indices, always terminate an activated viewport with deactivate_split_viewport | |
| virtual void | deactivate_split_viewport (context &ctx) |
| deactivate the previously split viewport | |
| virtual void | enable_viewport_individual_view (unsigned col_index, unsigned row_index, bool enable=true) |
| make a viewport manage its own view | |
| virtual bool | does_viewport_use_individual_view (unsigned col_index, unsigned row_index) const |
| check whether viewport manage its own view | |
| virtual view & | ref_viewport_view (unsigned col_index, unsigned row_index) |
| access the view of a given viewport | |
| virtual int | get_modelview_projection_window_matrices (int x, int y, int width, int height, const dmat4 **MPW_pptr, const dmat4 **MPW_other_pptr=0, int *x_other_ptr=0, int *y_other_ptr=0, int *vp_col_idx_ptr=0, int *vp_row_idx_ptr=0, int *vp_width_ptr=0, int *vp_height_ptr=0, int *vp_center_x_ptr=0, int *vp_center_y_ptr=0, int *vp_center_x_other_ptr=0, int *vp_center_y_other_ptr=0) const |
| given an opengl pixel location and the size in pixels of the opengl window, return the modelview_projection_window matrix for unprojection | |
| virtual int | get_modelview_projection_device_matrices (int x, int y, int width, int height, const dmat4 **MVPD_pptr, const dmat4 **MVPD_other_pptr=0, int *x_other_ptr=0, int *y_other_ptr=0, int *vp_col_idx_ptr=0, int *vp_row_idx_ptr=0, int *vp_width_ptr=0, int *vp_height_ptr=0, int *vp_center_x_ptr=0, int *vp_center_y_ptr=0, int *vp_center_x_other_ptr=0, int *vp_center_y_other_ptr=0) const |
| virtual double | get_z_and_unproject (context &ctx, int x, int y, dvec3 &p) |
| given an opengl pixel location x,y return the window z-value from the depth buffer | |
| double | get_z_and_unproject (context &ctx, int x, int y, vec3 &p) |
| void | compute_screen_rectangle (std::vector< dvec3 > &rect, double depth, double aspect) const |
fill rect with four points covering the screen rectangle at given depth from eye with given aspect ratio | |
| void | compute_screen_rectangle (std::vector< vec3 > &rect, double depth, double aspect) const |
Protected Attributes | |
| dvec3 | focus |
| focus of the view | |
| dvec3 | view_up_dir |
| dvec3 | view_dir |
| double | y_view_angle |
| double | y_extent_at_focus |
Detailed Description
defines a symmetric view with the following quantities:
- focus ... world location of interest which projects to the center of the view
- view direction ... view direction in the center of the view given in world coordinates
- view up direction ... upward direction in world coordinates that defines the y-direction
- y_view_angle ... opening angle of the view in y-direction
- y_extent_at_focus ... world extent in y-direction at the focus which fills the view completely
Constructor & Destructor Documentation
◆ view()
| cgv::render::view::view | ( | ) |
Member Function Documentation
◆ activate_split_viewport()
|
virtual |
◆ compute_axis_and_angle()
| int cgv::render::view::compute_axis_and_angle | ( | const dvec3 & | target_view_dir, |
| const dvec3 & | target_view_up_dir, | ||
| dvec3 & | axis, | ||
| double & | angle | ||
| ) |
compute axis and angle of a rotation that the current view_dir and view_up_dir to the given target_view_dir and target_view_up_dir
returns the result of the function cgv::math::decompose_rotation_to_axis_and_angle()
Definition at line 27 of file view.cxx.
References cgv::math::fmat< T, N, M >::transpose().
Referenced by cgv::app::navigator::handle_mouse_event().
◆ compute_screen_rectangle() [1/2]
| void cgv::render::view::compute_screen_rectangle | ( | std::vector< dvec3 > & | rect, |
| double | depth, | ||
| double | aspect | ||
| ) | const |
fill rect with four points covering the screen rectangle at given depth from eye with given aspect ratio
fill the given vector with four points covering the screen rectangle
Definition at line 304 of file view.cxx.
References get_eye(), get_y_extent_at_depth(), and put_coordinate_system().
◆ compute_screen_rectangle() [2/2]
| void cgv::render::view::compute_screen_rectangle | ( | std::vector< vec3 > & | rect, |
| double | depth, | ||
| double | aspect | ||
| ) | const |
◆ deactivate_split_viewport()
|
virtual |
◆ disable_viewport_splitting()
|
virtual |
◆ does_viewport_use_individual_view()
|
virtual |
◆ enable_viewport_individual_view()
|
virtual |
◆ enable_viewport_splitting()
|
virtual |
◆ get_depth_of_focus()
| double cgv::render::view::get_depth_of_focus | ( | ) | const |
return the depth of the focus point
Definition at line 73 of file view.cxx.
References get_tan_of_half_of_fovy().
◆ get_eye()
| const dvec3 cgv::render::view::get_eye | ( | ) | const |
query the eye point, which is computed from focus, view dir, y extent at focus and y view angle
With the y view angle approaching 0, the eye point moves infinitely far away. To avoid numerical problems, the eye point is computed with an y view angle no less than 0.1.
Definition at line 123 of file view.cxx.
References focus, and get_tan_of_half_of_fovy().
Referenced by cgv::render::clipped_view::compute_clipping_planes(), compute_screen_rectangle(), cgv::app::gizmo::finish_frame(), cgv::render::stereo_view::get_parallax_zero_depth(), cgv::app::gizmo::handle(), cgv::app::navigator::handle_mouse_event(), and rotate().
◆ get_focus()
| const dvec3 & cgv::render::view::get_focus | ( | ) | const |
query focus point
Definition at line 48 of file view.cxx.
References focus.
Referenced by cgv::render::stereo_view::get_parallax_zero_depth(), and cgv::app::navigator::handle_mouse_event().
◆ get_modelview_projection_device_matrices()
|
inlinevirtual |
◆ get_modelview_projection_window_matrices()
|
virtual |
given an opengl pixel location and the size in pixels of the opengl window, return the modelview_projection_window matrix for unprojection
In stereo modes with split viewport, the returned MPW is the one opengl pixel location is in. The return value is in this case -1 or 1 and tells if MPW corresponds to the left (-1) or right (1) viewport. Furthermore, the MPW of the corresponding opengl pixel location in the other eye is returned through MPW_other_ptr and the opengl pixel location in x_other_ptr and y_other_ptr. In anaglyph or quad buffer stereo mode the other mouse location is identical to the incoming x and y location and 0 is returned. In mono mode, the other MPW and mouse locations are set to values identical to MPW and x,y and also 0 is returned.
In case the viewport splitting was enabled during the last drawing process, the MPW and MPW_other matrices are set to the one valid in the panel that the opengl pixel location x,y is in. The panel column and row indices (counting from bottom to top as in opengl) are passed to the vp_col_idx and vp_row_idx pointers. In case that viewport splitting was disabled, 0 is passed to the panel location index pointers.
Finally, the vp_width, vp_height, vp_center_x, and vp_center_y pointers are set to the viewport size and center mouse location of the panel panel that the mouse pointer is in.
All pointer arguments starting with MPW_other_ptr can be set to the null pointer.
Definition at line 277 of file view.cxx.
Referenced by cgv::render::drawable::get_world_location().
◆ get_tan_of_half_of_fovy()
| double cgv::render::view::get_tan_of_half_of_fovy | ( | bool | ensure_non_zero | ) | const |
compute tan of half of y view angle, if ensure_non_zero is true, replace y view angles < 0.1 with 0.1
Definition at line 42 of file view.cxx.
Referenced by cgv::app::gizmo::finish_frame(), get_depth_of_focus(), get_eye(), and get_y_extent_at_depth().
◆ get_view_dir()
| const dvec3 & cgv::render::view::get_view_dir | ( | ) | const |
query current view direction
Definition at line 58 of file view.cxx.
Referenced by cgv::render::clipped_view::compute_clipping_planes(), and cgv::app::gizmo::finish_frame().
◆ get_view_up_dir()
| const dvec3 & cgv::render::view::get_view_up_dir | ( | ) | const |
◆ get_y_extent_at_depth()
| double cgv::render::view::get_y_extent_at_depth | ( | double | depth, |
| bool | ensure_non_zero | ||
| ) | const |
get y extent of viewing window at an arbitrary depth, if ensure_non_zero is true, replace y view angles < 0.1 with 0.1
Definition at line 79 of file view.cxx.
References get_tan_of_half_of_fovy().
Referenced by compute_screen_rectangle(), and set_eye_keep_view_angle().
◆ get_y_extent_at_focus()
| double cgv::render::view::get_y_extent_at_focus | ( | ) | const |
◆ get_y_view_angle()
| double cgv::render::view::get_y_view_angle | ( | ) | const |
◆ get_z_and_unproject() [1/2]
given an opengl pixel location x,y return the window z-value from the depth buffer
given a pixel location x,y return the z-value from the depth buffer, which ranges from 0.0 at z_near to 1.0 at z_far and a point in world coordinates
in case of stereo rendering two z-values exist that can be unprojected to two points in world coordinates. In this case the possibility with smaller z value is selected.
◆ get_z_and_unproject() [2/2]
◆ is_parallel()
| bool cgv::render::view::is_parallel | ( | ) | const |
◆ is_viewport_splitting_enabled()
|
virtual |
◆ move()
| void cgv::render::view::move | ( | double | step | ) |
◆ pan()
| void cgv::render::view::pan | ( | double | step_x, |
| double | step_y | ||
| ) |
move in screen x and screen y directions by given step lengths in world coordinates
Definition at line 264 of file view.cxx.
References focus, and put_coordinate_system().
◆ put_coordinate_system() [1/2]
construct coordinate system with z in negative view direction and x and y aligned with the right and up direction of the viewed image
If view direction and view up direction are not orthogonal, the y direction will point in the component of the view up direction that is orthogonal to the view direction.
Definition at line 211 of file view.cxx.
References cgv::math::fvec< T, N >::normalize().
Referenced by compute_screen_rectangle(), pan(), and rotate().
◆ put_coordinate_system() [2/2]
◆ ref_focus()
| dvec3 & cgv::render::view::ref_focus | ( | ) |
◆ ref_view_dir()
| dvec3 & cgv::render::view::ref_view_dir | ( | ) |
write access to view dir
Definition at line 20 of file view.cxx.
Referenced by cgv::app::navigator::handle_mouse_event().
◆ ref_view_up_dir()
| dvec3 & cgv::render::view::ref_view_up_dir | ( | ) |
write access to view up direction
Definition at line 18 of file view.cxx.
Referenced by cgv::app::navigator::handle_mouse_event().
◆ ref_viewport_view()
|
virtual |
◆ ref_y_extent_at_focus()
| double & cgv::render::view::ref_y_extent_at_focus | ( | ) |
◆ ref_y_view_angle()
| double & cgv::render::view::ref_y_view_angle | ( | ) |
◆ roll()
| void cgv::render::view::roll | ( | double | angle | ) |
◆ rotate()
| void cgv::render::view::rotate | ( | double | axis_direction_x, |
| double | axis_direction_y, | ||
| double | axis_point_depth | ||
| ) |
rotated view around axis by angle
Axis is given by point and direction, where the point is in the image center and the given depth and the axis points into a direction in image plane given through its screen x and screen y coordinate. The length of the axis vector gives the rotation angle in radians. Rotation around screen x direction corresponds to yaw and around screen y direction to gear rotations.
Definition at line 242 of file view.cxx.
References focus, get_eye(), cgv::math::fvec< T, N >::length(), and put_coordinate_system().
◆ set_eye_keep_extent()
| bool cgv::render::view::set_eye_keep_extent | ( | const dvec3 & | eye | ) |
set view dir and y view angle keeping focus and y extent such that get_eye() returns the passed point, return whether this was successful.
Recomputes view up direction to make it orthogonal to view direction. In the case that the eye point is identical to the current focus point the function fails and returns false.
Definition at line 148 of file view.cxx.
References focus, and cgv::math::fvec< T, N >::length().
Referenced by view_look_at_keep_extent().
◆ set_eye_keep_view_angle()
| bool cgv::render::view::set_eye_keep_view_angle | ( | const dvec3 & | eye | ) |
set the view dir and y extent at focus keeping focus and y view angle such that get_eye() returns the passed point, return whether this was successful.
Recomputes view up direction to make it orthogonal to view direction. In the case that the eye point is identical to the current focus point the function fails and returns false. If the current view angle is < 0.1, the view anlge 0.1 is used for eye point calculation
Definition at line 132 of file view.cxx.
References focus, get_y_extent_at_depth(), and cgv::math::fvec< T, N >::length().
Referenced by view_look_at_keep_view_angle().
◆ set_focus() [1/3]
|
virtual |
set a new focus point keeping y extent at focus and y view angle fix, such that the eye position is also changed
Definition at line 85 of file view.cxx.
References focus.
Referenced by cgv::render::clipped_view::set_default_view(), set_focus(), view_look_at_keep_extent(), and view_look_at_keep_view_angle().
◆ set_focus() [2/3]
◆ set_focus() [3/3]
| void cgv::render::view::set_focus | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
◆ set_view_dir() [1/3]
|
virtual |
set view direction without ensuring orthogonality to view up direction
Definition at line 98 of file view.cxx.
Referenced by cgv::render::clipped_view::set_default_view(), and set_view_dir().
◆ set_view_dir() [2/3]
|
inline |
◆ set_view_dir() [3/3]
| void cgv::render::view::set_view_dir | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
set view direction from coordinates
Definition at line 102 of file view.cxx.
References set_view_dir().
◆ set_view_up_dir() [1/3]
|
virtual |
set view up direction without ensuring orthogonality to view direction
Definition at line 92 of file view.cxx.
Referenced by cgv::render::clipped_view::set_default_view(), set_view_up_dir(), view_look_at_keep_extent(), and view_look_at_keep_view_angle().
◆ set_view_up_dir() [2/3]
|
inline |
◆ set_view_up_dir() [3/3]
| void cgv::render::view::set_view_up_dir | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
set view up direction from coordinates
Definition at line 96 of file view.cxx.
References set_view_up_dir().
◆ set_y_extent_at_focus()
|
virtual |
set y extent of viewing window at focus point keeping y view angle resulting in a zoom
Definition at line 104 of file view.cxx.
Referenced by cgv::render::clipped_view::set_default_view().
◆ set_y_view_angle()
|
virtual |
◆ view_look_at_keep_extent()
| void cgv::render::view::view_look_at_keep_extent | ( | const dvec3 & | eye, |
| const dvec3 & | foc, | ||
| const dvec3 & | vud | ||
| ) |
set the view according to the standard view lookat definition from eye, focus and view up direction keeping the y-view angle constant
set the view according to the standard view lookat definition from eye, focus and view up direction.
Definition at line 161 of file view.cxx.
References set_eye_keep_extent(), set_focus(), and set_view_up_dir().
◆ view_look_at_keep_view_angle()
| void cgv::render::view::view_look_at_keep_view_angle | ( | const dvec3 & | eye, |
| const dvec3 & | foc, | ||
| const dvec3 & | vud | ||
| ) |
set the view according to the standard view lookat definition from eye, focus and view up direction keeping the y-extent at the focus point constant
set the view according to the standard view lookat definition from eye, focus and view up direction.
Definition at line 169 of file view.cxx.
References set_eye_keep_view_angle(), set_focus(), and set_view_up_dir().
◆ zoom()
| void cgv::render::view::zoom | ( | double | factor | ) |
Member Data Documentation
◆ focus
|
protected |
focus of the view
Definition at line 25 of file view.h.
Referenced by get_eye(), get_focus(), move(), pan(), ref_focus(), rotate(), set_eye_keep_extent(), set_eye_keep_view_angle(), and set_focus().
◆ view_dir
◆ view_up_dir
◆ y_extent_at_focus
◆ y_view_angle
The documentation for this class was generated from the following files:
