Add interactive zoom_rect.
[scilab.git] / scilab / modules / renderer / src / cpp / subwinDrawing / Camera.h
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA - Jean-Baptiste Silvy 
4  * desc : File used to position viewpoint and rendering zone in the canvas
5  * 
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at    
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14
15 #ifndef _CAMERA_H_
16 #define _CAMERA_H_
17
18 #include "CameraBridge.h"
19 #include "../DrawableObject.h"
20
21 namespace sciGraphics
22 {
23   
24 class DrawableSubwin;
25
26 // here the drawn object is a subwindow since camera is part of DrawableSubwin
27 class Camera : public DrawableObject
28 {
29 public:
30   
31   Camera( sciPointObj * pObj ) ;
32
33   virtual ~Camera( void ) ;
34
35   /**
36    * Put back camera to default position.
37    */
38   void replaceCamera( void );
39
40   /**
41    * Convert user coordinates to pixel coordinates.
42    */
43   void getPixelCoordinates(const double userCoord[3], int pixCoord[2]);
44
45   /**
46    * Convert user coordinates to pixel coordinates including depth value
47    */
48   void getPixelCoordinates(const double userCoords[3], double pixCoords[3]);
49
50   /**
51    * Convert user coordinates to pixel coordinated using the 2d view.
52    */
53   void get2dViewPixelCoordinates(const double userCoord[3], int pixCoord[2]);
54
55   /**
56    * Unproject a 3 position in pixels into the standard scene coordinates
57    */
58  void getSceneCoordinates(const double pixCoords[3], double userCoords[3]);
59
60   /**
61    * Find coordinates in 2D view from pixel ones
62    */
63   void get2dViewCoordinates(const int pixCoords[2], double userCoord2D[2]);
64
65   /**
66    * Find the projection of user coords on the 2D frame.
67    */
68   void get2dViewCoordinates(const double userCoords[3], double coord2D[2]);
69
70
71   /**
72    * Draw the graphic handle and store it representation in memory
73    * for later faster drawing.
74    */
75   virtual void draw( void );
76
77   /**
78    * Fast draw of the graphic handle on the screen using the data created by draw.
79    * Warning, be sure that draw is called before show each time the handle is modified.
80    */
81   virtual void show( void );
82
83   /**
84    * Apply a zoom square on the axes box
85    * @param posX X coordinate of the lower left point of the zoom box in pixels.
86    * @param posY Y coordinate of the lower left point of the zoom box in pixels.
87    * @param width width of the zooming rectangle.
88    * @param height height of the zooming rectangle.
89    * @return true if the axes box has been zoomed, false otherwise
90    */
91   bool zoomRect(int posX, int posY, int width, int height);
92
93   /**
94    * Get the position and size of the rectangle in which the axes box must fit
95    */
96   void getViewingArea(int * xPos, int * yPos, int * width, int * height);
97
98 protected:
99
100   /**
101    * Set the viewing zone for a subwin.
102    * @param axesBounds axesBounds (WRECT) of the subwin. This a a vector [x_left,y_up,w,h].
103    * @param margins inside the axes bounds, set a surface to use.
104    *                This is a vector [margin_left, margin_right, margin_top, margin_bottom].
105    */
106   void setViewingArea( double axesBounds[4], double margins[4] ) ;
107
108   /**
109    * Set the rotation angles of the camera.
110    */
111   void setRotationAngles( double alpha, double theta ) ;
112
113   /**
114    * Specify which axes must be reversed.
115    */
116   void setAxesReverse(BOOL axesReverse[3]);
117
118   /**
119    * Specify the axes box to render.
120    * @param bounds [Xmin,Xmax,Ymin,Ymax,Zmin,Zmax] vector.
121    */
122   void setSubwinBox( double bounds[6] ) ;
123
124   /**
125    * Set camera parameters from subwin ones.
126    */
127   void setCameraParameters(void);
128
129   /**
130    * Position the view and view area accordingly to previous calls.
131    */
132   void renderPosition( void ) ;
133
134   /**
135    * Apply a zoom square on the axes box
136    * @param corners the 4 corners of the zooming rectangle in pixel
137    * @return true if the axes box has been zoomed, false otherwise
138    */
139   bool zoomRect(const double corners[4][2]);
140
141   /**
142    * Compute the lines composing the zooming selection area
143    * @param areaPixCorners corners of the selction rectangle in pixels
144    * @param areaLines 4 line composing the selection area in 3D
145    */
146   void computeZoomAreaLines(const double areaPixCorners[4][2], double areaLines[4][2][3]);
147
148   /**
149    * Compute the 4 intersections of the lines with an x = planeXcoord plane
150    * @param areaLines 4 lines composing the selection area in 3D
151    * @param planeXcoord either xMin or xMax
152    * @return false if no intersections could be computed (lines and plane are parallel)
153    */
154   bool getXaxisIntersections(const double areaLines[4][2][3], double planeXCoord, double intersections[4][3]);
155
156   /**
157    * Compute the 4 intersections of the lines with an y = planeYcoord plane
158    * @param areaLines 4 lines composing the selection area in 3D
159    * @param planeXcoord either yMin or yMax
160    * @return false if no intersections could be computed (lines and plane are parallel)
161    */
162   bool getYaxisIntersections(const double areaLines[4][2][3], double planeYCoord, double intersections[4][3]);
163
164   /**
165    * Compute the 4 intersections of the lines with an z = planeZcoord plane
166    * @param areaLines 4 lines composing the selection area in 3D
167    * @param planeXcoord either zMin or zMax
168    * @return false if no intersections could be computed (lines and plane are parallel)
169    */
170   bool getZaxisIntersections(const double areaLines[4][2][3], double planeZCoord, double intersections[4][3]);
171
172   /**
173    * Compute the intersection of the line defined by p1 and p2 knowing the alpha value
174    * @param intersection coordinates of the intersection
175    * @param alpha shuld be different than 1
176    */
177   void getIntersection(const double p1[3], const double p2[3], double alpha, double intersection[3]);
178
179   /**
180    * Update the new X bounds with 4 new intersections
181    * @param intersections intesection of the selection volume with a plane
182    * @param oldXMin previous minimal bound along X axis
183    * @param oldXMax previous maximal bound along X axis
184    * @param[in/out] newYmin currently computed minimum X bound
185    * @param[in/out] newYmax currently computed maximum X bound
186    */
187   void updateXCoordinate(const double intersections[4][3],
188                          double oldXmin, double oldXmax,
189                          double & newXmin, double & newXmax);
190
191   /**
192    * Update the new Y bounds with 4 new intersections
193    * @param intersections intesection of the selection volume with a plane
194    * @param oldYMin previous minimal bound along Y axis
195    * @param oldYMax previous maximal bound along Y axis
196    * @param[in/out] newYmin currently computed minimum Y bound
197    * @param[in/out] newYmax currently computed maximum Y bound
198    */
199   void updateYCoordinate(const double intersections[4][3],
200                          double oldYmin, double oldYmax,
201                          double & newYmin, double & newYmax);
202
203   /**
204    * Update the new z bounds with 4 new intersections
205    * @param intersections intesection of the selection volume with a plane
206    * @param oldMin previous minimal bound along Z axis
207    * @param oldMax previous maximal bound along Z axis
208    * @param[in/out] newYmin currently computed minimum Z bound
209    * @param[in/out] newYmax currently computed maximum Z bound
210    */
211   void updateZCoordinate(const double intersections[4][3],
212                          double oldZmin, double oldZmax,
213                          double & newZmin, double & newZmax);
214
215   /**
216    * test if part of the intersections is within a cube side
217    * with equatuion x = cst
218    * @return true if the intersection are within the side and
219    *              that intersections may be used to update data bounds
220    */
221   bool checkXIntersections(const double intersections[4][3],
222                            double oldYmin, double oldYmax,
223                            double oldZmin, double oldZmax);
224
225   /**
226    * test if part of the intersections is within a cube side
227    * with equatuion x = cst
228    * @return true if the intersection are within the side and
229    *              that intersections may be used to update data bounds
230    */
231   bool checkYIntersections(const double intersections[4][3],
232                            double oldXmin, double oldXmax,
233                            double oldZmin, double oldZmax);
234
235   /**
236    * test if part of the intersections is within a cube side
237    * with equatuion x = cst
238    * @return true if the intersection are within the side and
239    *              that intersections may be used to update data bounds
240    */
241   bool checkZIntersections(const double intersections[4][3],
242                            double oldXmin, double oldXmax,
243                            double oldYmin, double oldYmax);
244
245
246   /**
247    * Return the real type of implementation object
248    */
249   CameraBridge * getCameraImp( void ) ;
250
251 };
252
253 }
254
255 #endif /* _CAMERA_H_ */
256