0025775: "Default Gradient Background" in V3d_Viewer has no effect in new created...
[occt.git] / src / V3d / V3d_View.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 /***********************************************************************
15 FONCTION :
16 ----------
17 Classe V3d_View :
18 HISTORIQUE DES MODIFICATIONS   :
19 --------------------------------
20 00-09-92 : GG  ; Creation.
21 02-10-96 : FMN ; Suppression appel Redraw sans MustBeResized()
22 05-06-97 : FMN ; Correction FitAll()
23 30-06-97 : GG ; Correction + Optimisation de Panning(...)
24 On fait la translation + le zoom en une seule
25 operation au lieu de 2 precedemment qui etait buggee.
26 09-07-97 : FMN ; Correction FitAll() sur le Ratio
27 16-07-97 : FMN ; Correction FitAll() sur le calcul de la Box
28 22-07-97 : FMN ; Ajout mode RetainMode pour le Transient
29 15-12-97 : FMN ; Ajout texture mapping
30 17-12-97 : FMN ; CTS19129 Correction FitAll() multiple
31 18-12-97 : FMN ; Ajout mode Ajout
32 24-12-97 : FMN ; Remplacement de math par MathGra
33 24-12-97 : CQO ; BUC50037 Xw_Window -> Aspect_Window
34 31-12-97 : CAL ; Remplacement de MathGra par Array2OfReal
35 07-01-98 : CAL ; Ajout de la methode DoMapping.
36 07-01-98 : CAL ; Retrait de tous les "this->" inutiles
37 21-01-98 : CAL ; Remplacement des Window->Position () par Window->Size ()
38 27-01-98 : FMN ; PERF: OPTIMISATION LOADER (LOPTIM)
39 12-02-98 : GG  ; Reactivation du Redraw dans MustBeResized()
40 23-02-98 : FMN ; Remplacement PI par Standard_PI
41 25-02-98 : FMN ; PERF.27: Optimisation of view creation from existing view
42 11-03-98 : STT ; S3558
43 19-03-98 : FMN ; Probleme dans FitAll car la methode WNT_Window::Size(Real,Real)
44 ne marche pas.
45 08-04-98 : STT ; suppr. S3558
46 10-04-98 : CAL ; Ajout des methodes RefToPix et PixToRef
47 13-06-98 : FMN ; Probleme dans FitAll car la methode WNT_Window::Size(Real,Real)
48 ne marche pas. Contournement en appelant WNT_Window::Size(Int,Int).
49 16-08-98 : CAL ; S3892. Ajout grilles 3d.
50 09-09-98 : CAL ; S3892. Generalisation de TrsPoint.
51 06-10-98 : CAL ; Ajout d'un TIMER si CSF_GraphicTimer est definie.
52 16-10-98 : CAL ; Retrait d'un TIMER si CSF_GraphicTimer est definie.
53 06-11-98 : CAL ; PRO ?????. Probleme dans ZFitAll si un point dans la vue.
54 29-OCT-98 : DCB : Adding ScreenCopy () method.
55 REMARQUES :
56 -----------
57 About  FitAll() multiple. This probleme is caused by missing
58 precision of transformation matrices. If it is supposed that
59 projection is made in the plane (U,V), there is a difference
60 after several Zoom - compared to the exact value (cf ZoomX).
61 Don't forget that the matrices work in float and not in double.
62 To solve the problem (for lack of a better solution) I make 2 passes.
63 ************************************************************************/
64 /*----------------------------------------------------------------------*/
65 /*
66 * Includes
67 */
68
69 #include <Aspect_ColorScale.hxx>
70 #include <Aspect_GradientBackground.hxx>
71 #include <Aspect_Grid.hxx>
72 #include <Aspect_Window.hxx>
73 #include <Bnd_Box.hxx>
74 #include <gp_Ax3.hxx>
75 #include <gp_Dir.hxx>
76 #include <gp_Pln.hxx>
77 #include <Graphic3d_AspectMarker3d.hxx>
78 #include <Graphic3d_GraphicDriver.hxx>
79 #include <Graphic3d_Group.hxx>
80 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
81 #include <Graphic3d_MapOfStructure.hxx>
82 #include <Graphic3d_Structure.hxx>
83 #include <Graphic3d_TextureEnv.hxx>
84 #include <Graphic3d_Vector.hxx>
85 #include <Image_AlienPixMap.hxx>
86 #include <NCollection_Array1.hxx>
87 #include <Precision.hxx>
88 #include <Quantity_Color.hxx>
89 #include <Standard_Assert.hxx>
90 #include <Standard_DivideByZero.hxx>
91 #include <Standard_ErrorHandler.hxx>
92 #include <Standard_MultiplyDefined.hxx>
93 #include <Standard_ShortReal.hxx>
94 #include <Standard_Type.hxx>
95 #include <Standard_TypeMismatch.hxx>
96 #include <TColStd_Array2OfReal.hxx>
97 #include <TColStd_HSequenceOfInteger.hxx>
98 #include <V3d.hxx>
99 #include <V3d_BadValue.hxx>
100 #include <V3d_LayerMgr.hxx>
101 #include <V3d_Light.hxx>
102 #include <V3d_StereoDumpOptions.hxx>
103 #include <V3d_UnMapped.hxx>
104 #include <V3d_View.hxx>
105 #include <V3d_Viewer.hxx>
106 #include <Visual3d_Layer.hxx>
107 #include <Visual3d_Light.hxx>
108 #include <Visual3d_View.hxx>
109 #include <Visual3d_ViewManager.hxx>
110
111 #define V3d_FLAG_COMPUTATION   0x00000004
112
113 // Perspective
114 #include <OSD_Environment.hxx>
115
116 /*----------------------------------------------------------------------*/
117 /*
118 * Constant
119 */
120
121 #define DEUXPI (2. * M_PI)
122
123 namespace
124 {
125   static const Standard_Integer THE_NB_BOUND_POINTS = 8;
126 }
127
128 //=============================================================================
129 //function : Constructor
130 //purpose  :
131 //=============================================================================
132 V3d_View::V3d_View(const Handle(V3d_Viewer)& VM, const V3d_TypeOfView Type ) :
133   MyViewer(VM.operator->()),
134   MyActiveLights(),
135   MyViewContext (),
136   myActiveLightsIterator(),
137   SwitchSetFront(Standard_False),
138   MyTrsf (1, 4, 1, 4)
139 {
140   myImmediateUpdate = Standard_False;
141   MyView = new Visual3d_View(MyViewer->Viewer());
142
143   // { Begin to retrieve the definition from ViewContext.
144   // Step MyViewContext = MyView->Context() ;
145   // to permit MyView->SetContext to compare
146   // the old and the new context.
147   // No problem for MyViewMapping, MyViewOrientation
148   // as MyView->SetViewMapping and MyView->SetViewOrientation
149   // don't try to optimize the modifications introduced to
150   // viewmapping and vieworientation.
151
152   // Aliasing
153   if ((MyView->Context ()).AliasingIsOn ())
154     MyViewContext.SetAliasingOn ();
155   else
156     MyViewContext.SetAliasingOff ();
157
158   // DepthCueing
159   MyViewContext.SetDepthCueingBackPlane
160     ((MyView->Context ()).DepthCueingBackPlane ());
161   MyViewContext.SetDepthCueingFrontPlane
162     ((MyView->Context ()).DepthCueingFrontPlane ());
163
164   if ((MyView->Context ()).DepthCueingIsOn ())
165     MyViewContext.SetDepthCueingOn ();
166   else
167     MyViewContext.SetDepthCueingOff ();
168
169   // ZClipping
170   MyViewContext.SetZClippingBackPlane
171     ((MyView->Context ()).ZClippingBackPlane ());
172   MyViewContext.SetZClippingFrontPlane
173     ((MyView->Context ()).ZClippingFrontPlane ());
174
175   if ((MyView->Context ()).FrontZClippingIsOn ())
176     MyViewContext.SetFrontZClippingOn ();
177   else
178     MyViewContext.SetFrontZClippingOff ();
179
180   if ((MyView->Context ()).BackZClippingIsOn ())
181     MyViewContext.SetBackZClippingOn ();
182   else
183     MyViewContext.SetBackZClippingOff ();
184
185   // Visualization and Shading Model
186   MyViewContext.SetModel ((MyView->Context ()).Model ());
187   MyViewContext.SetVisualization ((MyView->Context ()).Visualization ());
188
189   // Texture Mapping
190   MyViewContext.SetSurfaceDetail (MyView->Context ().SurfaceDetail ());
191   MyViewContext.SetTextureEnv (MyView->Context ().TextureEnv ());
192   // } End of retrieval of the definition of ViewContext.
193
194   MyBackground = VM->GetBackgroundColor() ;
195   MyGradientBackground = VM->GetGradientBackground() ;
196
197   // camera init
198   Handle(Graphic3d_Camera) aCamera = new Graphic3d_Camera();
199   aCamera->SetFOVy (45.0);
200   aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, 0.05);
201   aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, 1.0);
202   SetCamera (aCamera);
203
204   SetAxis (0.,0.,0.,1.,1.,1.);
205   SetVisualization (VM->DefaultVisualization());
206   SetShadingModel (VM->DefaultShadingModel());
207   SetSurfaceDetail (VM->DefaultSurfaceDetail());
208   SetTwist (0.);
209   SetAt (0.,0.,0.);
210   SetProj (VM->DefaultViewProj());
211   SetSize (VM->DefaultViewSize());
212   Standard_Real zsize = VM->DefaultViewSize();
213   SetZSize (2.*zsize);
214   SetZClippingDepth (0.);
215   SetZClippingWidth (zsize);
216   SetZCueingDepth (0.);
217   SetZCueingWidth (zsize);
218   SetDepth (VM->DefaultViewSize()/2.0);
219   SetViewMappingDefault();
220   SetViewOrientationDefault();
221   VM->AddView (this);
222   Init();
223   myImmediateUpdate = Standard_True;
224
225   aCamera->SetProjectionType ((Type == V3d_ORTHOGRAPHIC)
226     ? Graphic3d_Camera::Projection_Orthographic
227     : Graphic3d_Camera::Projection_Perspective);
228 }
229
230 //=============================================================================
231 //function : Constructor
232 //purpose  :
233 //=============================================================================
234 V3d_View::V3d_View(const Handle(V3d_Viewer)& theVM,const Handle(V3d_View)& theView) :
235   MyViewer(theVM.operator->()),
236   MyActiveLights(),
237   MyViewContext (),
238   myActiveLightsIterator(),
239   SwitchSetFront(Standard_False),
240   MyTrsf (1, 4, 1, 4)
241 {
242   Handle(Visual3d_View) aFromView = theView->View();
243
244   myImmediateUpdate = Standard_False;
245   MyView = new Visual3d_View (MyViewer->Viewer());
246
247   for (theView->InitActiveLights(); theView->MoreActiveLights(); theView->NextActiveLights())
248   {
249     MyActiveLights.Append (theView->ActiveLight());
250   }
251
252   MyViewContext = aFromView->Context() ;
253
254   SetCamera (new Graphic3d_Camera (theView->Camera()));
255   View()->SetAutoZFitMode (theView->View()->AutoZFitMode(), theView->View()->AutoZFitScaleFactor());
256
257   MyBackground = aFromView->Background() ;
258   MyGradientBackground = aFromView->GradientBackground();
259
260   MyView->SetContext (MyViewContext) ;
261
262   SetAxis (0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
263
264   SetViewMappingDefault();
265   SetViewOrientationDefault();
266   theVM->AddView (this);
267
268   Init();
269
270   myImmediateUpdate = Standard_True;
271 }
272
273 //=============================================================================
274 //function : SetMagnify
275 //purpose  :
276 //=============================================================================
277 void V3d_View::SetMagnify(const Handle(Aspect_Window)& TheWindow,
278                           const Handle(V3d_View)& aPreviousView,
279                           const Standard_Integer x1,
280                           const Standard_Integer y1,
281                           const Standard_Integer x2,
282                           const Standard_Integer y2)
283 {
284   if( !MyView->IsDefined() ) {
285     Standard_Real a,b,c,d;
286     aPreviousView->Convert(x1,y1,a,b);
287     aPreviousView->Convert(x2,y2,c,d);
288     MyView->SetWindow(TheWindow) ;
289     FitAll(TheWindow,a,b,c,d);
290     MyView->SetContext(MyViewContext) ;
291     MyView->SetBackground(MyBackground) ;
292     MyViewer->SetViewOn(this) ;
293     MyWindow = TheWindow;
294     MyView->Redraw() ;
295     SetViewMappingDefault();
296   }
297 }
298
299 //=============================================================================
300 //function : SetWindow
301 //purpose  :
302 //=============================================================================
303 void V3d_View::SetWindow(const Handle(Aspect_Window)& TheWindow)
304 {
305   MyView->SetWindow(TheWindow) ;
306   // method V3d_View::SetWindow() should assign the field MyWindow before calling Redraw()
307   MyWindow = TheWindow;
308   // SetWindow carries out SetRatio and modifies
309   MyView->SetContext(MyViewContext) ;
310   MyView->SetBackground(MyBackground) ;
311   MyView->SetGradientBackground (MyGradientBackground, Standard_False);
312   MyViewer->SetViewOn(this) ;
313   MyView->Redraw() ;
314 }
315
316 //=============================================================================
317 //function : SetWindow
318 //purpose  :
319 //=============================================================================
320 void V3d_View::SetWindow(const Handle(Aspect_Window)&      aWindow,
321                          const Aspect_RenderingContext     aContext,
322                          const Aspect_GraphicCallbackProc& aDisplayCB,
323                          const Standard_Address            aClientData)
324 {
325   // method V3d_View::SetWindow() should assign the field MyWindow before calling Redraw()
326   MyWindow = aWindow;
327   MyView->SetWindow(aWindow, aContext, aDisplayCB, aClientData) ;
328   MyView->SetContext(MyViewContext) ;
329   MyView->SetBackground(MyBackground) ;
330   MyViewer->SetViewOn(this) ;
331   MyView->Redraw() ;
332 }
333
334 //=============================================================================
335 //function : Remove
336 //purpose  :
337 //=============================================================================
338 void V3d_View::Remove() const
339 {
340   MyViewer->DelView (this);
341   MyView->Remove();
342   Handle(Aspect_Window)& aWin = const_cast<Handle(Aspect_Window)&> (MyWindow);
343   aWin.Nullify();
344 }
345
346 //=============================================================================
347 //function : Update
348 //purpose  :
349 //=============================================================================
350 void V3d_View::Update() const
351 {
352   if( MyView->IsDefined() )  MyView->Update (Aspect_TOU_ASAP) ;
353 }
354
355 //=============================================================================
356 //function : Redraw
357 //purpose  :
358 //=============================================================================
359 void V3d_View::Redraw() const
360 {
361   if( MyView->IsDefined() ) MyView->Redraw() ;
362 }
363
364 //=============================================================================
365 //function : RedrawImmediate
366 //purpose  :
367 //=============================================================================
368 void V3d_View::RedrawImmediate() const
369 {
370   if (MyView->IsDefined())
371   {
372     MyView->RedrawImmediate();
373   }
374 }
375
376 //=============================================================================
377 //function : Invalidate
378 //purpose  :
379 //=============================================================================
380 void V3d_View::Invalidate() const
381 {
382   if (MyView->IsDefined())
383   {
384     MyView->Invalidate();
385   }
386 }
387
388 //=============================================================================
389 //function : IsInvalidated
390 //purpose  :
391 //=============================================================================
392 Standard_Boolean V3d_View::IsInvalidated() const
393 {
394   return !MyView->IsDefined()
395        || MyView->IsInvalidated();
396 }
397
398 //=============================================================================
399 //function : AutoZFit
400 //purpose  :
401 //=============================================================================
402 void V3d_View::AutoZFit()
403 {
404   View()->AutoZFit();
405 }
406
407 //=============================================================================
408 //function : ZFitAll
409 //purpose  :
410 //=============================================================================
411 void V3d_View::ZFitAll (const Standard_Real theScaleFactor)
412 {
413   View()->ZFitAll (theScaleFactor);
414 }
415
416 //=============================================================================
417 //function : Redraw
418 //purpose  :
419 //=============================================================================
420 void V3d_View::Redraw(const Standard_Integer xc,const Standard_Integer yc,
421                       const Standard_Integer width,const Standard_Integer height) const
422 {
423   if( MyView->IsDefined() ) MyView->Redraw(xc,yc,width,height) ;
424 }
425
426 //=============================================================================
427 //function : IsEmpty
428 //purpose  :
429 //=============================================================================
430 Standard_Boolean V3d_View::IsEmpty() const
431 {
432   Standard_Boolean TheStatus = Standard_True ;
433   if( MyView->IsDefined() ) {
434     Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
435     if( Nstruct > 0 ) TheStatus = Standard_False ;
436   }
437   return (TheStatus) ;
438 }
439
440 //=============================================================================
441 //function : UpdateLights
442 //purpose  :
443 //=============================================================================
444 void V3d_View::UpdateLights() const
445 {
446   MyView->SetContext(MyViewContext);
447   Update();
448 }
449
450 //=============================================================================
451 //function : DoMapping
452 //purpose  :
453 //=============================================================================
454 void V3d_View::DoMapping()
455 {
456   if( MyView->IsDefined() ) {
457     (MyView->Window())->DoMapping() ;
458   }
459 }
460
461 //=============================================================================
462 //function : MustBeResized
463 //purpose  :
464 //=============================================================================
465 void V3d_View::MustBeResized()
466 {
467   if ( !MyLayerMgr.IsNull() )
468     MyLayerMgr->Resized();
469
470   if( MyView->IsDefined() ) {
471     MyView->Resized() ;
472     MyView->Redraw();
473   }
474 }
475
476 //=============================================================================
477 //function : SetBackgroundColor
478 //purpose  :
479 //=============================================================================
480 void V3d_View::SetBackgroundColor(const Quantity_TypeOfColor Type, const Standard_Real v1, const Standard_Real v2, const Standard_Real v3)
481 {
482   Standard_Real V1 = Max( Min( v1, 1.0 ), 0.0 );
483   Standard_Real V2 = Max( Min( v2, 1.0 ), 0.0 );
484   Standard_Real V3 = Max( Min( v3, 1.0 ), 0.0 );
485
486   Quantity_Color C( V1, V2, V3, Type );
487   SetBackgroundColor( C );
488 }
489
490 //=============================================================================
491 //function : SetBackgroundColor
492 //purpose  :
493 //=============================================================================
494 void V3d_View::SetBackgroundColor(const Quantity_Color &Color)
495 {
496   MyBackground.SetColor( Color );
497   if ( MyView->IsDefined() )
498     MyView->SetBackground( MyBackground );
499   //szv: Why?
500   if ( !MyLayerMgr.IsNull() )
501     MyLayerMgr->Resized();
502 }
503
504 //=============================================================================
505 //function : SetBackgroundColor
506 //purpose  :
507 //=============================================================================
508 void V3d_View::SetBackgroundColor(const Quantity_NameOfColor Name)
509 {
510   Quantity_Color C( Name );
511   SetBackgroundColor( C );
512 }
513
514 //=============================================================================
515 //function : SetBgGradientColors
516 //purpose  :
517 //=============================================================================
518 void V3d_View::SetBgGradientColors( const Quantity_Color& Color1,
519                                     const Quantity_Color& Color2,
520                                     const Aspect_GradientFillMethod FillStyle,
521                                     const Standard_Boolean status)
522 {
523   MyGradientBackground.SetColors(Color1, Color2, FillStyle);
524   if ( MyView->IsDefined() )
525     MyView->SetGradientBackground( MyGradientBackground, status );
526 }
527
528 //=============================================================================
529 //function : SetBgGradientColors
530 //purpose  :
531 //=============================================================================
532 void V3d_View::SetBgGradientColors( const Quantity_NameOfColor Color1,
533                                     const Quantity_NameOfColor Color2,
534                                     const Aspect_GradientFillMethod FillStyle,
535                                     const Standard_Boolean status )
536 {
537   Quantity_Color C1( Color1 );
538   Quantity_Color C2( Color2 );
539   MyGradientBackground.SetColors( C1, C2, FillStyle );
540   if ( MyView->IsDefined() )
541     MyView->SetGradientBackground( MyGradientBackground, status );
542 }
543
544 //=============================================================================
545 //function : SetBgGradientStyle
546 //purpose  :
547 //=============================================================================
548 void V3d_View::SetBgGradientStyle( const Aspect_GradientFillMethod FillStyle,
549                                    const Standard_Boolean update)
550 {
551   Quantity_Color Color1, Color2;
552   MyGradientBackground.Colors( Color1, Color2 );
553   MyGradientBackground.SetColors( Color1, Color2, FillStyle );
554   if( MyView->IsDefined() )
555     MyView->SetBgGradientStyle( FillStyle, update ) ;
556 }
557
558 //=============================================================================
559 //function : SetBackgroundImage
560 //purpose  :
561 //=============================================================================
562 void V3d_View::SetBackgroundImage( const Standard_CString FileName,
563                                    const Aspect_FillMethod FillStyle,
564                                    const Standard_Boolean update )
565 {
566   if( MyView->IsDefined() )
567     MyView->SetBackgroundImage( FileName, FillStyle, update ) ;
568 }
569
570 //=============================================================================
571 //function : SetBgImageStyle
572 //purpose  :
573 //=============================================================================
574 void V3d_View::SetBgImageStyle( const Aspect_FillMethod FillStyle,
575                                 const Standard_Boolean update )
576 {
577   if( MyView->IsDefined() )
578     MyView->SetBgImageStyle( FillStyle, update ) ;
579 }
580
581 //=============================================================================
582 //function : SetAxis
583 //purpose  :
584 //=============================================================================
585 void V3d_View::SetAxis(const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real Vx, const Standard_Real Vy, const Standard_Real Vz)
586 {
587   Standard_Real D,Nx = Vx,Ny = Vy,Nz = Vz ;
588
589   D = Sqrt( Vx*Vx + Vy*Vy + Vz*Vz ) ;
590   V3d_BadValue_Raise_if ( D <= 0. , "V3d_View::SetAxis, bad axis");
591   Nx /= D ; Ny /= D ; Nz /= D ;
592   MyDefaultViewPoint.SetCoord(X,Y,Z) ;
593   MyDefaultViewAxis.SetCoord(Nx,Ny,Nz) ;
594 }
595
596 //=============================================================================
597 //function : SetShadingModel
598 //purpose  :
599 //=============================================================================
600 void V3d_View::SetShadingModel(const V3d_TypeOfShadingModel Model)
601 {
602   MyViewContext.SetModel((Visual3d_TypeOfModel) Model) ;
603   MyView->SetContext(MyViewContext) ;
604 }
605
606 //=============================================================================
607 //function : SetSurfaceDetail
608 //purpose  :
609 //=============================================================================
610 void V3d_View::SetSurfaceDetail(const V3d_TypeOfSurfaceDetail Model)
611 {
612   MyViewContext.SetSurfaceDetail((Visual3d_TypeOfSurfaceDetail) Model) ;
613   MyView->SetContext(MyViewContext) ;
614 }
615
616 //=============================================================================
617 //function : SetTextureEnv
618 //purpose  :
619 //=============================================================================
620 void V3d_View::SetTextureEnv(const Handle(Graphic3d_TextureEnv)& ATexture)
621 {
622   MyViewContext.SetTextureEnv(ATexture) ;
623   MyView->SetContext(MyViewContext) ;
624 }
625
626 //=============================================================================
627 //function : SetVisualization
628 //purpose  :
629 //=============================================================================
630 void V3d_View::SetVisualization(const V3d_TypeOfVisualization Mode)
631 {
632   MyViewContext.SetVisualization((Visual3d_TypeOfVisualization) Mode);
633   MyView->SetContext(MyViewContext) ;
634 }
635
636 //=============================================================================
637 //function : SetFront
638 //purpose  :
639 //=============================================================================
640 void V3d_View::SetFront()
641 {
642   gp_Ax3 a = MyViewer->PrivilegedPlane();
643   Standard_Real xo, yo, zo, vx, vy, vz, xu, yu, zu;
644
645   a.Direction().Coord(vx,vy,vz);
646   a.YDirection().Coord(xu,yu,zu);
647   a.Location().Coord(xo,yo,zo);
648
649   myCamera->SetCenter (gp_Pnt (xo, yo, zo));
650   if(SwitchSetFront)
651     myCamera->SetDirection (gp_Dir (vx, vy, vz));
652   else
653     myCamera->SetDirection (gp_Dir (vx, vy, vz).Reversed());
654   myCamera->SetUp (gp_Dir (xu, yu, zu));
655
656   View()->AutoZFit();
657
658   SwitchSetFront = !SwitchSetFront;
659
660   ImmediateUpdate();
661 }
662
663 //=============================================================================
664 //function : Rotate
665 //purpose  :
666 //=============================================================================
667 void V3d_View::Rotate (const Standard_Real ax, 
668                        const Standard_Real ay, 
669                        const Standard_Real az, 
670                        const Standard_Boolean Start)
671 {
672   Standard_Real Ax = ax;
673   Standard_Real Ay = ay;
674   Standard_Real Az = az;
675
676   if( Ax > 0. ) while ( Ax > DEUXPI ) Ax -= DEUXPI;
677   else if( Ax < 0. ) while ( Ax < -DEUXPI ) Ax += DEUXPI;
678   if( Ay > 0. ) while ( Ay > DEUXPI ) Ay -= DEUXPI;
679   else if( Ay < 0. ) while ( Ay < -DEUXPI ) Ay += DEUXPI;
680   if( Az > 0. ) while ( Az > DEUXPI ) Az -= DEUXPI;
681   else if( Az < 0. ) while ( Az < -DEUXPI ) Az += DEUXPI;
682
683   if (Start)
684   {
685     myCamStartOpUp = myCamera->Up();
686     myCamStartOpEye = myCamera->Eye();
687     myCamStartOpCenter = myCamera->Center();
688   }
689
690   myCamera->SetUp (myCamStartOpUp);
691   myCamera->SetEye (myCamStartOpEye);
692   myCamera->SetCenter (myCamStartOpCenter);
693
694   // rotate camera around 3 initial axes
695   gp_Dir aBackDir (gp_Vec (myCamStartOpCenter, myCamStartOpEye));
696   gp_Dir aXAxis (myCamStartOpUp.Crossed (aBackDir));
697   gp_Dir aYAxis (aBackDir.Crossed (aXAxis));
698   gp_Dir aZAxis (aXAxis.Crossed (aYAxis));
699
700   gp_Trsf aRot[3], aTrsf;
701   aRot[0].SetRotation (gp_Ax1 (myCamStartOpCenter, aYAxis), -Ax);
702   aRot[1].SetRotation (gp_Ax1 (myCamStartOpCenter, aXAxis), Ay);
703   aRot[2].SetRotation (gp_Ax1 (myCamStartOpCenter, aZAxis), Az);
704   aTrsf.Multiply (aRot[0]);
705   aTrsf.Multiply (aRot[1]);
706   aTrsf.Multiply (aRot[2]);
707
708   myCamera->Transform (aTrsf);
709
710   View()->AutoZFit();
711
712   ImmediateUpdate();
713 }
714
715 //=============================================================================
716 //function : Rotate
717 //purpose  :
718 //=============================================================================
719 void V3d_View::Rotate(const Standard_Real ax, const Standard_Real ay, const Standard_Real az,
720                       const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Boolean Start)
721 {
722
723   Standard_Real Ax = ax ;
724   Standard_Real Ay = ay ;
725   Standard_Real Az = az ;
726
727   if( Ax > 0. ) while ( Ax > DEUXPI ) Ax -= DEUXPI ;
728   else if( Ax < 0. ) while ( Ax < -DEUXPI ) Ax += DEUXPI ;
729   if( Ay > 0. ) while ( Ay > DEUXPI ) Ay -= DEUXPI ;
730   else if( Ay < 0. ) while ( Ay < -DEUXPI ) Ay += DEUXPI ;
731   if( Az > 0. ) while ( Az > DEUXPI ) Az -= DEUXPI ;
732   else if( Az < 0. ) while ( Az < -DEUXPI ) Az += DEUXPI ;
733
734   if (Start)
735   {
736     myGravityReferencePoint.SetCoord (X, Y, Z);
737     myCamStartOpUp = myCamera->Up();
738     myCamStartOpEye = myCamera->Eye();
739     myCamStartOpCenter = myCamera->Center();
740   }
741
742   const Graphic3d_Vertex& aVref = myGravityReferencePoint;
743
744   myCamera->SetUp (myCamStartOpUp);
745   myCamera->SetEye (myCamStartOpEye);
746   myCamera->SetCenter (myCamStartOpCenter);
747
748   // rotate camera around 3 initial axes
749   gp_Pnt aRCenter (aVref.X(), aVref.Y(), aVref.Z());
750
751   gp_Dir aZAxis (myCamera->Direction().Reversed());
752   gp_Dir aYAxis (myCamera->Up());
753   gp_Dir aXAxis (aYAxis.Crossed (aZAxis)); 
754
755   gp_Trsf aRot[3], aTrsf;
756   aRot[0].SetRotation (gp_Ax1 (aRCenter, aYAxis), -Ax);
757   aRot[1].SetRotation (gp_Ax1 (aRCenter, aXAxis), Ay);
758   aRot[2].SetRotation (gp_Ax1 (aRCenter, aZAxis), Az);
759   aTrsf.Multiply (aRot[0]);
760   aTrsf.Multiply (aRot[1]);
761   aTrsf.Multiply (aRot[2]);
762
763   myCamera->Transform (aTrsf);
764
765   View()->AutoZFit();
766
767   ImmediateUpdate();
768 }
769
770 //=============================================================================
771 //function : Rotate
772 //purpose  :
773 //=============================================================================
774 void V3d_View::Rotate(const V3d_TypeOfAxe Axe, const Standard_Real angle, const Standard_Boolean Start)
775 {
776   switch (Axe) {
777   case V3d_X :
778     Rotate(angle,0.,0.,Start);
779     break ;
780   case V3d_Y :
781     Rotate(0.,angle,0.,Start);
782     break ;
783   case V3d_Z :
784     Rotate(0.,0.,angle,Start);
785     break ;
786   }
787 }
788
789 //=============================================================================
790 //function : Rotate
791 //purpose  :
792 //=============================================================================
793 void V3d_View::Rotate(const V3d_TypeOfAxe Axe, const Standard_Real angle,
794                       const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Boolean Start)
795 {
796   Standard_Real Angle = angle ;
797
798   if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
799   else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
800
801   if (Start)
802   {
803     myGravityReferencePoint.SetCoord (X, Y, Z);
804     myCamStartOpUp = myCamera->Up();
805     myCamStartOpEye = myCamera->Eye();
806     myCamStartOpCenter = myCamera->Center();
807
808     switch (Axe) {
809     case V3d_X :
810       myViewAxis.SetCoord(1.,0.,0.) ;
811       break ;
812     case V3d_Y :
813       myViewAxis.SetCoord(0.,1.,0.) ;
814       break ;
815     case V3d_Z :
816       myViewAxis.SetCoord(0.,0.,1.) ;
817       break ;
818     }
819
820     myCamStartOpUp = myCamera->Up();
821     myCamStartOpEye = myCamera->Eye();
822     myCamStartOpCenter = myCamera->Center();
823   }
824
825   const Graphic3d_Vertex& aVref = myGravityReferencePoint;
826
827   myCamera->SetUp (myCamStartOpUp);
828   myCamera->SetEye (myCamStartOpEye);
829   myCamera->SetCenter (myCamStartOpCenter);
830
831   // rotate camera around passed axis
832   gp_Trsf aRotation;
833   gp_Pnt aRCenter (aVref.X(), aVref.Y(), aVref.Z());
834   gp_Dir aRAxis ((Axe == V3d_X) ? 1.0 : 0.0,
835                   (Axe == V3d_Y) ? 1.0 : 0.0,
836                   (Axe == V3d_Z) ? 1.0 : 0.0);
837
838   aRotation.SetRotation (gp_Ax1 (aRCenter, aRAxis), Angle);
839   myCamera->Transform (aRotation);
840
841   View()->AutoZFit();
842
843   ImmediateUpdate();
844 }
845
846 //=============================================================================
847 //function : Rotate
848 //purpose  :
849 //=============================================================================
850 void V3d_View::Rotate(const Standard_Real angle, const Standard_Boolean Start)
851 {
852   Standard_Real Angle = angle;
853
854   if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
855   else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
856
857   if( Start ) {
858     myCamStartOpUp = myCamera->Up();
859     myCamStartOpEye = myCamera->Eye();
860     myCamStartOpCenter = myCamera->Center();
861   }
862
863   const Graphic3d_Vertex& aPnt = MyDefaultViewPoint;
864   const Graphic3d_Vector& anAxis = MyDefaultViewAxis;
865
866   myCamera->SetUp (myCamStartOpUp);
867   myCamera->SetEye (myCamStartOpEye);
868   myCamera->SetCenter (myCamStartOpCenter);
869
870   gp_Trsf aRotation;
871   gp_Pnt aRCenter (aPnt.X(), aPnt.Y(), aPnt.Z());
872   gp_Dir aRAxis (anAxis.X(), anAxis.Y(), anAxis.Z());
873   aRotation.SetRotation (gp_Ax1 (aRCenter, aRAxis), Angle);
874   myCamera->Transform (aRotation);
875
876   View()->AutoZFit();
877
878   ImmediateUpdate();
879 }
880
881 //=============================================================================
882 //function : Turn
883 //purpose  :
884 //=============================================================================
885 void V3d_View::Turn(const Standard_Real ax, const Standard_Real ay, const Standard_Real az, const Standard_Boolean Start)
886 {
887   Standard_Real Ax = ax;
888   Standard_Real Ay = ay;
889   Standard_Real Az = az;
890
891   if( Ax > 0. ) while ( Ax > DEUXPI ) Ax -= DEUXPI ;
892   else if( Ax < 0. ) while ( Ax < -DEUXPI ) Ax += DEUXPI ;
893   if( Ay > 0. ) while ( Ay > DEUXPI ) Ay -= DEUXPI ;
894   else if( Ay < 0. ) while ( Ay < -DEUXPI ) Ay += DEUXPI ;
895   if( Az > 0. ) while ( Az > DEUXPI ) Az -= DEUXPI ;
896   else if( Az < 0. ) while ( Az < -DEUXPI ) Az += DEUXPI ;
897
898   if( Start ) {
899     myCamStartOpUp = myCamera->Up();
900     myCamStartOpEye = myCamera->Eye();
901     myCamStartOpCenter = myCamera->Center();
902   }
903
904   myCamera->SetUp (myCamStartOpUp);
905   myCamera->SetEye (myCamStartOpEye);
906   myCamera->SetCenter (myCamStartOpCenter);
907
908   // rotate camera around 3 initial axes
909   gp_Pnt aRCenter = myCamera->Eye();
910   gp_Dir aZAxis (myCamera->Direction().Reversed());
911   gp_Dir aYAxis (myCamera->Up());
912   gp_Dir aXAxis (aYAxis.Crossed (aZAxis)); 
913
914   gp_Trsf aRot[3], aTrsf;
915   aRot[0].SetRotation (gp_Ax1 (aRCenter, aYAxis), -Ax);
916   aRot[1].SetRotation (gp_Ax1 (aRCenter, aXAxis), Ay);
917   aRot[2].SetRotation (gp_Ax1 (aRCenter, aZAxis), Az);
918   aTrsf.Multiply (aRot[0]);
919   aTrsf.Multiply (aRot[1]);
920   aTrsf.Multiply (aRot[2]);
921
922   myCamera->Transform (aTrsf);
923
924   View()->AutoZFit();
925
926   ImmediateUpdate();
927 }
928
929 //=============================================================================
930 //function : Turn
931 //purpose  :
932 //=============================================================================
933 void V3d_View::Turn(const V3d_TypeOfAxe Axe, const Standard_Real angle, const Standard_Boolean Start)
934 {
935   switch (Axe) {
936   case V3d_X :
937     Turn(angle,0.,0.,Start);
938     break ;
939   case V3d_Y :
940     Turn(0.,angle,0.,Start);
941     break ;
942   case V3d_Z :
943     Turn(0.,0.,angle,Start);
944     break ;
945   }
946 }
947
948 //=============================================================================
949 //function : Turn
950 //purpose  :
951 //=============================================================================
952 void V3d_View::Turn(const Standard_Real angle, const Standard_Boolean Start)
953 {
954   Standard_Real Angle = angle ;
955
956   if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
957   else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
958
959   if( Start ) {
960     myCamStartOpUp = myCamera->Up();
961     myCamStartOpEye = myCamera->Eye();
962     myCamStartOpCenter = myCamera->Center();
963   }
964
965   myCamera->SetUp (myCamStartOpUp);
966   myCamera->SetEye (myCamStartOpEye);
967   myCamera->SetCenter (myCamStartOpCenter);
968
969   const Graphic3d_Vector& anAxis = MyDefaultViewAxis;
970
971   gp_Trsf aRotation;
972   gp_Pnt aRCenter = myCamera->Eye();
973   gp_Dir aRAxis (anAxis.X(), anAxis.Y(), anAxis.Z());
974   aRotation.SetRotation (gp_Ax1 (aRCenter, aRAxis), Angle);
975   myCamera->Transform (aRotation);
976
977   View()->AutoZFit();
978
979   ImmediateUpdate();
980 }
981
982 //=============================================================================
983 //function : SetTwist
984 //purpose  :
985 //=============================================================================
986 void V3d_View::SetTwist(const Standard_Real angle)
987 {
988   Standard_Real Angle = angle ;
989   Standard_Boolean TheStatus;
990
991   if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
992   else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
993
994   gp_Dir aReferencePlane (myCamera->Direction().Reversed());
995   gp_Dir anUp;
996
997   anUp = gp_Dir (0.0, 0.0, 1.0);
998
999   TheStatus = ScreenAxis(aReferencePlane, anUp,
1000     myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1001   if( !TheStatus ) {
1002     anUp = gp_Dir (0.0, 1.0, 0.0);
1003     TheStatus = ScreenAxis(aReferencePlane, anUp,
1004       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1005   }
1006   if( !TheStatus ) {
1007     anUp = gp_Dir (1.0, 0.0, 0.0);
1008     TheStatus = ScreenAxis(aReferencePlane, anUp,
1009       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1010   }
1011
1012   V3d_BadValue_Raise_if( !TheStatus,"V3d_ViewSetTwist, alignment of Eye,At,Up,");
1013   
1014   gp_Pnt aRCenter = myCamera->Center();
1015   gp_Dir aZAxis (myCamera->Direction().Reversed());
1016
1017   gp_Trsf aTrsf;
1018   aTrsf.SetRotation (gp_Ax1 (aRCenter, aZAxis), Angle);
1019
1020   Standard_Real myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ;
1021   myYscreenAxis.Coord (myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ);
1022
1023   myCamera->SetUp (gp_Dir (myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ));
1024   myCamera->Transform (aTrsf);
1025
1026   View()->AutoZFit();
1027
1028   ImmediateUpdate();
1029 }
1030
1031 //=============================================================================
1032 //function : SetEye
1033 //purpose  :
1034 //=============================================================================
1035 void V3d_View::SetEye(const Standard_Real X,const Standard_Real Y,const Standard_Real Z)
1036 {
1037   Standard_Real aTwistBefore = Twist();
1038
1039   Standard_Boolean wasUpdateEnabled = SetImmediateUpdate (Standard_False);
1040
1041   myCamera->SetEye (gp_Pnt (X, Y, Z));
1042   SetTwist (aTwistBefore);
1043
1044   View()->AutoZFit();
1045
1046   SetImmediateUpdate (wasUpdateEnabled);
1047
1048   ImmediateUpdate();
1049 }
1050
1051 //=============================================================================
1052 //function : SetDepth
1053 //purpose  :
1054 //=============================================================================
1055 void V3d_View::SetDepth(const Standard_Real Depth)
1056 {
1057   V3d_BadValue_Raise_if (Depth == 0. ,"V3d_View::SetDepth, bad depth");
1058
1059   if( Depth > 0. )
1060   {
1061     // Move eye using center (target) as anchor.
1062     myCamera->SetDistance (Depth);
1063   }
1064   else
1065   {
1066     // Move the view ref point instead of the eye.
1067     gp_Vec aDir (myCamera->Direction());
1068     gp_Pnt aCameraEye = myCamera->Eye();
1069     gp_Pnt aCameraCenter = aCameraEye.Translated (aDir.Multiplied (Abs (Depth)));
1070
1071     myCamera->SetCenter (aCameraCenter);
1072   }
1073
1074   View()->AutoZFit();
1075
1076   ImmediateUpdate();
1077 }
1078
1079 //=============================================================================
1080 //function : SetProj
1081 //purpose  :
1082 //=============================================================================
1083 void V3d_View::SetProj( const Standard_Real Vx,const Standard_Real Vy, const Standard_Real Vz )
1084 {
1085   V3d_BadValue_Raise_if( Sqrt(Vx*Vx + Vy*Vy + Vz*Vz) <= 0.,
1086     "V3d_View::SetProj, null projection vector");
1087
1088   Standard_Real aTwistBefore = Twist();
1089
1090   Standard_Boolean wasUpdateEnabled = SetImmediateUpdate (Standard_False);
1091
1092   myCamera->SetDirection (gp_Dir (Vx, Vy, Vz).Reversed());
1093
1094   SetTwist(aTwistBefore);
1095
1096   View()->AutoZFit();
1097
1098   SetImmediateUpdate (wasUpdateEnabled);
1099
1100   ImmediateUpdate();
1101 }
1102
1103 //=============================================================================
1104 //function : SetProj
1105 //purpose  :
1106 //=============================================================================
1107 void V3d_View::SetProj( const V3d_TypeOfOrientation Orientation )
1108 {
1109   Standard_Real Xpn=0;
1110   Standard_Real Ypn=0;
1111   Standard_Real Zpn=0;
1112
1113   switch (Orientation) {
1114   case V3d_Zpos :
1115     Ypn = 1.;
1116     break;
1117   case V3d_Zneg :
1118     Ypn = -1.;
1119     break;
1120   default:
1121     Zpn = 1.;
1122   }
1123
1124   const Graphic3d_Vector& aBck = V3d::GetProjAxis (Orientation);
1125
1126   // retain camera panning from origin when switching projection
1127   gp_Pnt anOriginVCS = myCamera->ConvertWorld2View (gp::Origin());
1128   Standard_Real aPanX = anOriginVCS.X();
1129   Standard_Real aPanY = anOriginVCS.Y();
1130
1131   myCamera->SetCenter (gp_Pnt (0, 0, 0));
1132   myCamera->SetDirection (gp_Dir (aBck.X(), aBck.Y(), aBck.Z()).Reversed());
1133   myCamera->SetUp (gp_Dir (Xpn, Ypn, Zpn));
1134   myCamera->OrthogonalizeUp();
1135
1136   Panning (aPanX, aPanY);
1137
1138   View()->AutoZFit();
1139
1140   ImmediateUpdate();
1141 }
1142
1143 //=============================================================================
1144 //function : SetAt
1145 //purpose  :
1146 //=============================================================================
1147 void V3d_View::SetAt(const Standard_Real X,const Standard_Real Y,const Standard_Real Z)
1148 {
1149   Standard_Real aTwistBefore = Twist();
1150
1151   Standard_Boolean wasUpdateEnabled = SetImmediateUpdate (Standard_False);
1152
1153   myCamera->SetCenter (gp_Pnt (X, Y, Z));
1154
1155   SetTwist (aTwistBefore);
1156
1157   View()->AutoZFit();
1158
1159   SetImmediateUpdate (wasUpdateEnabled);
1160
1161   ImmediateUpdate();
1162 }
1163
1164 //=============================================================================
1165 //function : SetUp
1166 //purpose  :
1167 //=============================================================================
1168 void V3d_View::SetUp(const Standard_Real Vx,const Standard_Real Vy,const Standard_Real Vz)
1169 {
1170   Standard_Boolean TheStatus ;
1171   V3d_BadValue_Raise_if( Sqrt(Vx*Vx + Vy*Vy + Vz*Vz) <= 0. ,
1172     "V3d_View::SetUp, nullUp vector");
1173
1174   gp_Dir aReferencePlane (myCamera->Direction().Reversed());
1175   gp_Dir anUp (Vx, Vy, Vz);
1176
1177   TheStatus = ScreenAxis(aReferencePlane,anUp,
1178     myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1179   if( !TheStatus ) {
1180     anUp = gp_Dir (0.0, 0.0, 1.0);
1181     TheStatus = ScreenAxis(aReferencePlane,anUp,
1182       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1183   }
1184   if( !TheStatus ) {
1185     anUp = gp_Dir (0.0, 1.0, 0.0);
1186     TheStatus = ScreenAxis(aReferencePlane,anUp,
1187       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1188   }
1189   if( !TheStatus ) {
1190     anUp = gp_Dir (1.0, 0.0, 0.0);
1191     TheStatus = ScreenAxis(aReferencePlane,anUp,
1192       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1193   }
1194   V3d_BadValue_Raise_if( !TheStatus,"V3d_View::Setup, alignment of Eye,At,Up");
1195
1196   Standard_Real myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ;
1197   myYscreenAxis.Coord (myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ);
1198
1199   myCamera->SetUp (gp_Dir (myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ));
1200
1201   View()->AutoZFit();
1202
1203   ImmediateUpdate();
1204 }
1205
1206 //=============================================================================
1207 //function : SetUp
1208 //purpose  :
1209 //=============================================================================
1210 void V3d_View::SetUp( const V3d_TypeOfOrientation Orientation )
1211 {
1212   Standard_Boolean TheStatus ;
1213
1214   gp_Dir aReferencePlane (myCamera->Direction().Reversed());
1215   gp_Dir anUp;
1216
1217   const Graphic3d_Vector& aViewReferenceUp = V3d::GetProjAxis(Orientation) ;
1218   anUp = gp_Dir (aViewReferenceUp.X(), aViewReferenceUp.Y(), aViewReferenceUp.Z());
1219
1220   TheStatus = ScreenAxis(aReferencePlane,anUp,
1221     myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1222   if( !TheStatus ) {
1223     anUp = gp_Dir (0.,0.,1.);
1224     TheStatus = ScreenAxis(aReferencePlane,anUp,
1225       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1226   }
1227   if( !TheStatus ) {
1228     anUp = gp_Dir (0.,1.,0.);
1229     TheStatus = ScreenAxis(aReferencePlane,anUp,
1230       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1231   }
1232   if( !TheStatus ) {
1233     anUp = gp_Dir (1.,0.,0.);
1234     TheStatus = ScreenAxis(aReferencePlane,anUp,
1235       myXscreenAxis,myYscreenAxis,myZscreenAxis) ;
1236   }
1237   V3d_BadValue_Raise_if( !TheStatus, "V3d_View::SetUp, alignment of Eye,At,Up");
1238
1239   Standard_Real myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ;
1240   myYscreenAxis.Coord (myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ);
1241
1242   myCamera->SetUp (gp_Dir (myYscreenAxisX, myYscreenAxisY, myYscreenAxisZ));
1243
1244   View()->AutoZFit();
1245
1246   ImmediateUpdate();
1247 }
1248
1249 //=============================================================================
1250 //function : SetViewOrientationDefault
1251 //purpose  :
1252 //=============================================================================
1253 void V3d_View::SetViewOrientationDefault()
1254 {
1255   MyView->SetViewOrientationDefault() ;
1256
1257   ImmediateUpdate();
1258 }
1259
1260 //=============================================================================
1261 //function : ResetViewOrientation
1262 //purpose  :
1263 //=============================================================================
1264 void V3d_View::ResetViewOrientation()
1265 {
1266   MyView->ViewOrientationReset() ;
1267
1268   ImmediateUpdate();
1269 }
1270
1271 //=============================================================================
1272 //function : Reset
1273 //purpose  :
1274 //=============================================================================
1275 void V3d_View::Reset( const Standard_Boolean update )
1276 {
1277   Handle(Graphic3d_Camera) aDefaultCamera = MyView->DefaultCamera();
1278
1279   if (!aDefaultCamera.IsNull())
1280   {
1281     myCamera->CopyMappingData (aDefaultCamera);
1282     myCamera->CopyOrientationData (aDefaultCamera);
1283
1284     View()->AutoZFit();
1285   }
1286
1287   SwitchSetFront = Standard_False;
1288
1289   if( myImmediateUpdate || update ) Update();
1290 }
1291
1292 //=======================================================================
1293 //function : SetCenter
1294 //purpose  :
1295 //=======================================================================
1296 void V3d_View::SetCenter (const Standard_Integer theXp,
1297                           const Standard_Integer theYp)
1298 {
1299   Standard_Real aXv, aYv;
1300   Convert (theXp, theYp, aXv, aYv);
1301   Translate (myCamera, aXv, aYv);
1302
1303   ImmediateUpdate();
1304 }
1305
1306 //=============================================================================
1307 //function : SetSize
1308 //purpose  :
1309 //=============================================================================
1310 void V3d_View::SetSize (const Standard_Real theSize)
1311 {
1312   V3d_BadValue_Raise_if (theSize <= 0.0, "V3d_View::SetSize, Window Size is NULL");
1313
1314   myCamera->SetScale (myCamera->Aspect() >= 1.0 ? theSize / myCamera->Aspect() : theSize);
1315
1316   View()->AutoZFit();
1317
1318   ImmediateUpdate();
1319 }
1320
1321 //=============================================================================
1322 //function : SetZSize
1323 //purpose  :
1324 //=============================================================================
1325 void V3d_View::SetZSize(const Standard_Real Size)
1326 {
1327   Standard_Real Zmax = Size/2.;
1328
1329   Standard_Real aDistance = myCamera->Distance();
1330
1331   if( Size <= 0. ) {
1332     Zmax = aDistance;
1333   }
1334
1335   Standard_Real Front = MyViewContext.ZClippingFrontPlane();
1336   Standard_Real Back  = MyViewContext.ZClippingBackPlane();
1337
1338   // ShortReal precision factor used to add meaningful tolerance to
1339   // ZNear, ZFar values in order to avoid equality after type conversion
1340   // to ShortReal matrices type.
1341   const Standard_Real aPrecision = 1.0 / Pow (10.0, ShortRealDigits() - 1);
1342
1343   Standard_Real aZFar  =  Zmax  + aDistance * 2.0;
1344   Standard_Real aZNear = -Zmax  + aDistance;
1345   aZNear              -= Abs (aZNear) * aPrecision;
1346   aZFar               += Abs (aZFar)  * aPrecision;
1347
1348   if (!myCamera->IsOrthographic())
1349   {
1350     if (aZFar < aPrecision)
1351     {
1352       // Invalid case when both values are negative
1353       aZNear = aPrecision;
1354       aZFar  = aPrecision * 2.0;
1355     }
1356     else if (aZNear < Abs (aZFar) * aPrecision)
1357     {
1358       // Z is less than 0.0, try to fix it using any appropriate z-scale
1359       aZNear = Abs (aZFar) * aPrecision;
1360     }
1361   }
1362
1363   // If range is too small
1364   if (aZFar < (aZNear + Abs (aZFar) * aPrecision))
1365   {
1366     aZFar = aZNear + Abs (aZFar) * aPrecision;
1367   }
1368
1369   myCamera->SetZRange (aZNear, aZFar);
1370
1371   if (MyViewContext.FrontZClippingIsOn()  ||
1372       MyViewContext.BackZClippingIsOn())
1373   {
1374     MyViewContext.SetZClippingFrontPlane (Front);
1375     MyViewContext.SetZClippingBackPlane (Back);
1376     MyView->SetContext (MyViewContext);
1377   }
1378 }
1379
1380 //=============================================================================
1381 //function : SetZoom
1382 //purpose  :
1383 //=============================================================================
1384 void V3d_View::SetZoom(const Standard_Real Coef,const Standard_Boolean Start)
1385 {
1386   V3d_BadValue_Raise_if( Coef <= 0.,"V3d_View::SetZoom, bad coefficient");
1387
1388   if (Start)
1389   {
1390     myCamStartOpEye    = myCamera->Eye();
1391     myCamStartOpCenter = myCamera->Center();
1392   }
1393
1394   Standard_Real aViewWidth  = myCamera->ViewDimensions().X();
1395   Standard_Real aViewHeight = myCamera->ViewDimensions().Y();
1396
1397   // ensure that zoom will not be too small or too big
1398   Standard_Real coef = Coef;
1399   if (aViewWidth < coef * Precision::Confusion())
1400   {
1401     coef = aViewWidth / Precision::Confusion();
1402   }
1403   else if (aViewWidth > coef * 1e12)
1404   {
1405     coef = aViewWidth / 1e12;
1406   }
1407   if (aViewHeight < coef * Precision::Confusion())
1408   {
1409     coef = aViewHeight / Precision::Confusion();
1410   }
1411   else if (aViewHeight > coef * 1e12)
1412   {
1413     coef = aViewHeight / 1e12;
1414   }
1415
1416   myCamera->SetEye (myCamStartOpEye);
1417   myCamera->SetCenter (myCamStartOpCenter);
1418   myCamera->SetScale (myCamera->Scale() / Coef);
1419   View()->AutoZFit();
1420
1421   ImmediateUpdate();
1422 }
1423
1424 //=============================================================================
1425 //function : SetScale
1426 //purpose  :
1427 //=============================================================================
1428 void V3d_View::SetScale( const Standard_Real Coef )
1429 {
1430   V3d_BadValue_Raise_if( Coef <= 0. ,"V3d_View::SetScale, bad coefficient");
1431
1432   Handle(Graphic3d_Camera) aDefaultCamera = MyView->DefaultCamera();
1433
1434   // Strange behavior for the sake of compatibility.
1435   if (!aDefaultCamera.IsNull())
1436   {
1437     myCamera->SetAspect (aDefaultCamera->Aspect());
1438     Standard_Real aDefaultScale = aDefaultCamera->Scale();
1439     myCamera->SetScale (aDefaultScale / Coef);
1440   } 
1441   else
1442   {
1443     myCamera->SetScale (myCamera->Scale() / Coef);
1444   }
1445
1446   View()->AutoZFit();
1447
1448   ImmediateUpdate();
1449 }
1450
1451 //=============================================================================
1452 //function : SetAxialScale
1453 //purpose  :
1454 //=============================================================================
1455 void V3d_View::SetAxialScale( const Standard_Real Sx, const Standard_Real Sy, const Standard_Real Sz )
1456 {
1457   V3d_BadValue_Raise_if( Sx <= 0. || Sy <= 0. || Sz <= 0.,"V3d_View::SetAxialScale, bad coefficient");
1458
1459   myCamera->SetAxialScale (gp_XYZ (Sx, Sy, Sz));
1460   View()->AutoZFit();
1461 }
1462
1463 //=============================================================================
1464 //function : FitAll
1465 //purpose  :
1466 //=============================================================================
1467 void V3d_View::FitAll (const Quantity_Coefficient theMargin, const Standard_Boolean theToUpdate)
1468 {
1469   FitAll (MyView->MinMaxValues(), theMargin, theToUpdate);
1470 }
1471
1472 //=============================================================================
1473 //function : FitAll
1474 //purpose  :
1475 //=============================================================================
1476 void V3d_View::FitAll (const Bnd_Box& theBox, const Quantity_Coefficient theMargin, const Standard_Boolean theToUpdate)
1477 {
1478   Standard_ASSERT_RAISE(theMargin >= 0.0 && theMargin < 1.0, "Invalid margin coefficient");
1479
1480   if (MyView->NumberOfDisplayedStructures() == 0)
1481   {
1482     return;
1483   }
1484
1485   if (!FitMinMax (myCamera, theBox, theMargin, 10.0 * Precision::Confusion()))
1486   {
1487     return;
1488   }
1489
1490   View()->AutoZFit();
1491
1492   if (myImmediateUpdate || theToUpdate)
1493   {
1494     Update();
1495   }
1496 }
1497
1498 //=============================================================================
1499 //function : DepthFitAll
1500 //purpose  :
1501 //=============================================================================
1502 void V3d_View::DepthFitAll(const Quantity_Coefficient Aspect,
1503                            const Quantity_Coefficient Margin)
1504 {
1505   Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax,U,V,W,U1,V1,W1 ;
1506   Standard_Real Umin,Vmin,Wmin,Umax,Vmax,Wmax ;
1507   Standard_Real Dx,Dy,Dz,Size;
1508
1509   Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
1510
1511   if((Nstruct <= 0) || (Aspect < 0.) || (Margin < 0.) || (Margin > 1.)) {
1512     ImmediateUpdate();
1513     return ;
1514   }
1515
1516   Bnd_Box aBox = MyView->MinMaxValues();
1517   if (aBox.IsVoid())
1518   {
1519     ImmediateUpdate();
1520     return ;
1521   }
1522     aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
1523     MyView->Projects(Xmin,Ymin,Zmin,U,V,W) ;
1524     MyView->Projects(Xmax,Ymax,Zmax,U1,V1,W1) ;
1525     Umin = Min(U,U1) ; Umax = Max(U,U1) ;
1526     Vmin = Min(V,V1) ; Vmax = Max(V,V1) ;
1527     Wmin = Min(W,W1) ; Wmax = Max(W,W1) ;
1528     MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
1529     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1530     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1531     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1532     MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
1533     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1534     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1535     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1536     MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
1537     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1538     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1539     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1540     MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
1541     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1542     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1543     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1544     MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
1545     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1546     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1547     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1548     MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
1549     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1550     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1551     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1552
1553     // Adjust Z size
1554     Wmax = Max(Abs(Wmin),Abs(Wmax)) ;
1555     Dz = 2.*Wmax + Margin * Wmax;
1556
1557     // Compute depth value
1558     Dx = Abs(Umax - Umin) ; Dy = Abs(Vmax - Vmin) ; // Dz = Abs(Wmax - Wmin);
1559     Dx += Margin * Dx; Dy += Margin * Dy;
1560     Size = Sqrt(Dx*Dx + Dy*Dy + Dz*Dz);
1561     if( Size > 0. ) {
1562       SetZSize(Size) ;
1563       SetDepth( Aspect * Size / 2.);
1564     }
1565
1566     ImmediateUpdate();
1567 }
1568
1569 //=============================================================================
1570 //function : FitAll
1571 //purpose  :
1572 //=============================================================================
1573 void V3d_View::FitAll(const Standard_Real theMinXv,
1574                       const Standard_Real theMinYv,
1575                       const Standard_Real theMaxXv,
1576                       const Standard_Real theMaxYv)
1577 {
1578   FitAll (MyWindow, theMinXv, theMinYv, theMaxXv, theMaxYv);
1579 }
1580
1581 //=============================================================================
1582 //function : WindowFitAll
1583 //purpose  :
1584 //=============================================================================
1585 void V3d_View::WindowFitAll(const Standard_Integer Xmin,
1586                             const Standard_Integer Ymin,
1587                             const Standard_Integer Xmax,
1588                             const Standard_Integer Ymax)
1589 {
1590   WindowFit(Xmin,Ymin,Xmax,Ymax);
1591 }
1592
1593 //=======================================================================
1594 //function : WindowFit
1595 //purpose  :
1596 //=======================================================================
1597 void V3d_View::WindowFit (const Standard_Integer theMinXp,
1598                           const Standard_Integer theMinYp,
1599                           const Standard_Integer theMaxXp,
1600                           const Standard_Integer theMaxYp)
1601 {
1602   Standard_Boolean wasUpdateEnabled = SetImmediateUpdate (Standard_False);
1603
1604   if (!myCamera->IsOrthographic())
1605   {
1606     // normalize view coordinates
1607     Standard_Integer aWinWidth, aWinHeight;
1608     MyWindow->Size (aWinWidth, aWinHeight);
1609
1610     // z coordinate of camera center
1611     Standard_Real aDepth = myCamera->Project (myCamera->Center()).Z();
1612
1613     // camera projection coordinate are in NDC which are normalized [-1, 1]
1614     Standard_Real aUMin = (2.0 / aWinWidth) * theMinXp  - 1.0;
1615     Standard_Real aUMax = (2.0 / aWinWidth) * theMaxXp  - 1.0;
1616     Standard_Real aVMin = (2.0 / aWinHeight) * theMinYp - 1.0;
1617     Standard_Real aVMax = (2.0 / aWinHeight) * theMaxYp - 1.0;
1618
1619     // compute camera panning
1620     gp_Pnt aScreenCenter (0.0, 0.0, aDepth);
1621     gp_Pnt aFitCenter ((aUMin + aUMax) * 0.5, (aVMin + aVMax) * 0.5, aDepth);
1622     gp_Pnt aPanTo = myCamera->ConvertProj2View (aFitCenter);
1623     gp_Pnt aPanFrom = myCamera->ConvertProj2View (aScreenCenter);
1624     gp_Vec aPanVec (aPanFrom, aPanTo);
1625
1626     // compute section size
1627     gp_Pnt aFitTopRight (aUMax, aVMax, aDepth);
1628     gp_Pnt aFitBotLeft (aUMin, aVMin, aDepth);
1629     gp_Pnt aViewBotLeft = myCamera->ConvertProj2View (aFitBotLeft);
1630     gp_Pnt aViewTopRight = myCamera->ConvertProj2View (aFitTopRight);
1631
1632     Standard_Real aUSize = aViewTopRight.X() - aViewBotLeft.X();
1633     Standard_Real aVSize = aViewTopRight.Y() - aViewBotLeft.Y();
1634
1635     Translate (myCamera, aPanVec.X(), -aPanVec.Y());
1636     Scale (myCamera, aUSize, aVSize);
1637     View()->AutoZFit();
1638   }
1639   else
1640   {
1641     Standard_Real aX1, aY1, aX2, aY2;
1642     Convert (theMinXp, theMinYp, aX1, aY1);
1643     Convert (theMaxXp, theMaxYp, aX2, aY2);
1644     FitAll (aX1, aY1, aX2, aY2);
1645   }
1646
1647   SetImmediateUpdate (wasUpdateEnabled);
1648
1649   ImmediateUpdate();
1650 }
1651
1652 //=======================================================================
1653 //function : SetViewMappingDefault
1654 //purpose  :
1655 //=======================================================================
1656 void V3d_View::SetViewMappingDefault()
1657 {
1658   MyView->SetViewMappingDefault();
1659
1660   ImmediateUpdate();
1661 }
1662
1663 //=======================================================================
1664 //function : ResetViewMapping
1665 //purpose  :
1666 //=======================================================================
1667 void V3d_View::ResetViewMapping()
1668 {
1669   MyView->ViewMappingReset();
1670
1671   Update();
1672 }
1673
1674 //=======================================================================
1675 //function : ConvertToGrid
1676 //purpose  :
1677 //=======================================================================
1678 void V3d_View::ConvertToGrid(const Standard_Integer Xp,
1679                              const Standard_Integer Yp,
1680                              Standard_Real& Xg,
1681                              Standard_Real& Yg,
1682                              Standard_Real& Zg) const
1683 {
1684   Graphic3d_Vertex aVrp;
1685   Standard_Real anX, anY, aZ;
1686   Convert (Xp, Yp, anX, anY, aZ);
1687   aVrp.SetCoord (anX, anY, aZ);
1688
1689   if( MyViewer->Grid()->IsActive() ) {
1690     Graphic3d_Vertex aNewVrp = Compute (aVrp) ;
1691     aNewVrp.Coord (Xg,Yg,Zg) ;
1692   } else
1693     aVrp.Coord (Xg,Yg,Zg) ;
1694 }
1695
1696 //=======================================================================
1697 //function : ConvertToGrid
1698 //purpose  :
1699 //=======================================================================
1700 void V3d_View::ConvertToGrid(const Standard_Real X,
1701                              const Standard_Real Y,
1702                              const Standard_Real Z,
1703                              Standard_Real& Xg,
1704                              Standard_Real& Yg,
1705                              Standard_Real& Zg) const
1706 {
1707   if( MyViewer->Grid()->IsActive() ) {
1708     Graphic3d_Vertex aVrp (X,Y,Z) ;
1709     Graphic3d_Vertex aNewVrp = Compute (aVrp) ;
1710     aNewVrp.Coord(Xg,Yg,Zg) ;
1711   } else {
1712     Xg = X; Yg = Y; Zg = Z;
1713   }
1714 }
1715
1716 //=======================================================================
1717 //function : Convert
1718 //purpose  :
1719 //=======================================================================
1720 Standard_Real V3d_View::Convert(const Standard_Integer Vp) const
1721 {
1722   Standard_Integer aDxw, aDyw ;
1723
1724   V3d_UnMapped_Raise_if (!MyView->IsDefined(), "view has no window");
1725
1726   MyWindow->Size (aDxw, aDyw);
1727   Standard_Real aValue;
1728
1729   gp_Pnt aViewDims = myCamera->ViewDimensions();
1730   aValue = aViewDims.X() * (Standard_Real)Vp / (Standard_Real)aDxw;
1731
1732   return aValue;
1733 }
1734
1735 //=======================================================================
1736 //function : Convert
1737 //purpose  :
1738 //=======================================================================
1739 void V3d_View::Convert(const Standard_Integer Xp,
1740                        const Standard_Integer Yp,
1741                        Standard_Real& Xv,
1742                        Standard_Real& Yv) const
1743 {
1744   Standard_Integer aDxw, aDyw;
1745
1746   V3d_UnMapped_Raise_if (!MyView->IsDefined(), "view has no window");
1747
1748   MyWindow->Size (aDxw, aDyw);
1749
1750   gp_Pnt aPoint (Xp * 2.0 / aDxw - 1.0, (aDyw - Yp) * 2.0 / aDyw - 1.0, 0.0);
1751   aPoint = myCamera->ConvertProj2View (aPoint);
1752
1753   Xv = aPoint.X();
1754   Yv = aPoint.Y();
1755 }
1756
1757 //=======================================================================
1758 //function : Convert
1759 //purpose  :
1760 //=======================================================================
1761 Standard_Integer V3d_View::Convert(const Standard_Real Vv) const
1762 {
1763   V3d_UnMapped_Raise_if (!MyView->IsDefined(), "view has no window");
1764
1765   Standard_Integer aDxw, aDyw;
1766   MyWindow->Size (aDxw, aDyw);
1767
1768   gp_Pnt aViewDims = myCamera->ViewDimensions();
1769   Standard_Integer aValue = RealToInt (aDxw * Vv / (aViewDims.X()));
1770
1771   return aValue;
1772 }
1773
1774 //=======================================================================
1775 //function : Convert
1776 //purpose  :
1777 //=======================================================================
1778 void V3d_View::Convert(const Standard_Real Xv,
1779                        const Standard_Real Yv,
1780                        Standard_Integer& Xp,
1781                        Standard_Integer& Yp) const
1782 {
1783   V3d_UnMapped_Raise_if (!MyView->IsDefined(), "view has no window");
1784
1785   Standard_Integer aDxw, aDyw;
1786   MyWindow->Size (aDxw, aDyw);
1787
1788   gp_Pnt aPoint (Xv, Yv, 0.0);
1789   aPoint = myCamera->ConvertView2Proj (aPoint);
1790   aPoint = gp_Pnt ((aPoint.X() + 1.0) * aDxw / 2.0, aDyw - (aPoint.Y() + 1.0) * aDyw / 2.0, 0.0);
1791
1792   Xp = RealToInt (aPoint.X());
1793   Yp = RealToInt (aPoint.Y());
1794 }
1795
1796 //=======================================================================
1797 //function : Convert
1798 //purpose  :
1799 //=======================================================================
1800 void V3d_View::Convert(const Standard_Integer Xp,
1801                        const Standard_Integer Yp,
1802                        Standard_Real& X,
1803                        Standard_Real& Y,
1804                        Standard_Real& Z) const
1805 {
1806   V3d_UnMapped_Raise_if (!MyView->IsDefined(), "view has no window");
1807   Standard_Integer aHeight, aWidth;
1808   MyWindow->Size (aWidth, aHeight);
1809
1810   Standard_Real anX = 2.0 * Xp / aWidth - 1.0;
1811   Standard_Real anY = 2.0 * (aHeight - 1 - Yp) / aHeight - 1.0;
1812   Standard_Real  aZ = 2.0 * 0.0 - 1.0;
1813
1814   gp_Pnt aResult = myCamera->UnProject (gp_Pnt (anX, anY, aZ));
1815
1816   X = aResult.X();
1817   Y = aResult.Y();
1818   Z = aResult.Z();
1819 }
1820
1821 //=======================================================================
1822 //function : ConvertWithProj
1823 //purpose  :
1824 //=======================================================================
1825 void V3d_View::ConvertWithProj(const Standard_Integer Xp,
1826                                const Standard_Integer Yp,
1827                                Standard_Real& X,
1828                                Standard_Real& Y,
1829                                Standard_Real& Z,
1830                                Standard_Real& Dx,
1831                                Standard_Real& Dy,
1832                                Standard_Real& Dz) const
1833 {
1834   V3d_UnMapped_Raise_if( !MyView->IsDefined(), "view has no window");
1835   Standard_Integer aHeight, aWidth;
1836   MyWindow->Size (aWidth, aHeight);
1837
1838   Standard_Real anX = 2.0 * Xp / aWidth - 1.0;
1839   Standard_Real anY = 2.0 * (aHeight - 1 - Yp) / aHeight - 1.0;
1840   Standard_Real  aZ = 2.0 * 0.0 - 1.0;
1841
1842   gp_Pnt aResult = myCamera->UnProject (gp_Pnt (anX, anY, aZ));
1843
1844   X = aResult.X();
1845   Y = aResult.Y();
1846   Z = aResult.Z();
1847
1848   Graphic3d_Vertex aVrp;
1849   aVrp.SetCoord (X, Y, Z);
1850
1851   aResult = myCamera->UnProject (gp_Pnt (anX, anY, aZ - 10.0));
1852
1853   Graphic3d_Vec3d aNormDir;
1854   aNormDir.x() = X - aResult.X();
1855   aNormDir.y() = Y - aResult.Y();
1856   aNormDir.z() = Z - aResult.Z();
1857   aNormDir.Normalize();
1858
1859   Dx = aNormDir.x();
1860   Dy = aNormDir.y();
1861   Dz = aNormDir.z();
1862 }
1863
1864 //=======================================================================
1865 //function : Convert
1866 //purpose  :
1867 //=======================================================================
1868 void V3d_View::Convert(const Standard_Real X,
1869                        const Standard_Real Y,
1870                        const Standard_Real Z,
1871                        Standard_Integer& Xp,
1872                        Standard_Integer& Yp) const
1873 {
1874   V3d_UnMapped_Raise_if( !MyView->IsDefined(), "view has no window");
1875   Standard_Integer aHeight, aWidth;
1876   MyWindow->Size (aWidth, aHeight);
1877
1878   gp_Pnt aPoint = myCamera->Project (gp_Pnt (X, Y, Z));
1879
1880   Xp = RealToInt ((aPoint.X() + 1) * 0.5 * aWidth);
1881   Yp = RealToInt (aHeight - 1 - (aPoint.Y() + 1) * 0.5 * aHeight);
1882 }
1883
1884 //=======================================================================
1885 //function : Project
1886 //purpose  :
1887 //=======================================================================
1888 void V3d_View::Project(const Standard_Real X,
1889                        const Standard_Real Y,
1890                        const Standard_Real Z,
1891                        Standard_Real &Xp,
1892                        Standard_Real &Yp) const
1893 {
1894   Standard_Real Zp;
1895   MyView->Projects (X, Y, Z, Xp, Yp, Zp);
1896 }
1897
1898 //=======================================================================
1899 //function : BackgroundColor
1900 //purpose  :
1901 //=======================================================================
1902 void V3d_View::BackgroundColor(const Quantity_TypeOfColor Type,
1903                                Standard_Real& V1,
1904                                Standard_Real& V2,
1905                                Standard_Real& V3) const
1906 {
1907   Quantity_Color C = BackgroundColor() ;
1908   C.Values(V1,V2,V3,Type) ;
1909 }
1910
1911 //=======================================================================
1912 //function : BackgroundColor
1913 //purpose  :
1914 //=======================================================================
1915 Quantity_Color V3d_View::BackgroundColor() const
1916 {
1917   return MyBackground.Color() ;
1918 }
1919
1920 //=======================================================================
1921 //function : GradientBackgroundColors
1922 //purpose  :
1923 //=======================================================================
1924 void V3d_View::GradientBackgroundColors(Quantity_Color& Color1,Quantity_Color& Color2) const
1925 {
1926   MyGradientBackground.Colors(Color1, Color2);
1927 }
1928
1929 //=======================================================================
1930 //function : GradientBackground
1931 //purpose  :
1932 //=======================================================================
1933 Aspect_GradientBackground V3d_View::GradientBackground() const
1934 {
1935    return MyGradientBackground;
1936 }
1937
1938 //=======================================================================
1939 //function : Scale
1940 //purpose  :
1941 //=======================================================================
1942 Standard_Real V3d_View::Scale() const
1943 {
1944   Handle(Graphic3d_Camera) aDefaultCamera = MyView->DefaultCamera();
1945
1946   Standard_Real aCameraScale;
1947
1948   // Strange behavior for the sake of compatibility.
1949   if (!aDefaultCamera.IsNull())
1950   {
1951     Standard_Real aDefaultScale = aDefaultCamera->Scale();
1952     aCameraScale = aDefaultScale / myCamera->Scale();
1953   } 
1954   else
1955   {
1956     aCameraScale = myCamera->Scale();
1957   }
1958
1959   return aCameraScale;
1960 }
1961
1962 //=======================================================================
1963 //function : AxialScale
1964 //purpose  :
1965 //=======================================================================
1966 void V3d_View::AxialScale(Standard_Real& Sx, Standard_Real& Sy, Standard_Real& Sz) const
1967 {
1968   gp_Pnt anAxialScale = myCamera->AxialScale();
1969   Sx = anAxialScale.X();
1970   Sy = anAxialScale.Y();
1971   Sz = anAxialScale.Z();
1972 }
1973
1974 //=======================================================================
1975 //function : Size
1976 //purpose  :
1977 //=======================================================================
1978 void V3d_View::Size(Standard_Real& Width, Standard_Real& Height) const
1979 {
1980   gp_Pnt aViewDims = myCamera->ViewDimensions();
1981
1982   Width = aViewDims.X();
1983   Height = aViewDims.Y();
1984 }
1985
1986 //=======================================================================
1987 //function : ZSize
1988 //purpose  :
1989 //=======================================================================
1990 Standard_Real V3d_View::ZSize() const
1991 {
1992   gp_Pnt aViewDims = myCamera->ViewDimensions();
1993
1994   return aViewDims.Z();
1995 }
1996
1997 //=======================================================================
1998 //function : MinMax
1999 //purpose  :
2000 //=======================================================================
2001 Standard_Integer V3d_View::MinMax(Standard_Real& Umin,
2002                                   Standard_Real& Vmin,
2003                                   Standard_Real& Umax,
2004                                   Standard_Real& Vmax) const
2005 {
2006   Standard_Real Wmin,Wmax,U,V,W ;
2007   Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax ;
2008   // CAL 6/11/98
2009   Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
2010
2011   if( Nstruct ) {
2012     Bnd_Box aBox = MyView->MinMaxValues();
2013     aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
2014     MyView->Projects(Xmin,Ymin,Zmin,Umin,Vmin,Wmin) ;
2015     MyView->Projects(Xmax,Ymax,Zmax,Umax,Vmax,Wmax) ;
2016     MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
2017     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2018     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2019     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2020     MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
2021     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2022     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2023     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2024     MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
2025     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2026     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2027     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2028     MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
2029     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2030     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2031     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2032     MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
2033     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2034     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2035     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2036     MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
2037     Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2038     Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2039     Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2040   }
2041   return Nstruct ;
2042 }
2043
2044 //=======================================================================
2045 //function : MinMax
2046 //purpose  :
2047 //=======================================================================
2048 Standard_Integer V3d_View::MinMax(Standard_Real& Xmin,
2049                                   Standard_Real& Ymin,
2050                                   Standard_Real& Zmin,
2051                                   Standard_Real& Xmax,
2052                                   Standard_Real& Ymax,
2053                                   Standard_Real& Zmax) const
2054 {
2055   // CAL 6/11/98
2056   // Standard_Integer Nstruct = (MyView->DisplayedStructures())->Extent() ;
2057   Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
2058
2059   if( Nstruct ) {
2060     Bnd_Box aBox = MyView->MinMaxValues();
2061     aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
2062   }
2063   return Nstruct ;
2064 }
2065
2066 //=======================================================================
2067 //function : Gravity
2068 //purpose  :
2069 //=======================================================================
2070 void V3d_View::Gravity (Standard_Real& theX,
2071                         Standard_Real& theY,
2072                         Standard_Real& theZ) const
2073 {
2074   Graphic3d_MapOfStructure aSetOfStructures;
2075   MyView->DisplayedStructures (aSetOfStructures);
2076
2077   Standard_Boolean hasSelection = Standard_False;
2078   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aSetOfStructures);
2079        aStructIter.More(); aStructIter.Next())
2080   {
2081     if (aStructIter.Key()->IsHighlighted()
2082      && aStructIter.Key()->IsVisible())
2083     {
2084       hasSelection = Standard_True;
2085       break;
2086     }
2087   }
2088
2089   Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
2090   Standard_Integer aNbPoints = 0;
2091   gp_XYZ aResult (0.0, 0.0, 0.0);
2092   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aSetOfStructures);
2093        aStructIter.More(); aStructIter.Next())
2094   {
2095     const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
2096     if (!aStruct->IsVisible()
2097     || (hasSelection && !aStruct->IsHighlighted())
2098     ||  aStruct->IsEmpty())
2099     {
2100       continue;
2101     }
2102
2103     Bnd_Box aBox = aStruct->MinMaxValues();
2104     if (aBox.IsVoid() || aStruct->IsInfinite())
2105     {
2106       continue;
2107     }
2108
2109     // use camera projection to find gravity point
2110     aBox.Get (Xmin, Ymin, Zmin,
2111               Xmax, Ymax, Zmax);
2112     gp_Pnt aPnts[THE_NB_BOUND_POINTS] =
2113     {
2114       gp_Pnt (Xmin, Ymin, Zmin), gp_Pnt (Xmin, Ymin, Zmax),
2115       gp_Pnt (Xmin, Ymax, Zmin), gp_Pnt (Xmin, Ymax, Zmax),
2116       gp_Pnt (Xmax, Ymin, Zmin), gp_Pnt (Xmax, Ymin, Zmax),
2117       gp_Pnt (Xmax, Ymax, Zmin), gp_Pnt (Xmax, Ymax, Zmax)
2118     };
2119
2120     for (Standard_Integer aPntIt = 0; aPntIt < THE_NB_BOUND_POINTS; ++aPntIt)
2121     {
2122       const gp_Pnt& aBndPnt    = aPnts[aPntIt];
2123       const gp_Pnt  aProjected = myCamera->Project (aBndPnt);
2124       if (Abs (aProjected.X()) <= 1.0
2125        && Abs (aProjected.Y()) <= 1.0)
2126       {
2127         aResult += aBndPnt.XYZ();
2128         ++aNbPoints;
2129       }
2130     }
2131   }
2132
2133   if (aNbPoints == 0)
2134   {
2135     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aSetOfStructures);
2136          aStructIter.More(); aStructIter.Next())
2137     {
2138       const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
2139       if (aStruct->IsEmpty())
2140       {
2141         continue;
2142       }
2143
2144       Bnd_Box aBox = aStruct->MinMaxValues();
2145       if (aBox.IsVoid() || aStruct->IsInfinite())
2146       {
2147         continue;
2148       }
2149
2150       aBox.Get (Xmin, Ymin, Zmin,
2151                 Xmax, Ymax, Zmax);
2152       gp_Pnt aPnts[THE_NB_BOUND_POINTS] =
2153       {
2154         gp_Pnt (Xmin, Ymin, Zmin), gp_Pnt (Xmin, Ymin, Zmax),
2155         gp_Pnt (Xmin, Ymax, Zmin), gp_Pnt (Xmin, Ymax, Zmax),
2156         gp_Pnt (Xmax, Ymin, Zmin), gp_Pnt (Xmax, Ymin, Zmax),
2157         gp_Pnt (Xmax, Ymax, Zmin), gp_Pnt (Xmax, Ymax, Zmax)
2158       };
2159
2160       for (Standard_Integer aPntIt = 0; aPntIt < THE_NB_BOUND_POINTS; ++aPntIt)
2161       {
2162         const gp_Pnt& aBndPnt = aPnts[aPntIt];
2163         aResult += aBndPnt.XYZ();
2164         ++aNbPoints;
2165       }
2166     }
2167   }
2168
2169   if (aNbPoints > 0)
2170   {
2171     aResult /= aNbPoints;
2172   }
2173   theX = aResult.X();
2174   theY = aResult.Y();
2175   theZ = aResult.Z();
2176 }
2177
2178 //=======================================================================
2179 //function : Eye
2180 //purpose  :
2181 //=======================================================================
2182 void V3d_View::Eye(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2183 {
2184   gp_Pnt aCameraEye = myCamera->Eye();
2185   X = aCameraEye.X();
2186   Y = aCameraEye.Y();
2187   Z = aCameraEye.Z();
2188 }
2189
2190 //=============================================================================
2191 //function : FocalReferencePoint
2192 //purpose  :
2193 //=============================================================================
2194 void V3d_View::FocalReferencePoint(Standard_Real& X, Standard_Real& Y,Standard_Real& Z) const
2195 {
2196   Eye (X,Y,Z);
2197 }
2198
2199 //=============================================================================
2200 //function : ProjReferenceAxe
2201 //purpose  :
2202 //=============================================================================
2203 void V3d_View::ProjReferenceAxe(const Standard_Integer Xpix,
2204                                 const Standard_Integer Ypix,
2205                                 Standard_Real& XP,
2206                                 Standard_Real& YP,
2207                                 Standard_Real& ZP,
2208                                 Standard_Real& VX,
2209                                 Standard_Real& VY,
2210                                 Standard_Real& VZ) const
2211 {
2212   Standard_Real Xo,Yo,Zo;
2213
2214   Convert (Xpix, Ypix, XP, YP, ZP);
2215   if ( Type() == V3d_PERSPECTIVE ) 
2216   {
2217     FocalReferencePoint (Xo,Yo,Zo);
2218     VX = Xo - XP;
2219     VY = Yo - YP;
2220     VZ = Zo - ZP;
2221   }
2222   else 
2223   {
2224     Proj (VX,VY,VZ);
2225   }
2226 }
2227
2228 //=============================================================================
2229 //function : Depth
2230 //purpose  :
2231 //=============================================================================
2232 Standard_Real V3d_View::Depth() const
2233 {
2234   return myCamera->Distance();
2235 }
2236
2237 //=============================================================================
2238 //function : Proj
2239 //purpose  :
2240 //=============================================================================
2241 void V3d_View::Proj(Standard_Real& Dx, Standard_Real& Dy, Standard_Real& Dz) const
2242 {
2243   gp_Dir aCameraDir = myCamera->Direction().Reversed();
2244   Dx = aCameraDir.X();
2245   Dy = aCameraDir.Y();
2246   Dz = aCameraDir.Z();
2247 }
2248
2249 //=============================================================================
2250 //function : At
2251 //purpose  :
2252 //=============================================================================
2253 void V3d_View::At(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2254 {
2255   gp_Pnt aCameraCenter = myCamera->Center();
2256   X = aCameraCenter.X();
2257   Y = aCameraCenter.Y();
2258   Z = aCameraCenter.Z();
2259 }
2260
2261 //=============================================================================
2262 //function : Up
2263 //purpose  :
2264 //=============================================================================
2265 void V3d_View::Up(Standard_Real& Vx, Standard_Real& Vy, Standard_Real& Vz) const
2266 {
2267   gp_Dir aCameraUp = myCamera->Up();
2268   Vx = aCameraUp.X();
2269   Vy = aCameraUp.Y();
2270   Vz = aCameraUp.Z();
2271 }
2272
2273 //=============================================================================
2274 //function : Twist
2275 //purpose  :
2276 //=============================================================================
2277 Standard_Real V3d_View::Twist() const
2278 {
2279   Standard_Real Xup,Yup,Zup,Xpn,Ypn,Zpn,X0,Y0,Z0 ;
2280   Standard_Real pvx,pvy,pvz,pvn,sca,angle ;
2281   Graphic3d_Vector Xaxis,Yaxis,Zaxis ;
2282   Standard_Boolean TheStatus ;
2283
2284   gp_Dir aReferencePlane (myCamera->Direction().Reversed());
2285   gp_Dir anUp;
2286
2287   Proj(Xpn,Ypn,Zpn);
2288   anUp = gp_Dir (0.,0.,1.) ;
2289   TheStatus = ScreenAxis (aReferencePlane, anUp,Xaxis,Yaxis,Zaxis) ;
2290   if( !TheStatus ) {
2291     anUp = gp_Dir (0.,1.,0.) ;
2292     TheStatus = ScreenAxis (aReferencePlane, anUp,Xaxis,Yaxis,Zaxis) ;
2293   }
2294   if( !TheStatus ) {
2295     anUp = gp_Dir (1.,0.,0.) ;
2296     TheStatus = ScreenAxis (aReferencePlane, anUp,Xaxis,Yaxis,Zaxis) ;
2297   }
2298   Yaxis.Coord(X0,Y0,Z0) ;
2299
2300   Up(Xup,Yup,Zup) ;
2301   /* Compute Cross Vector From Up & Origin */
2302   pvx = Y0*Zup - Z0*Yup ;
2303   pvy = Z0*Xup - X0*Zup ;
2304   pvz = X0*Yup - Y0*Xup ;
2305   pvn = pvx*pvx + pvy*pvy + pvz*pvz ;
2306   sca = X0*Xup + Y0*Yup + Z0*Zup ;
2307   /* Compute Angle */
2308   angle = Sqrt(pvn) ;
2309   if( angle > 1. ) angle = 1. ;
2310   else if( angle < -1. ) angle = -1. ;
2311   angle = asin(angle) ;
2312   if( sca < 0. ) angle = M_PI - angle ;
2313   if( angle > 0. && angle < M_PI ) {
2314     sca = pvx*Xpn + pvy*Ypn + pvz*Zpn ;
2315     if( sca < 0. ) angle = DEUXPI - angle ;
2316   }
2317   return angle ;
2318 }
2319
2320 //=============================================================================
2321 //function : ShadingModel
2322 //purpose  :
2323 //=============================================================================
2324 V3d_TypeOfShadingModel V3d_View::ShadingModel() const
2325 {
2326   V3d_TypeOfShadingModel SM = (V3d_TypeOfShadingModel)MyViewContext.Model() ;
2327   return SM ;
2328 }
2329
2330 //=============================================================================
2331 //function : SurfaceDetail
2332 //purpose  :
2333 //=============================================================================
2334 V3d_TypeOfSurfaceDetail V3d_View::SurfaceDetail() const
2335 {
2336   V3d_TypeOfSurfaceDetail SM = (V3d_TypeOfSurfaceDetail)MyViewContext.SurfaceDetail() ;
2337   return SM ;
2338 }
2339
2340 //=============================================================================
2341 //function : TextureEnv
2342 //purpose  :
2343 //=============================================================================
2344 Handle(Graphic3d_TextureEnv) V3d_View::TextureEnv() const
2345 {
2346   Handle(Graphic3d_TextureEnv) SM = MyViewContext.TextureEnv() ;
2347   return SM ;
2348 }
2349
2350 //=============================================================================
2351 //function : Visualization
2352 //purpose  :
2353 //=============================================================================
2354 V3d_TypeOfVisualization V3d_View::Visualization() const
2355 {
2356   V3d_TypeOfVisualization V =
2357     (V3d_TypeOfVisualization)MyViewContext.Visualization() ;
2358   return V ;
2359 }
2360
2361 //=============================================================================
2362 //function : Antialiasing
2363 //purpose  :
2364 //=============================================================================
2365 Standard_Boolean V3d_View::Antialiasing() const
2366 {
2367   Standard_Boolean A = MyViewContext.AliasingIsOn() ;
2368   return A ;
2369 }
2370
2371 //=============================================================================
2372 //function : Viewer
2373 //purpose  :
2374 //=============================================================================
2375 Handle(V3d_Viewer) V3d_View::Viewer() const
2376 {
2377   return MyViewer ;
2378 }
2379
2380 //=============================================================================
2381 //function : IfWindow
2382 //purpose  :
2383 //=============================================================================
2384 Standard_Boolean V3d_View::IfWindow() const
2385 {
2386   Standard_Boolean TheStatus = MyView->IsDefined() ;
2387   return TheStatus ;
2388 }
2389
2390 //=============================================================================
2391 //function : Window
2392 //purpose  :
2393 //=============================================================================
2394 Handle(Aspect_Window) V3d_View::Window() const
2395 {
2396   return MyWindow;
2397 }
2398
2399 //=============================================================================
2400 //function : Type
2401 //purpose  :
2402 //=============================================================================
2403 V3d_TypeOfView V3d_View::Type() const
2404 {
2405   return myCamera->IsOrthographic() ? V3d_ORTHOGRAPHIC : V3d_PERSPECTIVE;
2406 }
2407
2408 //=============================================================================
2409 //function : SetFocale
2410 //purpose  :
2411 //=============================================================================
2412 void V3d_View::SetFocale( const Standard_Real focale )
2413 {
2414   if (myCamera->IsOrthographic())
2415   {
2416     return;
2417   }
2418
2419   Standard_Real aFOVyRad = ATan (focale / (myCamera->Distance() * 2.0));
2420
2421   myCamera->SetFOVy (aFOVyRad * (360 / M_PI));
2422
2423   ImmediateUpdate();
2424 }
2425
2426 //=============================================================================
2427 //function : Focale
2428 //purpose  :
2429 //=============================================================================
2430 Standard_Real V3d_View::Focale() const
2431 {
2432   if (myCamera->IsOrthographic())
2433   {
2434     return 0.0;
2435   }
2436
2437   return myCamera->Distance() * 2.0 * Tan(myCamera->FOVy() * M_PI / 360.0);
2438 }
2439
2440 //=============================================================================
2441 //function : View
2442 //purpose  :
2443 //=============================================================================
2444 Handle(Visual3d_View) V3d_View::View() const
2445 {
2446   return MyView ;
2447 }
2448
2449 //=============================================================================
2450 //function : ScreenAxis
2451 //purpose  :
2452 //=============================================================================
2453 Standard_Boolean V3d_View::ScreenAxis( const gp_Dir &Vpn, const gp_Dir &Vup, Graphic3d_Vector &Xaxe, Graphic3d_Vector &Yaxe, Graphic3d_Vector &Zaxe)
2454 {
2455   Standard_Real Xpn, Ypn, Zpn, Xup, Yup, Zup;
2456   Standard_Real dx1, dy1, dz1, xx, yy, zz;
2457
2458   Xpn = Vpn.X(); Ypn = Vpn.Y(); Zpn = Vpn.Z();
2459   Xup = Vup.X(); Yup = Vup.Y(); Zup = Vup.Z();
2460   xx = Yup*Zpn - Zup*Ypn;
2461   yy = Zup*Xpn - Xup*Zpn;
2462   zz = Xup*Ypn - Yup*Xpn;
2463   Xaxe.SetCoord (xx, yy, zz);
2464   if (Xaxe.LengthZero()) return Standard_False;
2465   Xaxe.Normalize(); 
2466   Xaxe.Coord(dx1, dy1, dz1);
2467   xx = Ypn*dz1 - Zpn*dy1;
2468   yy = Zpn*dx1 - Xpn*dz1;
2469   zz = Xpn*dy1 - Ypn*dx1;
2470   Yaxe.SetCoord (xx, yy, zz) ;
2471   if (Yaxe.LengthZero()) return Standard_False;
2472   Yaxe.Normalize(); 
2473
2474   Zaxe.SetCoord (Xpn, Ypn, Zpn);
2475   Zaxe.Normalize();
2476   return Standard_True;
2477 }
2478
2479 //=============================================================================
2480 //function : TrsPoint
2481 //purpose  :
2482 //=============================================================================
2483 Graphic3d_Vertex V3d_View::TrsPoint( const Graphic3d_Vertex &P, const TColStd_Array2OfReal &Matrix )
2484 {
2485   Graphic3d_Vertex PP ;
2486   Standard_Real X,Y,Z,XX,YY,ZZ ;
2487
2488   // CAL. S3892
2489   Standard_Integer lr, ur, lc, uc;
2490   lr    = Matrix.LowerRow ();
2491   ur    = Matrix.UpperRow ();
2492   lc    = Matrix.LowerCol ();
2493   uc    = Matrix.UpperCol ();
2494   if ((ur - lr + 1 != 4) || (uc - lc + 1 != 4) ) {
2495     P.Coord(X,Y,Z) ;
2496     PP.SetCoord(X,Y,Z) ;
2497     return PP ;
2498   }
2499   P.Coord(X,Y,Z) ;
2500   XX = (Matrix(lr,lc+3) + X*Matrix(lr,lc) + Y*Matrix(lr,lc+1)+
2501     Z*Matrix(lr,lc+2))/Matrix(lr+3,lc+3) ;
2502
2503   YY = (Matrix(lr+1,lc+3) + X*Matrix(lr+1,lc) + Y*Matrix(lr+1,lc+1) +
2504     Z*Matrix(lr+1,lc+2))/Matrix(lr+3,lc+3) ;
2505
2506   ZZ = (Matrix(lr+2,lc+3) + X*Matrix(lr+2,lc) + Y*Matrix(lr+2,lc+1) +
2507     Z*Matrix(lr+2,lc+2))/Matrix(lr+3,lc+3) ;
2508   PP.SetCoord(XX,YY,ZZ) ;
2509   return PP ;
2510 }
2511
2512 //=======================================================================
2513 //function : Pan
2514 //purpose  :
2515 //=======================================================================
2516 void V3d_View::Pan (const Standard_Integer theDXp,
2517                     const Standard_Integer theDYp,
2518                     const Quantity_Factor  theZoomFactor,
2519                     const Standard_Boolean theToStart)
2520 {
2521   Panning (Convert (theDXp), Convert (theDYp), theZoomFactor, theToStart);
2522 }
2523
2524 //=======================================================================
2525 //function : Panning
2526 //purpose  :
2527 //=======================================================================
2528 void V3d_View::Panning (const Standard_Real theDXv,
2529                         const Standard_Real theDYv,
2530                         const Quantity_Factor theZoomFactor,
2531                         const Standard_Boolean theToStart)
2532 {
2533   Standard_ASSERT_RAISE (theZoomFactor > 0.0, "Bad zoom factor");
2534
2535   if (theToStart)
2536   {
2537     myCamStartOpEye = myCamera->Eye();
2538     myCamStartOpCenter = myCamera->Center();
2539   }
2540
2541   Standard_Boolean wasUpdateEnabled = SetImmediateUpdate (Standard_False);
2542
2543   gp_Pnt aViewDims = myCamera->ViewDimensions();
2544
2545   myCamera->SetEye (myCamStartOpEye);
2546   myCamera->SetCenter (myCamStartOpCenter);
2547   Translate (myCamera, -theDXv, -theDYv);
2548   Scale (myCamera, aViewDims.X() / theZoomFactor, aViewDims.Y() / theZoomFactor);
2549
2550   SetImmediateUpdate (wasUpdateEnabled);
2551
2552   ImmediateUpdate();
2553 }
2554
2555 //=======================================================================
2556 //function : Zoom
2557 //purpose  :
2558 //=======================================================================
2559 void V3d_View::Zoom (const Standard_Integer theXp1,
2560                      const Standard_Integer theYp1,
2561                      const Standard_Integer theXp2,
2562                      const Standard_Integer theYp2)
2563 {
2564   Standard_Integer aDx = theXp2 - theXp1;
2565   Standard_Integer aDy = theYp2 - theYp1;
2566   if (aDx != 0 || aDy != 0)
2567   {
2568     Standard_Real aCoeff = Sqrt( (Standard_Real)(aDx * aDx + aDy * aDy) ) / 100.0 + 1.0;
2569     aCoeff = (aDx > 0) ? aCoeff : 1.0 / aCoeff;
2570     SetZoom (aCoeff, Standard_True);
2571   }
2572 }
2573
2574 //=======================================================================
2575 //function : StartZoomAtPoint
2576 //purpose  :
2577 //=======================================================================
2578 void V3d_View::StartZoomAtPoint (const Standard_Integer theXp,
2579                                  const Standard_Integer theYp)
2580 {
2581   MyZoomAtPointX = theXp;
2582   MyZoomAtPointY = theYp;
2583 }
2584
2585 //=======================================================================
2586 //function : ZoomAtPoint
2587 //purpose  :
2588 //=======================================================================
2589 void V3d_View::ZoomAtPoint (const Standard_Integer theMouseStartX,
2590                             const Standard_Integer theMouseStartY,
2591                             const Standard_Integer theMouseEndX,
2592                             const Standard_Integer theMouseEndY)
2593 {
2594   Standard_Boolean wasUpdateEnabled = SetImmediateUpdate (Standard_False);
2595
2596   // zoom
2597   Standard_Real aDxy = Standard_Real ((theMouseEndX + theMouseEndY) - (theMouseStartX + theMouseStartY));
2598   Standard_Real aDZoom = Abs (aDxy) / 100.0 + 1.0;
2599   aDZoom = (aDxy > 0.0) ?  aDZoom : 1.0 / aDZoom;
2600
2601   V3d_BadValue_Raise_if (aDZoom <= 0.0, "V3d_View::ZoomAtPoint, bad coefficient");
2602
2603   Standard_Real aViewWidth  = myCamera->ViewDimensions().X();
2604   Standard_Real aViewHeight = myCamera->ViewDimensions().Y();
2605
2606   // ensure that zoom will not be too small or too big.
2607   Standard_Real aCoef = aDZoom;
2608   if (aViewWidth < aCoef * Precision::Confusion())
2609   {
2610     aCoef = aViewWidth / Precision::Confusion();
2611   }
2612   else if (aViewWidth > aCoef * 1e12)
2613   {
2614     aCoef = aViewWidth / 1e12;
2615   }
2616   if (aViewHeight < aCoef * Precision::Confusion())
2617   {
2618     aCoef = aViewHeight / Precision::Confusion();
2619   }
2620   else if (aViewHeight > aCoef * 1e12)
2621   {
2622     aCoef = aViewHeight / 1e12;
2623   }
2624
2625   Standard_Real aZoomAtPointXv = 0.0;
2626   Standard_Real aZoomAtPointYv = 0.0;
2627   Convert (MyZoomAtPointX, MyZoomAtPointY, aZoomAtPointXv, aZoomAtPointYv);
2628
2629   V3d_Coordinate aDxv = aZoomAtPointXv / aCoef;
2630   V3d_Coordinate aDyv = aZoomAtPointYv / aCoef;
2631
2632   myCamera->SetScale (myCamera->Scale() / aCoef);
2633   Translate (myCamera, aZoomAtPointXv - aDxv, aZoomAtPointYv - aDyv);
2634
2635   View()->AutoZFit();
2636
2637   SetImmediateUpdate (wasUpdateEnabled);
2638
2639   ImmediateUpdate();
2640 }
2641
2642 //=============================================================================
2643 //function : AxialScale
2644 //purpose  :
2645 //=============================================================================
2646 void V3d_View::AxialScale (const Standard_Integer Dx,
2647                            const Standard_Integer Dy,
2648                            const V3d_TypeOfAxe Axis)
2649 {
2650   if( Dx != 0. || Dy != 0. ) {
2651     Standard_Real Sx, Sy, Sz;
2652     AxialScale( Sx, Sy, Sz );
2653     Standard_Real dscale = Sqrt(Dx*Dx + Dy*Dy) / 100. + 1;
2654     dscale = (Dx > 0) ?  dscale : 1./dscale;
2655     if( Axis == V3d_X ) Sx = dscale;
2656     if( Axis == V3d_Y ) Sy = dscale;
2657     if( Axis == V3d_Z ) Sz = dscale;
2658     SetAxialScale( Sx, Sy, Sz );
2659   }
2660 }
2661
2662 //=============================================================================
2663 //function : FitAll
2664 //purpose  :
2665 //=============================================================================
2666 void V3d_View::FitAll(const Handle(Aspect_Window)& aWindow,
2667                       const Standard_Real Xmin,
2668                       const Standard_Real Ymin,
2669                       const Standard_Real Xmax,
2670                       const Standard_Real Ymax)
2671 {
2672   Standard_Integer aWinWidth, aWinHeight;
2673   aWindow->Size (aWinWidth, aWinHeight);
2674
2675   Standard_Real aWinAspect = (Standard_Real)aWinWidth / aWinHeight;
2676   Standard_Real aFitSizeU  = Abs (Xmax - Xmin);
2677   Standard_Real aFitSizeV  = Abs (Ymax - Ymin);
2678   Standard_Real aFitAspect = aFitSizeU / aFitSizeV;
2679   if (aFitAspect >= aWinAspect)
2680   {
2681     aFitSizeV = aFitSizeU / aWinAspect;
2682   }
2683   else
2684   {
2685     aFitSizeU = aFitSizeV * aWinAspect;
2686   }
2687
2688   myCamera->SetAspect (aWinAspect);
2689   Translate (myCamera, (Xmin + Xmax) * 0.5, (Ymin + Ymax) * 0.5);
2690   Scale (myCamera, aFitSizeU, aFitSizeV);
2691   View()->AutoZFit();
2692
2693   ImmediateUpdate();
2694 }
2695
2696 //=============================================================================
2697 //function : StartRotation
2698 //purpose  :
2699 //=============================================================================
2700 static Standard_Boolean zRotation = Standard_False;
2701 void V3d_View::StartRotation(const Standard_Integer X,
2702                              const Standard_Integer Y,
2703                              const Quantity_Ratio zRotationThreshold)
2704 {
2705   sx = X; sy = Y;
2706   Standard_Real x,y;
2707   Size(x,y);
2708   rx = Standard_Real(Convert(x));
2709   ry = Standard_Real(Convert(y));
2710   Gravity(gx,gy,gz);
2711   Rotate(0.,0.,0.,gx,gy,gz,Standard_True);
2712   zRotation = Standard_False;
2713   if( zRotationThreshold > 0. ) {
2714     Standard_Real dx = Abs(sx - rx/2.);
2715     Standard_Real dy = Abs(sy - ry/2.);
2716     //  if( dx > rx/3. || dy > ry/3. ) zRotation = Standard_True;
2717     Standard_Real dd = zRotationThreshold * (rx + ry)/2.;
2718     if( dx > dd || dy > dd ) zRotation = Standard_True;
2719   }
2720
2721 }
2722
2723 //=============================================================================
2724 //function : Rotation
2725 //purpose  :
2726 //=============================================================================
2727 void V3d_View::Rotation(const Standard_Integer X,
2728                         const Standard_Integer Y)
2729 {
2730   if( rx == 0. || ry == 0. ) {
2731     StartRotation(X,Y);
2732     return;
2733   }
2734   Standard_Real dx=0.,dy=0.,dz=0.;
2735   if( zRotation ) {
2736     dz = atan2(Standard_Real(X)-rx/2., ry/2.-Standard_Real(Y)) -
2737       atan2(sx-rx/2.,ry/2.-sy);
2738   } else {
2739     dx = (Standard_Real(X) - sx) * M_PI / rx;
2740     dy = (sy - Standard_Real(Y)) * M_PI / ry;
2741   }
2742
2743   Rotate(dx, dy, dz, gx, gy, gz, Standard_False);
2744 }
2745
2746 //=============================================================================
2747 //function : SetComputedMode
2748 //purpose  :
2749 //=============================================================================
2750 void V3d_View::SetComputedMode (const Standard_Boolean aMode)
2751 {
2752   if (aMode)
2753   {
2754     if (myComputedMode)
2755     {
2756       MyView->SetComputedMode (Standard_True);
2757       Update();
2758     }
2759   } 
2760   else 
2761   {
2762     MyView->SetComputedMode (Standard_False);
2763     Update();
2764   }
2765 }
2766
2767 //=============================================================================
2768 //function : ComputedMode
2769 //purpose  :
2770 //=============================================================================
2771 Standard_Boolean V3d_View::ComputedMode() const
2772 {
2773   return MyView->ComputedMode();
2774 }
2775
2776 //=============================================================================
2777 //function : SetBackFacingModel
2778 //purpose  :
2779 //=============================================================================
2780 void V3d_View::SetBackFacingModel (const V3d_TypeOfBackfacingModel aModel)
2781 {
2782   MyView->SetBackFacingModel (Visual3d_TypeOfBackfacingModel(aModel));
2783   Redraw();
2784 }
2785
2786 //=============================================================================
2787 //function : BackFacingModel
2788 //purpose  :
2789 //=============================================================================
2790 V3d_TypeOfBackfacingModel V3d_View::BackFacingModel() const
2791 {
2792   return V3d_TypeOfBackfacingModel(MyView -> BackFacingModel ());
2793 }
2794
2795 void V3d_View::Init()
2796 {
2797   myComputedMode = MyViewer->ComputedMode();
2798   if( !myComputedMode || !MyViewer->DefaultComputedMode() ) {
2799     SetComputedMode(Standard_False);
2800   }
2801 }
2802
2803 //=============================================================================
2804 //function : Dump
2805 //purpose  :
2806 //=============================================================================
2807 Standard_Boolean V3d_View::Dump (const Standard_CString      theFile,
2808                                  const Graphic3d_BufferType& theBufferType)
2809 {
2810   Standard_Integer aWinWidth, aWinHeight;
2811   MyWindow->Size (aWinWidth, aWinHeight);
2812   Image_AlienPixMap anImage;
2813
2814   return ToPixMap (anImage, aWinWidth, aWinHeight, theBufferType) && anImage.Save (theFile);
2815 }
2816
2817 //=============================================================================
2818 //function : ToPixMap
2819 //purpose  :
2820 //=============================================================================
2821 Standard_Boolean V3d_View::ToPixMap (Image_PixMap&               theImage,
2822                                      const Standard_Integer      theWidth,
2823                                      const Standard_Integer      theHeight,
2824                                      const Graphic3d_BufferType& theBufferType,
2825                                      const Standard_Boolean      theToKeepAspect,
2826                                      const V3d_StereoDumpOptions theStereoOptions)
2827 {
2828   Graphic3d_CView* cView = (Graphic3d_CView* )MyView->CView();
2829
2830   // always prefer hardware accelerated offscreen buffer
2831   Graphic3d_PtrFrameBuffer aFBOPtr = NULL;
2832   Graphic3d_PtrFrameBuffer aPrevFBOPtr = (Graphic3d_PtrFrameBuffer )cView->ptrFBO;
2833   Standard_Integer aFBOVPSizeX (theWidth), aFBOVPSizeY (theHeight), aFBOSizeXMax (0), aFBOSizeYMax (0);
2834   Standard_Integer aPrevFBOVPSizeX (0), aPrevFBOVPSizeY (0), aPrevFBOSizeXMax (0), aPrevFBOSizeYMax (0);
2835   if (aPrevFBOPtr != NULL)
2836   {
2837     MyView->FBOGetDimensions (aPrevFBOPtr,
2838                               aPrevFBOVPSizeX, aPrevFBOVPSizeY,
2839                               aPrevFBOSizeXMax, aPrevFBOSizeYMax);
2840     if (aFBOVPSizeX <= aPrevFBOSizeXMax && aFBOVPSizeY <= aPrevFBOSizeYMax)
2841     {
2842       MyView->FBOChangeViewport (aPrevFBOPtr, aFBOVPSizeX, aFBOVPSizeY);
2843       aFBOPtr = aPrevFBOPtr;
2844     }
2845   }
2846
2847   if (aFBOPtr == NULL)
2848   {
2849     // Try to create hardware accelerated buffer
2850     aFBOPtr = MyView->FBOCreate (aFBOVPSizeX, aFBOVPSizeY);
2851     if (aFBOPtr != NULL)
2852     {
2853       MyView->FBOGetDimensions (aFBOPtr,
2854                                 aFBOVPSizeX,  aFBOVPSizeY,
2855                                 aFBOSizeXMax, aFBOSizeYMax);
2856       // reduce viewport in case of hardware limits
2857       if (aFBOVPSizeX > aFBOSizeXMax) aFBOVPSizeX = aFBOSizeXMax;
2858       if (aFBOVPSizeY > aFBOSizeYMax) aFBOVPSizeY = aFBOSizeYMax;
2859       MyView->FBOChangeViewport (aFBOPtr, aFBOVPSizeX, aFBOVPSizeY);
2860     }
2861   }
2862   cView->ptrFBO = aFBOPtr;
2863
2864   // If hardware accelerated buffer - try to use onscreen buffer
2865   // Results may be bad!
2866   if (aFBOPtr == NULL)
2867   {
2868     // retrieve window sizes
2869     Standard_Integer aWinWidth, aWinHeight;
2870     MyWindow->Size (aWinWidth, aWinHeight);
2871
2872     // technically we can reduce existing viewport...
2873     // but currently allow only dumping the window itself
2874     if (aFBOVPSizeX != aWinWidth || aFBOVPSizeY != aWinHeight)
2875     {
2876       return Standard_False;
2877     }
2878   }
2879
2880   Handle(Graphic3d_Camera) aStoreMapping = new Graphic3d_Camera();
2881
2882   aStoreMapping->Copy (myCamera);
2883
2884   if (myCamera->IsStereo())
2885   {
2886     switch (theStereoOptions)
2887     {
2888       case V3d_SDO_MONO:
2889       {
2890         myCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
2891         break;
2892       }
2893       case V3d_SDO_LEFT_EYE:
2894       {
2895         myCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
2896         break;
2897       }
2898       case V3d_SDO_RIGHT_EYE:
2899       {
2900         myCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
2901         break;
2902       }
2903       case V3d_SDO_BLENDED:
2904       {
2905         break; // dump as is
2906       }
2907     }
2908   }
2909
2910   // render immediate structures into back buffer rather than front
2911   Handle(Graphic3d_GraphicDriver) aDriver = Handle(Graphic3d_GraphicDriver)::DownCast (MyView->GraphicDriver());
2912   const Standard_Boolean aPrevImmediateMode = aDriver.IsNull() ? Standard_True : aDriver->SetImmediateModeDrawToFront (*cView, Standard_False);
2913
2914   const Standard_Boolean toAutoUpdate = myImmediateUpdate;
2915   myImmediateUpdate = Standard_False;
2916   View()->AutoZFit();
2917   myImmediateUpdate = toAutoUpdate;
2918
2919   if (theToKeepAspect)
2920   {
2921     myCamera->SetAspect ((Standard_Real) aFBOVPSizeX / aFBOVPSizeY);
2922   }
2923
2924   //workaround for rendering list of Over and Under Layers
2925   if (!MyLayerMgr.IsNull())
2926   {
2927     MyLayerMgr->Compute();
2928   }
2929
2930   Redraw();
2931
2932   if (!aDriver.IsNull())
2933   {
2934     aDriver->SetImmediateModeDrawToFront (*cView, aPrevImmediateMode);
2935   }
2936
2937   myCamera->Copy (aStoreMapping);
2938
2939   Standard_Boolean isSuccess = Standard_True;
2940
2941   // allocate image buffer for dumping
2942   if (theImage.IsEmpty()
2943    || (Standard_Size )aFBOVPSizeX != theImage.SizeX()
2944    || (Standard_Size )aFBOVPSizeY != theImage.SizeY())
2945   {
2946     bool isBigEndian = Image_PixMap::IsBigEndianHost();
2947     Image_PixMap::ImgFormat aFormat = Image_PixMap::ImgUNKNOWN;
2948     switch (theBufferType)
2949     {
2950       case Graphic3d_BT_RGB:   aFormat = isBigEndian ? Image_PixMap::ImgRGB  : Image_PixMap::ImgBGR;  break;
2951       case Graphic3d_BT_RGBA:  aFormat = isBigEndian ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA; break;
2952       case Graphic3d_BT_Depth: aFormat = Image_PixMap::ImgGrayF; break;
2953     }
2954
2955     isSuccess = isSuccess && theImage.InitZero (aFormat, aFBOVPSizeX, aFBOVPSizeY);
2956   }
2957   isSuccess = isSuccess && MyView->BufferDump (theImage, theBufferType);
2958
2959   // FBO now useless, free resources
2960   if (aFBOPtr != aPrevFBOPtr)
2961   {
2962     MyView->FBORelease (aFBOPtr);
2963   }
2964   else if (aPrevFBOPtr != NULL)
2965   {
2966     MyView->FBOChangeViewport (aPrevFBOPtr, aPrevFBOVPSizeX, aPrevFBOVPSizeY);
2967   }
2968   cView->ptrFBO = aPrevFBOPtr;
2969   return isSuccess;
2970 }
2971
2972 void V3d_View::ImmediateUpdate() const
2973 {
2974   if (myImmediateUpdate) Update();
2975 }
2976
2977 Standard_Boolean V3d_View::SetImmediateUpdate (const Standard_Boolean theImmediateUpdate)
2978 {
2979   Standard_Boolean aPreviousMode = myImmediateUpdate;
2980   myImmediateUpdate = theImmediateUpdate;
2981   return aPreviousMode;
2982 }
2983
2984 // =======================================================================
2985 // function : SetCamera
2986 // purpose  :
2987 // =======================================================================
2988 void V3d_View::SetCamera (const Handle(Graphic3d_Camera)& theCamera)
2989 {
2990   Standard_ASSERT_RAISE (!theCamera.IsNull(), "Void camera is not allowed");
2991
2992   myCamera = theCamera;
2993
2994   MyView->SetCamera (theCamera);
2995 }
2996
2997 // =======================================================================
2998 // function : GetCamera
2999 // purpose  :
3000 // =======================================================================
3001 const Handle(Graphic3d_Camera)& V3d_View::Camera() const
3002 {
3003   return myCamera;
3004 }
3005
3006 // =======================================================================
3007 // function : FitMinMax
3008 // purpose  : Internal
3009 // =======================================================================
3010 Standard_Boolean V3d_View::FitMinMax (const Handle(Graphic3d_Camera)& theCamera,
3011                                       const Bnd_Box& theBox,
3012                                       const Standard_Real theMargin,
3013                                       const Standard_Real theResolution,
3014                                       const Standard_Boolean theToEnlargeIfLine) const
3015 {
3016   // Check bounding box for validness
3017   if (theBox.IsVoid())
3018   {
3019     return Standard_False; // bounding box is out of bounds...
3020   }
3021
3022   // Apply "axial scaling" to the bounding points.
3023   // It is not the best approach to make this scaling as a part of fit all operation,
3024   // but the axial scale is integrated into camera orientation matrix and the other
3025   // option is to perform frustum plane adjustment algorithm in view camera space,
3026   // which will lead to a number of additional world-view space conversions and
3027   // loosing precision as well.
3028   gp_Pnt aBndMin = theBox.CornerMin().XYZ().Multiplied (theCamera->AxialScale());
3029   gp_Pnt aBndMax = theBox.CornerMax().XYZ().Multiplied (theCamera->AxialScale());
3030
3031   if (aBndMax.IsEqual (aBndMin, RealEpsilon()))
3032   {
3033     return Standard_False; // nothing to fit all
3034   }
3035
3036   // Prepare camera frustum planes.
3037   NCollection_Array1<gp_Pln> aFrustumPlane (1, 6);
3038   theCamera->Frustum (aFrustumPlane.ChangeValue (1),
3039                       aFrustumPlane.ChangeValue (2),
3040                       aFrustumPlane.ChangeValue (3),
3041                       aFrustumPlane.ChangeValue (4),
3042                       aFrustumPlane.ChangeValue (5),
3043                       aFrustumPlane.ChangeValue (6));
3044
3045   // Prepare camera up, side, direction vectors.
3046   gp_Dir aCamUp  = theCamera->OrthogonalizedUp();
3047   gp_Dir aCamDir = theCamera->Direction();
3048   gp_Dir aCamSide = aCamDir ^ aCamUp;
3049
3050   // Prepare scene bounding box parameters.
3051   gp_Pnt aBndCenter = (aBndMin.XYZ() + aBndMax.XYZ()) / 2.0;
3052
3053   NCollection_Array1<gp_Pnt> aBndCorner (1, 8);
3054   aBndCorner.ChangeValue (1) = gp_Pnt (aBndMin.X(), aBndMin.Y(), aBndMin.Z());
3055   aBndCorner.ChangeValue (2) = gp_Pnt (aBndMin.X(), aBndMin.Y(), aBndMax.Z());
3056   aBndCorner.ChangeValue (3) = gp_Pnt (aBndMin.X(), aBndMax.Y(), aBndMin.Z());
3057   aBndCorner.ChangeValue (4) = gp_Pnt (aBndMin.X(), aBndMax.Y(), aBndMax.Z());
3058   aBndCorner.ChangeValue (5) = gp_Pnt (aBndMax.X(), aBndMin.Y(), aBndMin.Z());
3059   aBndCorner.ChangeValue (6) = gp_Pnt (aBndMax.X(), aBndMin.Y(), aBndMax.Z());
3060   aBndCorner.ChangeValue (7) = gp_Pnt (aBndMax.X(), aBndMax.Y(), aBndMin.Z());
3061   aBndCorner.ChangeValue (8) = gp_Pnt (aBndMax.X(), aBndMax.Y(), aBndMax.Z());
3062
3063   // Perspective-correct camera projection vector, matching the bounding box is determined geometrically.
3064   // Knowing the initial shape of a frustum it is possible to match it to a bounding box.
3065   // Then, knowing the relation of camera projection vector to the frustum shape it is possible to
3066   // set up perspective-correct camera projection matching the bounding box.
3067   // These steps support non-asymmetric transformations of view-projection space provided by camera.
3068   // The zooming can be done by calculating view plane size matching the bounding box at center of
3069   // the bounding box. The only limitation here is that the scale of camera should define size of
3070   // its view plane passing through the camera center, and the center of camera should be on the
3071   // same line with the center of bounding box.
3072
3073   // The following method is applied:
3074   // 1) Determine normalized asymmetry of camera projection vector by frustum planes.
3075   // 2) Determine new location of frustum planes, "matching" the bounding box.
3076   // 3) Determine new camera projection vector using the normalized asymmetry.
3077   // 4) Determine new zooming in view space.
3078
3079   // 1. Determine normalized projection asymmetry (if any).
3080   Standard_Real anAssymX = Tan ( aCamSide.Angle (aFrustumPlane (1).Axis().Direction()))
3081                          - Tan (-aCamSide.Angle (aFrustumPlane (2).Axis().Direction()));
3082   Standard_Real anAssymY = Tan ( aCamUp.Angle   (aFrustumPlane (3).Axis().Direction()))
3083                          - Tan (-aCamUp.Angle   (aFrustumPlane (4).Axis().Direction()));
3084
3085   // 2. Determine how far should be the frustum planes placed from center
3086   //    of bounding box, in order to match the bounding box closely.
3087   NCollection_Array1<Standard_Real> aFitDistance (1, 6);
3088   aFitDistance.ChangeValue (1) = 0.0;
3089   aFitDistance.ChangeValue (2) = 0.0;
3090   aFitDistance.ChangeValue (3) = 0.0;
3091   aFitDistance.ChangeValue (4) = 0.0;
3092   aFitDistance.ChangeValue (5) = 0.0;
3093   aFitDistance.ChangeValue (6) = 0.0;
3094
3095   for (Standard_Integer anI = aFrustumPlane.Lower(); anI <= aFrustumPlane.Upper(); ++anI)
3096   {
3097     // Measure distances from center of bounding box to its corners towards the frustum plane.
3098     const gp_Dir& aPlaneN = aFrustumPlane.ChangeValue (anI).Axis().Direction();
3099
3100     Standard_Real& aFitDist = aFitDistance.ChangeValue (anI);
3101
3102     for (Standard_Integer aJ = aBndCorner.Lower(); aJ <= aBndCorner.Upper(); ++aJ)
3103     {
3104       aFitDist = Max (aFitDist, gp_Vec (aBndCenter, aBndCorner (aJ)).Dot (aPlaneN));
3105     }
3106   }
3107   // The center of camera is placed on the same line with center of bounding box.
3108   // The view plane section crosses the bounding box at its center.
3109   // To compute view plane size, evaluate coefficients converting "point -> plane distance"
3110   // into view section size between the point and the frustum plane.
3111   //       proj
3112   //       /|\   right half of frame     //
3113   //        |                           //
3114   //  point o<--  distance * coeff  -->//---- (view plane section)
3115   //         \                        //
3116   //      (distance)                 // 
3117   //                ~               //
3118   //                 (distance)    //
3119   //                           \/\//
3120   //                            \//
3121   //                            //
3122   //                      (frustum plane)
3123   aFitDistance.ChangeValue (1) *= Sqrt(1 + Pow (Tan ( aCamSide.Angle (aFrustumPlane (1).Axis().Direction())), 2.0));
3124   aFitDistance.ChangeValue (2) *= Sqrt(1 + Pow (Tan (-aCamSide.Angle (aFrustumPlane (2).Axis().Direction())), 2.0));
3125   aFitDistance.ChangeValue (3) *= Sqrt(1 + Pow (Tan ( aCamUp.Angle   (aFrustumPlane (3).Axis().Direction())), 2.0));
3126   aFitDistance.ChangeValue (4) *= Sqrt(1 + Pow (Tan (-aCamUp.Angle   (aFrustumPlane (4).Axis().Direction())), 2.0));
3127   aFitDistance.ChangeValue (5) *= Sqrt(1 + Pow (Tan ( aCamDir.Angle  (aFrustumPlane (5).Axis().Direction())), 2.0));
3128   aFitDistance.ChangeValue (6) *= Sqrt(1 + Pow (Tan (-aCamDir.Angle  (aFrustumPlane (6).Axis().Direction())), 2.0));
3129
3130   Standard_Real aViewSizeXv = aFitDistance (1) + aFitDistance (2);
3131   Standard_Real aViewSizeYv = aFitDistance (3) + aFitDistance (4);
3132   Standard_Real aViewSizeZv = aFitDistance (5) + aFitDistance (6);
3133
3134   // 3. Place center of camera on the same line with center of bounding
3135   //    box applying corresponding projection asymmetry (if any).
3136   Standard_Real anAssymXv = anAssymX * aViewSizeXv * 0.5;
3137   Standard_Real anAssymYv = anAssymY * aViewSizeYv * 0.5;
3138   Standard_Real anOffsetXv = (aFitDistance (2) - aFitDistance (1)) * 0.5 + anAssymXv;
3139   Standard_Real anOffsetYv = (aFitDistance (4) - aFitDistance (3)) * 0.5 + anAssymYv;
3140   gp_Vec aTranslateSide = gp_Vec (aCamSide) * anOffsetXv;
3141   gp_Vec aTranslateUp   = gp_Vec (aCamUp)   * anOffsetYv;
3142   gp_Pnt aCamNewCenter  = aBndCenter.Translated (aTranslateSide).Translated (aTranslateUp);
3143
3144   gp_Trsf aCenterTrsf;
3145   aCenterTrsf.SetTranslation (theCamera->Center(), aCamNewCenter);
3146   theCamera->Transform (aCenterTrsf);
3147   theCamera->SetDistance (aFitDistance (6) + aFitDistance (5));
3148
3149   // Bounding box collapses to a point or thin line going in depth of the screen
3150   if (aViewSizeXv < theResolution && aViewSizeYv < theResolution)
3151   {
3152     if (aViewSizeXv < theResolution || !theToEnlargeIfLine)
3153     {
3154       return Standard_True; // This is just one point or line and zooming has no effect.
3155     }
3156
3157     // Looking along line and "theToEnlargeIfLine" is requested.
3158     // Fit view to see whole scene on rotation.
3159     aViewSizeXv = aViewSizeZv;
3160     aViewSizeYv = aViewSizeZv;
3161   }
3162
3163   Scale (theCamera, aViewSizeXv * (1.0 + theMargin), aViewSizeYv * (1.0 + theMargin));
3164
3165   return Standard_True;
3166 }
3167
3168 // =======================================================================
3169 // function : Scale
3170 // purpose  : Internal
3171 // =======================================================================
3172 void V3d_View::Scale (const Handle(Graphic3d_Camera)& theCamera,
3173                       const Standard_Real theSizeXv,
3174                       const Standard_Real theSizeYv) const
3175 {
3176   Standard_Real anAspect = theCamera->Aspect();
3177   if (anAspect > 1.0)
3178   {
3179     theCamera->SetScale (Max (theSizeXv / anAspect, theSizeYv));
3180   }
3181   else
3182   {
3183     theCamera->SetScale (Max (theSizeXv, theSizeYv * anAspect));
3184   }
3185 }
3186
3187 // =======================================================================
3188 // function : Translate
3189 // purpose  : Internal
3190 // =======================================================================
3191 void V3d_View::Translate (const Handle(Graphic3d_Camera)& theCamera,
3192                           const Standard_Real theDXv,
3193                           const Standard_Real theDYv) const
3194 {
3195   const gp_Pnt& aCenter = theCamera->Center();
3196   const gp_Dir& aDir = theCamera->Direction();
3197   const gp_Dir& anUp = theCamera->Up();
3198   gp_Ax3 aCameraCS (aCenter, aDir.Reversed(), aDir ^ anUp);
3199
3200   gp_Vec aCameraPanXv = gp_Vec (aCameraCS.XDirection()) * theDXv;
3201   gp_Vec aCameraPanYv = gp_Vec (aCameraCS.YDirection()) * theDYv;
3202   gp_Vec aCameraPan = aCameraPanXv + aCameraPanYv;
3203   gp_Trsf aPanTrsf;
3204   aPanTrsf.SetTranslation (aCameraPan);
3205
3206   theCamera->Transform (aPanTrsf);
3207 }
3208
3209 // =======================================================================
3210 // function : IsCullingEnabled
3211 // purpose  :
3212 // =======================================================================
3213 Standard_Boolean V3d_View::IsCullingEnabled() const
3214 {
3215   Graphic3d_CView* aView = (Graphic3d_CView* )MyView->CView();
3216   return aView->IsCullingEnabled;
3217 }
3218
3219 // =======================================================================
3220 // function : SetFrustumCulling
3221 // purpose  :
3222 // =======================================================================
3223 void V3d_View::SetFrustumCulling (const Standard_Boolean theToClip)
3224 {
3225   Graphic3d_CView* aView = (Graphic3d_CView* )MyView->CView();
3226   aView->IsCullingEnabled = theToClip;
3227 }