1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 // This file is part of Open CASCADE Technology software library.
5 // This library is free software; you can redistribute it and / or modify it
6 // under the terms of the GNU Lesser General Public 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.
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
14 /***********************************************************************
20 HISTORIQUE DES MODIFICATIONS :
21 --------------------------------
22 00-09-92 : GG ; Creation.
23 02-10-96 : FMN ; Suppression appel Redraw sans MustBeResized()
24 05-06-97 : FMN ; Correction FitAll()
25 30-06-97 : GG ; Correction + Optimisation de Panning(...)
26 On fait la translation + le zoom en une seule
27 operation au lieu de 2 precedemment qui etait buggee.
28 09-07-97 : FMN ; Correction FitAll() sur le Ratio
29 16-07-97 : FMN ; Correction FitAll() sur le calcul de la Box
30 22-07-97 : FMN ; Ajout mode RetainMode pour le Transient
31 15-12-97 : FMN ; Ajout texture mapping
32 17-12-97 : FMN ; CTS19129 Correction FitAll() multiple
33 18-12-97 : FMN ; Ajout mode Ajout
34 24-12-97 : FMN ; Remplacement de math par MathGra
35 24-12-97 : CQO ; BUC50037 Xw_Window -> Aspect_Window
36 31-12-97 : CAL ; Remplacement de MathGra par Array2OfReal
37 07-01-98 : CAL ; Ajout de la methode DoMapping.
38 07-01-98 : CAL ; Retrait de tous les "this->" inutiles
39 21-01-98 : CAL ; Remplacement des Window->Position () par Window->Size ()
40 27-01-98 : FMN ; PERF: OPTIMISATION LOADER (LOPTIM)
41 12-02-98 : GG ; Reactivation du Redraw dans MustBeResized()
42 23-02-98 : FMN ; Remplacement PI par Standard_PI
43 25-02-98 : FMN ; PERF.27: Optimisation of view creation from existing view
44 11-03-98 : STT ; S3558
45 19-03-98 : FMN ; Probleme dans FitAll car la methode WNT_Window::Size(Real,Real)
47 08-04-98 : STT ; suppr. S3558
48 10-04-98 : CAL ; Ajout des methodes RefToPix et PixToRef
49 13-06-98 : FMN ; Probleme dans FitAll car la methode WNT_Window::Size(Real,Real)
50 ne marche pas. Contournement en appelant WNT_Window::Size(Int,Int).
51 16-08-98 : CAL ; S3892. Ajout grilles 3d.
52 09-09-98 : CAL ; S3892. Generalisation de TrsPoint.
53 24-09-98 : CAL ; Ajout d'un parametre a V3d_View::SetPlotter.
54 06-10-98 : CAL ; Ajout d'un TIMER si CSF_GraphicTimer est definie.
55 16-10-98 : CAL ; Retrait d'un TIMER si CSF_GraphicTimer est definie.
56 06-11-98 : CAL ; PRO ?????. Probleme dans ZFitAll si un point dans la vue.
57 13-06-98 : FMN ; PRO14896: Correction sur la gestion de la perspective (cf Programming Guinde)
58 29-OCT-98 : DCB : Adding ScreenCopy () method.
59 22-12-98 : FMN ; Rename CSF_WALKTHROW en CSF_WALKTHROUGH
60 10-11-99 : GG ; PRO19603 Add Redraw( area ) method
62 -> Don't increase too much the ZSize.
63 -> Initialize correctly the Z clipping and D cueing
65 IMP100701 : SZV ; Add ToPixMap() method
69 About FitAll() multiple. This probleme is caused by missing
70 precision of transformation matrices. If it is supposed that
71 projection is made in the plane (U,V), there is a difference
72 after several Zoom - compared to the exact value (cf ZoomX).
73 Don't forget that the matrices work in float and not in double.
74 To solve the problem (for lack of a better solution) I make 2 passes.
76 ************************************************************************/
78 //GER61351 //GG_15/12/99 Add SetBackgroundColor() and BackgroundColor() methods
81 #define IMP240100 //GG
82 // -> Remove PixToRef() method ,use
83 // instead the equivalent Convert() method.
84 // -> Rename RefToPix() to Convert() method.
85 // -> Remove the grid computation in Convert()
86 // method. Use instead the NEW ConvertToGrid() methods.
87 // Reason is the Convert() method is call by
88 // StdSelect_ViewSelector3d_Pick() from
89 // AIS_InteractiveContext() and it's not possible
90 // to select an object vertex when the grid is active!
91 // -> Remove grid echo marker definition
92 // (reported in the viewer)
93 // -> Add SetProjModel() methods.
95 #define G004 //VKH 15-11-99
96 // -> Add Dump() methods
97 // -> GG 07/03/00 Use the new MMSize()
98 // method from Aspect_Window class.
100 #define IMP210200 //GG Add Transparency() method
102 #define IMP250200 //GG With SetDepth() method, when the requested
104 // move the view ref point and the eye,instead
107 #define IMP020300 //GG Don't use ZFitAll in during Rotation
108 // for perf improvment
110 #define IMP210600 //GG Avoid to have infinite loop when call Rotation() method
111 // without call before StartRotation().
112 // This problem occurs when CTRL MB3 is maintain press betwwen 2 views.
114 #define IMP250900 //GG Enable rotation around screen Z axis when
115 // rotation begin far the center of the screen.
116 // Thanks to Patrick REGINSTER (SAMTECH)
117 // GG 21/12/00 Due to a regression on the previous specifications
118 // this new functionnality is right now deactivated
119 // by default (see StartRotation(...,zRotationThreshold)
122 #define BUC60952 //GG Enable to rotate around the view axis
123 // and the required view point
125 #define RIC120302 //GG Add a NEW SetWindow method which enable
126 // to connect a graphic widget and context to OGL.
128 #define IMP260302 //GG To avoid conflicting in Window destructor
129 // nullify this handle in Remove method
131 #define OCC280 //SAV fix for FitAll problem in the perspective view.
133 #define OCC1188 //SAV Added methods to set background image
135 /*----------------------------------------------------------------------*/
140 #include <Standard_TypeMismatch.hxx>
141 #include <Visual3d_ViewManager.hxx>
142 #include <Visual3d_Light.hxx>
143 #include <Graphic3d_Structure.hxx>
144 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
145 #include <Graphic3d_MapOfStructure.hxx>
146 #include <Graphic3d_TextureEnv.hxx>
147 #include <Image_AlienPixMap.hxx>
149 #include <V3d_View.ixx>
150 #include <V3d_BadValue.hxx>
151 #include <Standard_ShortReal.hxx>
152 #include <gp_Dir.hxx>
153 #include <TColStd_Array2OfReal.hxx>
154 #include <Visual3d_TransientManager.hxx>
155 #include <Precision.hxx>
158 #include <Graphic3d_AspectMarker3d.hxx>
159 #include <Graphic3d_GraphicDriver.hxx>
162 #include <Aspect_GenericColorMap.hxx>
163 #include <Aspect_TypeMap.hxx>
164 #include <Aspect_WidthMap.hxx>
165 #include <Aspect_MarkMap.hxx>
166 #include <Aspect_FontMap.hxx>
167 #include <TColStd_HSequenceOfInteger.hxx>
169 #define V3d_FLAG_COMPUTATION 0x00000004
172 #include <OSD_Environment.hxx>
174 /*----------------------------------------------------------------------*/
180 #define DEUXPI (2. * M_PI)
182 /*----------------------------------------------------------------------*/
184 * Local data definitions
188 static Standard_Real MyXwindowCenter ;
189 static Standard_Real MyYwindowCenter ;
190 static Standard_Real MyWindowWidth ;
191 static Standard_Real MyWindowHeight ;
195 static Graphic3d_Vector MyXscreenAxis ;
196 static Graphic3d_Vector MyYscreenAxis ;
197 static Graphic3d_Vector MyZscreenAxis ;
198 static Graphic3d_Vector MyViewReferencePlane ;
199 static Graphic3d_Vector MyViewReferenceUp ;
200 static Graphic3d_Vector MyViewAxis ;
201 static Graphic3d_Vertex MyViewReferencePoint ;
202 static Graphic3d_Vertex MyGravityReferencePoint ;
203 static Graphic3d_Vertex MyProjReferencePoint ;
205 static Graphic3d_Vector& _MyXscreenAxis() {
206 static Graphic3d_Vector MyXscreenAxis;
207 return MyXscreenAxis;
209 #define MyXscreenAxis _MyXscreenAxis()
211 static Graphic3d_Vector& _MyYscreenAxis() {
212 static Graphic3d_Vector MyYscreenAxis;
213 return MyYscreenAxis;
215 #define MyYscreenAxis _MyYscreenAxis()
217 static Graphic3d_Vector& _MyZscreenAxis() {
218 static Graphic3d_Vector MyZscreenAxis;
219 return MyZscreenAxis;
221 #define MyZscreenAxis _MyZscreenAxis()
223 static Graphic3d_Vector& _MyViewReferencePlane() {
224 static Graphic3d_Vector MyViewReferencePlane;
225 return MyViewReferencePlane;
227 #define MyViewReferencePlane _MyViewReferencePlane()
229 static Graphic3d_Vector& _MyViewReferenceUp() {
230 static Graphic3d_Vector MyViewReferenceUp;
231 return MyViewReferenceUp;
233 #define MyViewReferenceUp _MyViewReferenceUp()
235 static Graphic3d_Vector& _MyViewAxis() {
236 static Graphic3d_Vector MyViewAxis;
239 #define MyViewAxis _MyViewAxis()
241 static Graphic3d_Vertex& _MyViewReferencePoint() {
242 static Graphic3d_Vertex MyViewReferencePoint;
243 return MyViewReferencePoint;
245 #define MyViewReferencePoint _MyViewReferencePoint()
247 static Graphic3d_Vertex& _MyGravityReferencePoint() {
248 static Graphic3d_Vertex MyGravityReferencePoint;
249 return MyGravityReferencePoint;
251 #define MyGravityReferencePoint _MyGravityReferencePoint()
253 static Graphic3d_Vertex& _MyProjReferencePoint() {
254 static Graphic3d_Vertex MyProjReferencePoint;
255 return MyProjReferencePoint;
257 #define MyProjReferencePoint _MyProjReferencePoint()
260 /*----------------------------------------------------------------------*/
263 V3d_View::V3d_View(const Handle(V3d_Viewer)& VM, const V3d_TypeOfView Type ) :
265 MyProjModel(V3d_TPM_SCREEN),
266 MyViewer(VM.operator->()),
269 myActiveLightsIterator(),
270 SwitchSetFront(Standard_False),
271 MyTrsf (1, 4, 1, 4) // S3892
273 myImmediateUpdate = Standard_False;
274 MyView = new Visual3d_View(MyViewer->Viewer());
276 // { Begin to retrieve the definition from ViewContext.
277 // Step MyViewContext = MyView->Context() ;
278 // to permit MyView->SetContext to compare
279 // the old and the new context.
280 // No problem for MyViewMapping, MyViewOrientation
281 // as MyView->SetViewMapping and MyView->SetViewOrientation
282 // don't try to optimize the modifications introduced to
283 // viewmapping and vieworientation.
286 if ((MyView->Context ()).AliasingIsOn ())
287 MyViewContext.SetAliasingOn ();
289 MyViewContext.SetAliasingOff ();
292 MyViewContext.SetDepthCueingBackPlane
293 ((MyView->Context ()).DepthCueingBackPlane ());
294 MyViewContext.SetDepthCueingFrontPlane
295 ((MyView->Context ()).DepthCueingFrontPlane ());
297 if ((MyView->Context ()).DepthCueingIsOn ())
298 MyViewContext.SetDepthCueingOn ();
300 MyViewContext.SetDepthCueingOff ();
303 MyViewContext.SetZClippingBackPlane
304 ((MyView->Context ()).ZClippingBackPlane ());
305 MyViewContext.SetZClippingFrontPlane
306 ((MyView->Context ()).ZClippingFrontPlane ());
308 if ((MyView->Context ()).FrontZClippingIsOn ())
309 MyViewContext.SetFrontZClippingOn ();
311 MyViewContext.SetFrontZClippingOff ();
313 if ((MyView->Context ()).BackZClippingIsOn ())
314 MyViewContext.SetBackZClippingOn ();
316 MyViewContext.SetBackZClippingOff ();
318 // Visualisation and Shading Model
319 MyViewContext.SetModel ((MyView->Context ()).Model ());
320 MyViewContext.SetVisualization ((MyView->Context ()).Visualization ());
323 MyViewContext.SetSurfaceDetail (MyView->Context ().SurfaceDetail ());
324 MyViewContext.SetTextureEnv (MyView->Context ().TextureEnv ());
325 // } End of retrieval of the definition of ViewContext.
327 MyViewMapping = MyView->ViewMapping() ;
328 MyViewOrientation = MyView->ViewOrientation() ;
329 MyBackground = VM->GetBackgroundColor() ;
330 MyGradientBackground = VM->GetGradientBackground() ;
332 SetAxis(0.,0.,0.,1.,1.,1.) ;
333 SetVisualization(VM->DefaultVisualization()) ;
334 SetShadingModel(VM->DefaultShadingModel()) ;
335 SetSurfaceDetail(VM->DefaultSurfaceDetail()) ;
338 SetProj(VM->DefaultViewProj()) ;
339 SetSize(VM->DefaultViewSize()) ;
340 Standard_Real zsize = VM->DefaultViewSize();
341 SetZSize(2.*zsize+zsize*Zmargin) ;
342 SetZClippingDepth(0.);
343 SetZClippingWidth(zsize);
345 SetZCueingWidth(zsize);
346 SetDepth(VM->DefaultViewSize()/2.) ;
348 SetViewMappingDefault();
351 myImmediateUpdate = Standard_True;
358 MyTransparencyFlag = Standard_False;
362 /*----------------------------------------------------------------------*/
364 V3d_View::V3d_View(const Handle(V3d_Viewer)& VM,const Handle(V3d_View)& V, const V3d_TypeOfView Type ) :
366 MyProjModel(V3d_TPM_SCREEN),
367 MyViewer(VM.operator->()),
370 myActiveLightsIterator(),
371 SwitchSetFront(Standard_False),
372 MyTrsf (1, 4, 1, 4) // S3892
374 Handle(Visual3d_View) FromView = V->View() ;
376 myImmediateUpdate = Standard_False;
377 MyView = new Visual3d_View(MyViewer->Viewer());
379 for (V->InitActiveLights();V->MoreActiveLights();V->NextActiveLights()){
380 MyActiveLights.Append(V->ActiveLight());}
382 MyViewContext = FromView->Context() ;
384 MyViewMapping = FromView->ViewMapping() ;
385 MyViewOrientation = FromView->ViewOrientation() ;
386 MyBackground = FromView->Background() ;
387 MyGradientBackground = FromView->GradientBackground();
389 MyView->SetContext(MyViewContext) ;
391 SetAxis(0.,0.,0.,1.,1.,1.) ;
394 myImmediateUpdate = Standard_True;
397 /*----------------------------------------------------------------------*/
401 void V3d_View::SetMagnify(const Handle(Aspect_Window)& TheWindow,
402 const Handle(V3d_View)& aPreviousView,
403 const Standard_Integer x1,
404 const Standard_Integer y1,
405 const Standard_Integer x2,
406 const Standard_Integer y2)
408 if( !MyView->IsDefined() ) {
409 Standard_Real a,b,c,d;
410 aPreviousView->Convert(x1,y1,a,b);
411 aPreviousView->Convert(x2,y2,c,d);
412 MyView->SetWindow(TheWindow) ;
413 FitAll(TheWindow,a,b,c,d);
414 MyView->SetContext(MyViewContext) ;
415 MyView->SetViewOrientation(MyViewOrientation) ;
416 MyView->SetBackground(MyBackground) ;
417 MyViewer->SetViewOn(this) ;
418 MyWindow = TheWindow;
420 SetViewMappingDefault();
424 /*----------------------------------------------------------------------*/
426 void V3d_View::SetWindow(const Handle(Aspect_Window)& TheWindow)
428 Standard_MultiplyDefined_Raise_if( MyView->IsDefined(),
429 "V3d_View::SetWindow, window of view already defined");
431 MyView->SetWindow(TheWindow) ;
432 // AGV: Method V3d_View::SetWindow() should assign the field MyWindow before
433 // calling Redraw(). Otherwise it is impossible to call certain methods of
434 // V3d_View like Convert() inside the context of Redraw(),
435 // particularly in class NIS_View.
436 MyWindow = TheWindow;
437 // SetWindow carries out SetRatio and modifies
438 // ViewMapping and ViewMappingDefault of MyView.
439 MyViewMapping = MyView->ViewMapping() ;
440 MyView->SetContext(MyViewContext) ;
441 MyView->SetViewMapping(MyViewMapping) ;
442 MyView->SetViewOrientation(MyViewOrientation) ;
443 MyView->SetBackground(MyBackground) ;
444 MyViewer->SetViewOn(this) ;
449 /*----------------------------------------------------------------------*/
451 void V3d_View::SetWindow(const Handle(Aspect_Window)& aWindow,
452 const Aspect_RenderingContext aContext,
453 const Aspect_GraphicCallbackProc& aDisplayCB,
454 const Standard_Address aClientData)
456 Standard_MultiplyDefined_Raise_if( MyView->IsDefined(),
457 "V3d_View::SetWindow, "
458 "window of view already defined");
459 // AGV: Method V3d_View::SetWindow() should assign the field MyWindow before
460 // calling Redraw(). Otherwise it is impossible to call certain methods of
461 // V3d_View like Convert() inside the context of Redraw(),
462 // particularly in class NIS_View.
464 MyView->SetWindow(aWindow, aContext, aDisplayCB, aClientData) ;
465 MyViewMapping = MyView->ViewMapping() ;
466 MyView->SetContext(MyViewContext) ;
467 MyView->SetViewMapping(MyViewMapping) ;
468 MyView->SetViewOrientation(MyViewOrientation) ;
469 MyView->SetBackground(MyBackground) ;
470 MyViewer->SetViewOn(this) ;
475 /*----------------------------------------------------------------------*/
477 void V3d_View::Remove() const
479 MyViewer->DelView (this);
481 Handle(Aspect_Window)& aWin = const_cast<Handle(Aspect_Window)&> (MyWindow);
485 /*----------------------------------------------------------------------*/
487 void V3d_View::Update() const
489 if( MyView->IsDefined() ) MyView->Update() ;
492 /*----------------------------------------------------------------------*/
494 void V3d_View::Redraw() const
496 if( MyView->IsDefined() ) MyView->Redraw() ;
499 /*----------------------------------------------------------------------*/
501 void V3d_View::Redraw(const Standard_Integer xc,const Standard_Integer yc,
502 const Standard_Integer width,const Standard_Integer height) const
504 if( MyView->IsDefined() ) MyView->Redraw(xc,yc,width,height) ;
507 /*----------------------------------------------------------------------*/
509 Standard_Boolean V3d_View::IsEmpty() const
511 Standard_Boolean TheStatus = Standard_True ;
512 if( MyView->IsDefined() ) {
513 Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
514 if( Nstruct > 0 ) TheStatus = Standard_False ;
519 /*----------------------------------------------------------------------*/
521 void V3d_View::UpdateLights() const
523 MyView->SetContext(MyViewContext);
527 /*----------------------------------------------------------------------*/
529 void V3d_View::DoMapping()
531 if( MyView->IsDefined() ) {
532 (MyView->Window())->DoMapping() ;
536 /*----------------------------------------------------------------------*/
538 void V3d_View::MustBeResized()
540 if ( !MyLayerMgr.IsNull() )
541 MyLayerMgr->Resized();
543 if( MyView->IsDefined() ) {
545 MyViewMapping = MyView->ViewMapping();
550 /*----------------------------------------------------------------------*/
552 void V3d_View::SetBackgroundColor(const Quantity_TypeOfColor Type, const Standard_Real v1, const Standard_Real v2, const Standard_Real v3)
554 Standard_Real V1 = Max( Min( v1, 1.0 ), 0.0 );
555 Standard_Real V2 = Max( Min( v2, 1.0 ), 0.0 );
556 Standard_Real V3 = Max( Min( v3, 1.0 ), 0.0 );
558 Quantity_Color C( V1, V2, V3, Type );
559 SetBackgroundColor( C );
562 /*----------------------------------------------------------------------*/
564 void V3d_View::SetBackgroundColor(const Quantity_Color &Color)
566 MyBackground.SetColor( Color );
567 if ( MyView->IsDefined() )
568 MyView->SetBackground( MyBackground );
570 if ( !MyLayerMgr.IsNull() )
571 MyLayerMgr->Resized();
574 /*----------------------------------------------------------------------*/
576 void V3d_View::SetBackgroundColor(const Quantity_NameOfColor Name)
578 Quantity_Color C( Name );
579 SetBackgroundColor( C );
582 /*----------------------------------------------------------------------*/
584 void V3d_View::SetBgGradientColors( const Quantity_Color& Color1,
585 const Quantity_Color& Color2,
586 const Aspect_GradientFillMethod FillStyle,
587 const Standard_Boolean status)
589 MyGradientBackground.SetColors(Color1, Color2, FillStyle);
590 if ( MyView->IsDefined() )
591 MyView->SetGradientBackground( MyGradientBackground, status );
594 /*----------------------------------------------------------------------*/
596 void V3d_View::SetBgGradientColors( const Quantity_NameOfColor Color1,
597 const Quantity_NameOfColor Color2,
598 const Aspect_GradientFillMethod FillStyle,
599 const Standard_Boolean status )
601 Quantity_Color C1( Color1 );
602 Quantity_Color C2( Color2 );
603 MyGradientBackground.SetColors( C1, C2, FillStyle );
604 if ( MyView->IsDefined() )
605 MyView->SetGradientBackground( MyGradientBackground, status );
608 /*----------------------------------------------------------------------*/
610 void V3d_View::SetBgGradientStyle( const Aspect_GradientFillMethod FillStyle,
611 const Standard_Boolean update)
613 Quantity_Color Color1, Color2;
614 MyGradientBackground.Colors( Color1, Color2 );
615 MyGradientBackground.SetColors( Color1, Color2, FillStyle );
616 if( MyView->IsDefined() )
617 MyView->SetBgGradientStyle( FillStyle, update ) ;
620 /*----------------------------------------------------------------------*/
622 void V3d_View::SetBackgroundImage( const Standard_CString FileName,
623 const Aspect_FillMethod FillStyle,
624 const Standard_Boolean update )
627 if( MyView->IsDefined() )
628 MyView->SetBackgroundImage( FileName, FillStyle, update ) ;
632 /*----------------------------------------------------------------------*/
634 void V3d_View::SetBgImageStyle( const Aspect_FillMethod FillStyle,
635 const Standard_Boolean update )
638 if( MyView->IsDefined() )
639 MyView->SetBgImageStyle( FillStyle, update ) ;
643 /*----------------------------------------------------------------------*/
645 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)
647 Standard_Real D,Nx = Vx,Ny = Vy,Nz = Vz ;
649 D = Sqrt( Vx*Vx + Vy*Vy + Vz*Vz ) ;
650 V3d_BadValue_Raise_if ( D <= 0. , "V3d_View::SetAxis, bad axis");
651 Nx /= D ; Ny /= D ; Nz /= D ;
652 MyDefaultViewPoint.SetCoord(X,Y,Z) ;
653 MyDefaultViewAxis.SetCoord(Nx,Ny,Nz) ;
654 MyDefaultViewAxis.Normalize() ;
657 /*----------------------------------------------------------------------*/
659 void V3d_View::SetShadingModel(const V3d_TypeOfShadingModel Model)
661 MyViewContext.SetModel((Visual3d_TypeOfModel) Model) ;
662 MyView->SetContext(MyViewContext) ;
665 /*----------------------------------------------------------------------*/
667 void V3d_View::SetSurfaceDetail(const V3d_TypeOfSurfaceDetail Model)
669 MyViewContext.SetSurfaceDetail((Visual3d_TypeOfSurfaceDetail) Model) ;
670 MyView->SetContext(MyViewContext) ;
673 /*----------------------------------------------------------------------*/
675 void V3d_View::SetTextureEnv(const Handle(Graphic3d_TextureEnv)& ATexture)
677 MyViewContext.SetTextureEnv(ATexture) ;
678 MyView->SetContext(MyViewContext) ;
681 /*----------------------------------------------------------------------*/
683 void V3d_View::SetVisualization(const V3d_TypeOfVisualization Mode)
685 MyViewContext.SetVisualization((Visual3d_TypeOfVisualization) Mode);
686 MyView->SetContext(MyViewContext) ;
689 /*----------------------------------------------------------------------*/
691 void V3d_View::SetFront()
693 gp_Ax3 a = MyViewer->PrivilegedPlane();
694 Standard_Real xo,yo,zo,vx,vy,vz,xu,yu,zu;
696 a.Direction().Coord(vx,vy,vz);
697 a.YDirection().Coord(xu,yu,zu);
698 a.Location().Coord(xo,yo,zo);
701 MyViewOrientation.SetViewReferencePlane(Graphic3d_Vector(-vx,-vy,-vz));
703 MyViewOrientation.SetViewReferencePlane(Graphic3d_Vector(vx,vy,vz));
705 SwitchSetFront = !SwitchSetFront;
707 MyViewOrientation.SetViewReferenceUp(Graphic3d_Vector(xu,yu,zu));
708 MyViewOrientation.SetViewReferencePoint(Graphic3d_Vertex(xo,yo,zo));
710 MyView->SetViewOrientation(MyViewOrientation) ;
715 /*----------------------------------------------------------------------*/
717 void V3d_View::Rotate(const Standard_Real ax, const Standard_Real ay, const Standard_Real az, const Standard_Boolean Start)
719 Standard_Real Ax = ax ;
720 Standard_Real Ay = ay ;
721 Standard_Real Az = az ;
722 Graphic3d_Vector Vpn,Vup ;
723 TColStd_Array2OfReal Matrix(0,3,0,3) ;
724 TColStd_Array2OfReal Rmatrix(0,3,0,3) ;
726 if( Ax > 0. ) while ( Ax > DEUXPI ) Ax -= DEUXPI ;
727 else if( Ax < 0. ) while ( Ax < -DEUXPI ) Ax += DEUXPI ;
728 if( Ay > 0. ) while ( Ay > DEUXPI ) Ay -= DEUXPI ;
729 else if( Ay < 0. ) while ( Ay < -DEUXPI ) Ay += DEUXPI ;
730 if( Az > 0. ) while ( Az > DEUXPI ) Az -= DEUXPI ;
731 else if( Az < 0. ) while ( Az < -DEUXPI ) Az += DEUXPI ;
734 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
735 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
736 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
737 if (!ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
738 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis))
739 V3d_BadValue::Raise ("V3d_View::Rotate, alignment of Eye,At,Up");
744 if( Ax != 0. ) RotAxis(MyViewReferencePoint,MyYscreenAxis,-Ax,Matrix);
746 RotAxis(MyViewReferencePoint,MyXscreenAxis,Ay,Rmatrix) ;
747 Multiply(Matrix, Rmatrix, Matrix);
750 RotAxis(MyViewReferencePoint,MyZscreenAxis,Az,Rmatrix) ;
751 Multiply(Matrix, Rmatrix, Matrix);
753 Vpn = TrsPoint(MyViewReferencePlane,Matrix) ;
754 MyViewOrientation.SetViewReferencePlane(Vpn) ;
755 Vup = TrsPoint(MyViewReferenceUp,Matrix) ;
756 MyViewOrientation.SetViewReferenceUp(Vup) ;
757 MyView->SetViewOrientation(MyViewOrientation) ;
764 /*----------------------------------------------------------------------*/
766 void V3d_View::Rotate(const Standard_Real ax, const Standard_Real ay, const Standard_Real az,
767 const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Boolean Start)
769 Standard_Real Ax = ax ;
770 Standard_Real Ay = ay ;
771 Standard_Real Az = az ;
772 Graphic3d_Vector Vpn,Vup ;
773 Graphic3d_Vertex Vrp ;
774 TColStd_Array2OfReal Matrix(0,3,0,3) ;
775 TColStd_Array2OfReal Rmatrix(0,3,0,3) ;
777 if( Ax > 0. ) while ( Ax > DEUXPI ) Ax -= DEUXPI ;
778 else if( Ax < 0. ) while ( Ax < -DEUXPI ) Ax += DEUXPI ;
779 if( Ay > 0. ) while ( Ay > DEUXPI ) Ay -= DEUXPI ;
780 else if( Ay < 0. ) while ( Ay < -DEUXPI ) Ay += DEUXPI ;
781 if( Az > 0. ) while ( Az > DEUXPI ) Az -= DEUXPI ;
782 else if( Az < 0. ) while ( Az < -DEUXPI ) Az += DEUXPI ;
785 MyGravityReferencePoint.SetCoord(X,Y,Z) ;
786 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
787 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
788 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
789 if (!ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
790 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis))
791 V3d_BadValue::Raise ("V3d_View::Rotate, alignment of Eye,At,Up");
796 if( Ax != 0. ) RotAxis(MyGravityReferencePoint,MyYscreenAxis,-Ax,Matrix);
798 RotAxis(MyGravityReferencePoint,MyXscreenAxis,Ay,Rmatrix) ;
799 Multiply(Matrix, Rmatrix, Matrix);
802 RotAxis(MyGravityReferencePoint,MyZscreenAxis,Az,Rmatrix) ;
803 Multiply(Matrix, Rmatrix, Matrix);
805 Vrp = TrsPoint(MyViewReferencePoint,Matrix) ;
806 MyViewOrientation.SetViewReferencePoint(Vrp) ;
807 Vpn = TrsPoint(MyViewReferencePlane,Matrix) ;
808 MyViewOrientation.SetViewReferencePlane(Vpn) ;
809 Vup = TrsPoint(MyViewReferenceUp,Matrix) ;
810 MyViewOrientation.SetViewReferenceUp(Vup) ;
811 MyView->SetViewOrientation(MyViewOrientation) ;
818 /*----------------------------------------------------------------------*/
820 void V3d_View::Rotate(const V3d_TypeOfAxe Axe, const Standard_Real angle, const Standard_Boolean Start)
824 Rotate(angle,0.,0.,Start);
827 Rotate(0.,angle,0.,Start);
830 Rotate(0.,0.,angle,Start);
835 /*----------------------------------------------------------------------*/
837 void V3d_View::Rotate(const V3d_TypeOfAxe Axe, const Standard_Real angle,
838 const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Boolean Start)
840 Standard_Real Angle = angle ;
841 Graphic3d_Vector Vpn,Vup ;
842 Graphic3d_Vertex Vrp ;
843 TColStd_Array2OfReal Matrix(0,3,0,3) ;
845 if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
846 else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
849 MyGravityReferencePoint.SetCoord(X,Y,Z) ;
850 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
851 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
852 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
855 MyViewAxis.SetCoord(1.,0.,0.) ;
858 MyViewAxis.SetCoord(0.,1.,0.) ;
861 MyViewAxis.SetCoord(0.,0.,1.) ;
866 RotAxis(MyGravityReferencePoint,MyViewAxis,Angle,Matrix) ;
867 Vrp = TrsPoint(MyViewReferencePoint,Matrix) ;
868 MyViewOrientation.SetViewReferencePoint(Vrp) ;
869 Vpn = TrsPoint(MyViewReferencePlane,Matrix) ;
870 MyViewOrientation.SetViewReferencePlane(Vpn) ;
871 Vup = TrsPoint(MyViewReferenceUp,Matrix) ;
872 MyViewOrientation.SetViewReferenceUp(Vup) ;
873 MyView->SetViewOrientation(MyViewOrientation) ;
880 /*----------------------------------------------------------------------*/
882 void V3d_View::Rotate(const Standard_Real angle, const Standard_Boolean Start)
884 Standard_Real Angle = angle ;
885 Graphic3d_Vector Vpn,Vup ;
886 TColStd_Array2OfReal Matrix(0,3,0,3) ;
888 if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
889 else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
892 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
893 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
894 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
897 RotAxis(MyDefaultViewPoint,MyDefaultViewAxis,Angle,Matrix) ;
899 Graphic3d_Vertex Vrp ;
900 Vrp = TrsPoint(MyViewReferencePoint,Matrix) ;
901 MyViewOrientation.SetViewReferencePoint(Vrp) ;
903 Vpn = TrsPoint(MyViewReferencePlane,Matrix) ;
904 MyViewOrientation.SetViewReferencePlane(Vpn) ;
905 Vup = TrsPoint(MyViewReferenceUp,Matrix) ;
906 MyViewOrientation.SetViewReferenceUp(Vup) ;
907 MyView->SetViewOrientation(MyViewOrientation) ;
914 /*----------------------------------------------------------------------*/
916 void V3d_View::Turn(const Standard_Real ax, const Standard_Real ay, const Standard_Real az, const Standard_Boolean Start)
918 Standard_Real Ax = ax ;
919 Standard_Real Ay = ay ;
920 Standard_Real Az = az ;
921 Graphic3d_Vertex Vrp,Eye ;
922 Graphic3d_Vector Vpn,Vup ;
923 Standard_Real Xrp,Yrp,Zrp,Xpn,Ypn,Zpn,Xat,Yat,Zat,Xeye,Yeye,Zeye ;
924 TColStd_Array2OfReal Matrix(0,3,0,3) ;
925 TColStd_Array2OfReal Rmatrix(0,3,0,3) ;
927 if( Ax > 0. ) while ( Ax > DEUXPI ) Ax -= DEUXPI ;
928 else if( Ax < 0. ) while ( Ax < -DEUXPI ) Ax += DEUXPI ;
929 if( Ay > 0. ) while ( Ay > DEUXPI ) Ay -= DEUXPI ;
930 else if( Ay < 0. ) while ( Ay < -DEUXPI ) Ay += DEUXPI ;
931 if( Az > 0. ) while ( Az > DEUXPI ) Az -= DEUXPI ;
932 else if( Az < 0. ) while ( Az < -DEUXPI ) Az += DEUXPI ;
935 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint();
936 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
937 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
938 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
939 if (!ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
940 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis))
941 V3d_BadValue::Raise ("V3d_View::Turn, alignment of Eye,At,Up");
945 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
946 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
947 MyViewReferencePlane.Coord(Xpn,Ypn,Zpn) ;
948 Xeye = Zrp*Xpn + Xat ; Yeye = Zrp*Ypn + Yat ; Zeye = Zrp*Zpn + Zat ;
949 Eye.SetCoord(Xeye,Yeye,Zeye) ;
950 if( Ax != 0. ) RotAxis(Eye,MyYscreenAxis,-Ax,Matrix) ;
952 RotAxis(Eye,MyXscreenAxis,Ay,Rmatrix) ;
953 Multiply(Matrix, Rmatrix, Matrix);
956 RotAxis(Eye,MyZscreenAxis,Az,Rmatrix) ;
957 Multiply(Matrix, Rmatrix, Matrix);
959 Vrp = TrsPoint(MyViewReferencePoint,Matrix) ;
960 MyViewOrientation.SetViewReferencePoint(Vrp) ;
961 Vpn = TrsPoint(MyViewReferencePlane,Matrix) ;
962 MyViewOrientation.SetViewReferenceUp(Vpn) ;
963 Vup = TrsPoint(MyViewReferenceUp,Matrix) ;
964 MyViewOrientation.SetViewReferenceUp(Vup) ;
965 MyView->SetViewOrientation(MyViewOrientation) ;
969 // Check ZClipping planes
971 Vrp.Coord(Xat,Yat,Zat) ;
972 Zmax = Sqrt( Xat*Xat + Yat*Yat + Zat*Zat) ;
973 if( Zmax > MyViewMapping.FrontPlaneDistance() &&
974 MyProjModel == V3d_TPM_SCREEN ) {
975 SetZSize(2.*Zmax+Zmax*Zmargin) ;
981 /*----------------------------------------------------------------------*/
983 void V3d_View::Turn(const V3d_TypeOfAxe Axe, const Standard_Real angle, const Standard_Boolean Start)
987 Turn(angle,0.,0.,Start);
990 Turn(0.,angle,0.,Start);
993 Turn(0.,0.,angle,Start);
998 void V3d_View::Turn(const Standard_Real angle, const Standard_Boolean Start)
1000 Standard_Real Angle = angle ;
1001 Graphic3d_Vertex Vrp,Eye ;
1002 Graphic3d_Vector Vpn,Vup ;
1003 Standard_Real Xrp,Yrp,Zrp,Xpn,Ypn,Zpn,Xat,Yat,Zat,Xeye,Yeye,Zeye ;
1004 TColStd_Array2OfReal Matrix(0,3,0,3) ;
1006 if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
1007 else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
1010 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint();
1011 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
1012 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
1013 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
1015 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1016 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
1017 MyViewReferencePlane.Coord(Xpn,Ypn,Zpn) ;
1018 Xeye = Zrp*Xpn + Xat ; Yeye = Zrp*Ypn + Yat ; Zeye = Zrp*Zpn + Zat ;
1019 Eye.SetCoord(Xeye,Yeye,Zeye) ;
1020 RotAxis(Eye,MyDefaultViewAxis,Angle,Matrix) ;
1021 Vrp = TrsPoint(MyViewReferencePoint,Matrix) ;
1022 MyViewOrientation.SetViewReferencePoint(Vrp) ;
1023 Vpn = TrsPoint(MyViewReferencePlane,Matrix) ;
1024 MyViewOrientation.SetViewReferencePlane(Vpn) ;
1025 Vup = TrsPoint(MyViewReferenceUp,Matrix) ;
1026 MyViewOrientation.SetViewReferenceUp(Vup) ;
1027 MyView->SetViewOrientation(MyViewOrientation) ;
1031 // Check ZClipping planes
1032 Standard_Real Zmax ;
1033 Vrp.Coord(Xat,Yat,Zat) ;
1034 Zmax = Sqrt( Xat*Xat + Yat*Yat + Zat*Zat ) ;
1035 if( Zmax > MyViewMapping.FrontPlaneDistance() &&
1036 MyProjModel == V3d_TPM_SCREEN ) {
1037 SetZSize(2.*Zmax+Zmax*Zmargin) ;
1043 void V3d_View::SetTwist(const Standard_Real angle)
1045 Standard_Real Angle = angle ;
1046 TColStd_Array2OfReal Matrix(0,3,0,3) ;
1047 Standard_Boolean TheStatus ;
1049 if( Angle > 0. ) while ( Angle > DEUXPI ) Angle -= DEUXPI ;
1050 else if( Angle < 0. ) while ( Angle < -DEUXPI ) Angle += DEUXPI ;
1052 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
1053 MyViewReferenceUp.SetCoord(0.,0.,1.) ;
1054 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1055 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1057 MyViewReferenceUp.SetCoord(0.,1.,0.) ;
1058 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1059 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1062 MyViewReferenceUp.SetCoord(1.,0.,0.) ;
1063 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1064 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1067 V3d_BadValue_Raise_if( !TheStatus,"V3d_ViewSetTwist, alignment of Eye,At,Up,");
1069 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
1070 RotAxis(MyViewReferencePoint,MyZscreenAxis,Angle,Matrix) ;
1071 MyViewReferenceUp = TrsPoint(MyYscreenAxis,Matrix) ;
1072 MyViewOrientation.SetViewReferenceUp(MyViewReferenceUp) ;
1073 MyView->SetViewOrientation(MyViewOrientation) ;
1078 void V3d_View::SetProjModel( const V3d_TypeOfProjectionModel aModel )
1080 MyProjModel = aModel;
1083 V3d_TypeOfProjectionModel V3d_View::ProjModel() const
1089 void V3d_View::SetEye(const Standard_Real X,const Standard_Real Y,const Standard_Real Z)
1091 Standard_Real Angle,Xat,Yat,Zat,Xrp,Yrp,Zrp,Xpn,Ypn,Zpn ;
1093 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
1094 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1095 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
1096 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
1097 MyViewReferenceUp = MyViewOrientation.ViewReferenceUp() ;
1098 Xpn = X - Xat ; Ypn = Y - Yat ; Zpn = Z - Zat ;
1099 Zrp = Sqrt(Xpn*Xpn + Ypn*Ypn + Zpn*Zpn) ;
1100 V3d_BadValue_Raise_if( Zrp <= 0. , "V3d_View::SetEye:: Eye,At are Confused");
1102 Xpn /= Zrp ; Ypn /= Zrp ; Zpn /= Zrp ;
1103 MyViewReferencePlane.SetCoord(Xpn,Ypn,Zpn) ;
1104 MyViewOrientation.SetViewReferencePlane(MyViewReferencePlane) ;
1105 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
1106 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint);
1108 Standard_Boolean update = myImmediateUpdate;
1109 myImmediateUpdate = Standard_False;
1110 if( MyProjModel == V3d_TPM_WALKTHROUGH ) {
1111 //FMN desactivation temp SetTwist(Angle) ;
1113 MyView->SetViewOrientation(MyViewOrientation) ;
1114 MyView->SetViewMapping(MyViewMapping) ;
1121 // Check ZClipping planes
1122 Standard_Real Zmax = Sqrt( X*X + Y*Y + Z*Z ) ;
1123 if( Zmax > MyViewMapping.FrontPlaneDistance() &&
1124 MyProjModel == V3d_TPM_SCREEN ) {
1125 SetZSize(2.*Zmax+Zmax*Zmargin) ;
1127 if( MyType == V3d_PERSPECTIVE ) SetFocale(focale) ;
1128 MyView->SetViewMapping(MyViewMapping);
1131 myImmediateUpdate = update;
1135 void V3d_View::SetDepth(const Standard_Real Depth)
1137 Standard_Real Xrp,Yrp,Zrp ;
1139 V3d_BadValue_Raise_if( Depth == 0. ,"V3d_View::SetDepth, bad depth");
1141 V3d_BadValue_Raise_if( Depth <= 0. ,"V3d_View::SetDepth, bad depth");
1144 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
1145 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
1146 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
1147 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1153 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
1154 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint);
1157 // Check ZClipping planes
1158 Standard_Real Xat,Yat,Zat,Xpn,Ypn,Zpn,Xeye,Yeye,Zeye ;
1159 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
1160 MyViewReferencePlane.Coord(Xpn,Ypn,Zpn) ;
1162 if( Depth < 0. ) { // Move the view ref point instead of the eye.
1163 Xeye = Xpn*Zrp + Xat ; Yeye = Ypn*Zrp + Yat ; Zeye = Zpn*Zrp + Zat ;
1165 Xat = Xeye - Xpn*Zrp ; Yat = Yeye - Ypn*Zrp ; Zat = Zeye - Zpn*Zrp;
1166 MyViewReferencePoint.SetCoord(Xat,Yat,Zat) ;
1167 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
1168 MyViewOrientation.SetViewReferencePoint(MyViewReferencePoint) ;
1169 MyView->SetViewOrientation(MyViewOrientation);
1173 MyView->SetViewMapping(MyViewMapping) ;
1176 Xeye = Xpn*Zrp + Xat ; Yeye = Ypn*Zrp + Yat ; Zeye = Zpn*Zrp + Zat ;
1177 Standard_Real Zmax = Sqrt( Xeye*Xeye + Yeye*Yeye + Zeye*Zeye );
1179 if( Zmax > MyViewMapping.FrontPlaneDistance() &&
1180 MyProjModel == V3d_TPM_SCREEN ) {
1181 SetZSize(2.*Zmax+Zmax*Zmargin) ;
1183 if( MyType == V3d_PERSPECTIVE ) SetFocale(focale) ;
1187 MyView->SetViewMapping(MyViewMapping) ;
1195 void V3d_View::SetProj( const Standard_Real Vx,const Standard_Real Vy, const Standard_Real Vz )
1197 Standard_Real Angle ;
1199 V3d_BadValue_Raise_if( Sqrt(Vx*Vx + Vy*Vy + Vz*Vz) <= 0.,
1200 "V3d_View::SetProj, null projection vector");
1203 MyViewReferencePlane.SetCoord(Vx,Vy,Vz) ;
1204 MyViewReferencePlane.Normalize() ;
1205 MyViewOrientation.SetViewReferencePlane(MyViewReferencePlane) ;
1206 Standard_Boolean update = myImmediateUpdate;
1207 myImmediateUpdate = Standard_False;
1208 if( MyProjModel == V3d_TPM_SCREEN ) SetTwist(Angle) ;
1212 myImmediateUpdate = update;
1216 void V3d_View::SetProj( const V3d_TypeOfOrientation Orientation )
1218 MyViewReferencePlane = V3d::GetProjAxis(Orientation) ;
1219 MyViewOrientation.SetViewReferencePlane(MyViewReferencePlane) ;
1220 // MSV 14.03.2007: reset ViewReferencePoint to debug LH3D14955
1221 MyViewOrientation.SetViewReferencePoint(Graphic3d_Vertex (0.0f, 0.0f, 0.0f));
1222 Standard_Real Xpn=0;
1223 Standard_Real Ypn=0;
1224 Standard_Real Zpn=0;
1226 switch (Orientation) {
1243 void V3d_View::SetAt(const Standard_Real X,const Standard_Real Y,const Standard_Real Z)
1245 Standard_Real Angle,Xrp,Yrp,Zrp,Xpn,Ypn,Zpn,Xat,Yat,Zat ;
1246 Standard_Real Xeye,Yeye,Zeye ;
1249 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
1250 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1251 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
1252 MyViewReferencePlane.Coord(Xpn,Ypn,Zpn) ;
1253 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
1254 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
1255 Xeye = Zrp*Xpn + Xat ; Yeye = Zrp*Ypn + Yat ; Zeye = Zrp*Zpn + Zat ;
1256 Xpn = Xeye - X ; Ypn = Yeye - Y ; Zpn = Zeye - Z ;
1257 Zrp = Sqrt(Xpn*Xpn + Ypn*Ypn + Zpn*Zpn) ;
1258 V3d_BadValue_Raise_if( Zrp <= 0.,
1259 "V3d_View::SetAt, Eye,At are Confused");
1261 Xpn /= Zrp ; Ypn /= Zrp ; Zpn /= Zrp ;
1262 MyViewReferencePoint.SetCoord(X,Y,Z) ;
1263 MyViewOrientation.SetViewReferencePoint(MyViewReferencePoint) ;
1264 MyViewReferencePlane.SetCoord(Xpn,Ypn,Zpn) ;
1265 MyViewOrientation.SetViewReferencePlane(MyViewReferencePlane) ;
1266 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
1267 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint);
1268 Standard_Boolean update = myImmediateUpdate;
1269 myImmediateUpdate = Standard_False;
1270 if( MyProjModel == V3d_TPM_WALKTHROUGH ) {
1271 //FMN desactivation temp SetTwist(Angle) ;
1273 MyView->SetViewOrientation(MyViewOrientation) ;
1274 MyView->SetViewMapping(MyViewMapping) ;
1279 MyView->SetViewMapping(MyViewMapping);
1283 // Check ZClipping planes
1284 Standard_Real Zmax = Sqrt( X*X + Y*Y + Z*Z ) ;
1285 if( Zmax > MyViewMapping.FrontPlaneDistance() &&
1286 MyProjModel == V3d_TPM_SCREEN ) {
1287 SetZSize(2.*Zmax+Zmax*Zmargin) ;
1289 if( MyType == V3d_PERSPECTIVE ) SetFocale(focale) ;
1290 MyView->SetViewMapping(MyViewMapping);
1293 myImmediateUpdate = update;
1297 void V3d_View::SetUp(const Standard_Real Vx,const Standard_Real Vy,const Standard_Real Vz)
1299 Standard_Boolean TheStatus ;
1300 V3d_BadValue_Raise_if( Sqrt(Vx*Vx + Vy*Vy + Vz*Vz) <= 0. ,
1301 "V3d_View::SetUp, nullUp vector");
1303 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
1304 MyViewReferenceUp.SetCoord(Vx,Vy,Vz) ;
1305 MyViewReferenceUp.Normalize() ;
1306 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1307 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1309 MyViewReferenceUp.SetCoord(0.,0.,1.) ;
1310 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1311 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1314 MyViewReferenceUp.SetCoord(0.,1.,0.) ;
1315 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1316 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1319 MyViewReferenceUp.SetCoord(1.,0.,0.) ;
1320 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1321 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1323 V3d_BadValue_Raise_if( !TheStatus,"V3d_View::Setup, alignment of Eye,At,Up");
1325 MyViewReferenceUp = MyYscreenAxis ;
1326 MyViewOrientation.SetViewReferenceUp(MyViewReferenceUp) ;
1327 MyView->SetViewOrientation(MyViewOrientation) ;
1331 void V3d_View::SetUp( const V3d_TypeOfOrientation Orientation )
1333 Standard_Boolean TheStatus ;
1335 MyViewReferenceUp = V3d::GetProjAxis(Orientation) ;
1336 MyViewReferencePlane = MyViewOrientation.ViewReferencePlane() ;
1337 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1338 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1340 MyViewReferenceUp.SetCoord(0.,0.,1.) ;
1341 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1342 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1345 MyViewReferenceUp.SetCoord(0.,1.,0.) ;
1346 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1347 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1350 MyViewReferenceUp.SetCoord(1.,0.,0.) ;
1351 TheStatus = ScreenAxis(MyViewReferencePlane,MyViewReferenceUp,
1352 MyXscreenAxis,MyYscreenAxis,MyZscreenAxis) ;
1354 V3d_BadValue_Raise_if( !TheStatus, "V3d_View::SetUp, alignment of Eye,At,Up");
1356 MyViewReferenceUp = MyYscreenAxis ;
1357 MyViewOrientation.SetViewReferenceUp(MyViewReferenceUp) ;
1358 MyView->SetViewOrientation(MyViewOrientation) ;
1362 void V3d_View::SetViewOrientation(const Visual3d_ViewOrientation& VO)
1364 MyViewOrientation = VO;
1365 MyView->SetViewOrientation(MyViewOrientation) ;
1369 void V3d_View::SetViewOrientationDefault()
1371 MyView->SetViewOrientation(MyViewOrientation) ;
1372 MyView->SetViewOrientationDefault() ;
1376 void V3d_View::ResetViewOrientation()
1378 MyView->ViewOrientationReset() ;
1379 MyViewOrientation = MyView->ViewOrientation() ;
1383 void V3d_View::Reset( const Standard_Boolean update )
1385 MyView->ViewOrientationReset() ;
1386 MyViewOrientation = MyView->ViewOrientation() ;
1387 MyView->ViewMappingReset();
1388 MyViewMapping = MyView->ViewMapping() ;
1391 SwitchSetFront = Standard_False;
1393 if( !myImmediateUpdate && update ) Update();
1399 void V3d_View::Panning(const Standard_Real Dx, const Standard_Real Dy, const Quantity_Factor aZoomFactor, const Standard_Boolean Start)
1401 Standard_Real Umin,Vmin,Umax,Vmax,Xrp,Yrp,Zrp,Dxv,Dyv ;
1402 V3d_BadValue_Raise_if( aZoomFactor <= 0.,"V3d_View::Panning, bad zoom factor");
1405 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
1406 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
1407 MyXwindowCenter = (Umin + Umax)/2. ;
1408 MyYwindowCenter = (Vmin + Vmax)/2. ;
1409 MyWindowWidth = Abs(Umax - Umin) ;
1410 MyWindowHeight = Abs(Vmax - Vmin) ;
1411 V3d_BadValue_Raise_if( MyWindowWidth <= 0. || MyWindowHeight <= 0. ,
1412 "V3d_View::Panning, Window Size is NULL");
1414 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1415 Xrp = MyXwindowCenter - Dx ;
1416 Yrp = MyYwindowCenter - Dy ;
1417 Dxv = MyWindowWidth/aZoomFactor ; Dyv = MyWindowHeight/aZoomFactor ;
1418 Umin = Xrp - Dxv/2. ; Umax = Xrp + Dxv/2. ;
1419 Vmin = Yrp - Dyv/2. ; Vmax = Yrp + Dyv/2. ;
1420 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
1421 if( MyType != V3d_PERSPECTIVE ) {
1422 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
1423 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint) ;
1425 MyView->SetViewMapping(MyViewMapping) ;
1429 void V3d_View::SetCenter(const Standard_Integer X, const Standard_Integer Y)
1436 void V3d_View::SetCenter(const Standard_Real Xc, const Standard_Real Yc)
1438 Standard_Real Umin,Vmin,Umax,Vmax,Xrp,Yrp,Zrp ;
1440 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
1441 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1442 MyXwindowCenter = Xrp = Xc ; MyYwindowCenter = Yrp = Yc ;
1443 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
1444 MyWindowWidth = Abs(Umax - Umin) ; MyWindowHeight = Abs(Vmax - Vmin) ;
1445 V3d_BadValue_Raise_if( MyWindowWidth <= 0. || MyWindowHeight <= 0. ,
1446 "V3d_View::SetCenter, Window Size is NULL");
1448 Umin = Xc - MyWindowWidth/2. ; Vmin = Yc - MyWindowHeight/2. ;
1449 Umax = Xc + MyWindowWidth/2. ; Vmax = Yc + MyWindowHeight/2. ;
1450 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
1451 if( MyType != V3d_PERSPECTIVE ) {
1452 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
1453 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint) ;
1455 MyView->SetViewMapping(MyViewMapping) ;
1459 void V3d_View::SetSize(const Standard_Real Size)
1461 Standard_Real Umin,Vmin,Umax,Vmax,Rap ;
1463 V3d_BadValue_Raise_if( Size <= 0.,
1464 "V3d_View::SetSize, Window Size is NULL");
1467 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
1468 MyWindowWidth = Abs(Umax - Umin) ;
1469 MyWindowHeight = Abs(Vmax - Vmin) ;
1470 MyXwindowCenter = (Umin + Umax)/2. ;
1471 MyYwindowCenter = (Vmin + Vmax)/2. ;
1472 Rap = MyWindowWidth/MyWindowHeight ;
1473 if( MyWindowWidth >= MyWindowHeight ) {
1474 MyWindowWidth = Size ; MyWindowHeight = Size/Rap ;
1476 MyWindowHeight = Size ; MyWindowWidth = Size*Rap ;
1478 Umin = MyXwindowCenter - MyWindowWidth/2. ;
1479 Vmin = MyYwindowCenter - MyWindowHeight/2. ;
1480 Umax = MyXwindowCenter + MyWindowWidth/2. ;
1481 Vmax = MyYwindowCenter + MyWindowHeight/2. ;
1482 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
1483 MyView->SetViewMapping(MyViewMapping) ;
1487 void V3d_View::SetZSize(const Standard_Real Size)
1489 Standard_Real Zmax = Size/2.;
1493 Standard_Real Xat,Yat,Zat,Xpn,Ypn,Zpn,Xrp,Yrp,Zrp,Xeye,Yeye,Zeye;
1494 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
1495 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1496 MyViewReferencePlane.Coord(Xpn,Ypn,Zpn) ;
1497 Xeye = Zrp*Xpn + Xat ; Yeye = Zrp*Ypn + Yat ; Zeye = Zrp*Zpn + Zat;
1498 Zmax = Sqrt( Xeye*Xeye + Yeye*Yeye + Zeye*Zeye );
1499 if( Zmax <= MyViewMapping.FrontPlaneDistance() ) return;
1502 V3d_BadValue_Raise_if( Size <= 0.,
1503 "V3d_View::SetZSize, Window ZSize is NULL");
1506 Standard_Real Front = MyViewContext.ZClippingFrontPlane() ;
1507 Standard_Real Back = MyViewContext.ZClippingBackPlane() ;
1509 MyViewMapping.SetFrontPlaneDistance(Zmax) ;
1510 MyViewMapping.SetBackPlaneDistance(-Zmax) ;
1513 if( MyProjModel != V3d_TPM_WALKTHROUGH ) {
1514 MyViewMapping.SetViewPlaneDistance(MyType == V3d_PERSPECTIVE ? 0. : Zmax) ;
1517 MyView->SetViewMapping(MyViewMapping) ;
1518 if( MyViewContext.FrontZClippingIsOn() ||
1519 MyViewContext.BackZClippingIsOn() )
1521 MyViewContext.SetZClippingFrontPlane(Front) ;
1522 MyViewContext.SetZClippingBackPlane(Back) ;
1523 MyView->SetContext(MyViewContext) ;
1527 void V3d_View::SetZoom(const Standard_Real Coef,const Standard_Boolean Start)
1529 Standard_Real Umin,Vmin,Umax,Vmax,Dxv,Dyv ;
1530 V3d_BadValue_Raise_if( Coef <= 0.,"V3d_View::SetZoom, bad coefficient");
1533 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
1534 MyXwindowCenter = (Umin + Umax)/2. ;
1535 MyYwindowCenter = (Vmin + Vmax)/2. ;
1536 MyWindowWidth = Abs(Umax - Umin) ;
1537 MyWindowHeight = Abs(Vmax - Vmin) ;
1540 // ensure that zoom will not be too small or too big
1541 Standard_Real coef = Coef;
1542 if ( MyWindowWidth < coef * Precision::Confusion() )
1543 coef = MyWindowWidth / Precision::Confusion();
1544 else if ( MyWindowWidth > coef * 1e12 )
1545 coef = MyWindowWidth / 1e12;
1546 if ( MyWindowHeight < coef * Precision::Confusion() )
1547 coef = MyWindowHeight / Precision::Confusion();
1548 else if ( MyWindowHeight > coef * 1e12 )
1549 coef = MyWindowHeight / 1e12;
1551 Dxv = MyWindowWidth/coef;
1552 Dyv = MyWindowHeight/coef;
1553 Umin = MyXwindowCenter - Dxv/2. ; Umax = MyXwindowCenter + Dxv/2. ;
1554 Vmin = MyYwindowCenter - Dyv/2. ; Vmax = MyYwindowCenter + Dyv/2. ;
1555 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
1556 MyView->SetViewMapping(MyViewMapping) ;
1560 void V3d_View::SetScale( const Standard_Real Coef )
1562 Standard_Real Umin,Vmin,Umax,Vmax,Xrp,Yrp,Dxv,Dyv ;
1563 Visual3d_ViewMapping VMD = MyView->ViewMappingDefault() ;
1565 V3d_BadValue_Raise_if( Coef <= 0. ,"V3d_View::SetScale, bad coefficient");
1567 VMD.WindowLimit(Umin,Vmin,Umax,Vmax) ;
1568 Dxv = Abs(Umax - Umin) ; Dyv = Abs(Vmax - Vmin) ;
1569 Dxv /= Coef ; Dyv /= Coef ;
1570 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
1571 Xrp = (Umin + Umax)/2. ; Yrp = (Vmin + Vmax)/2. ;
1572 Umin = Xrp - Dxv/2. ; Umax = Xrp + Dxv/2. ;
1573 Vmin = Yrp - Dyv/2. ; Vmax = Yrp + Dyv/2. ;
1574 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
1575 MyView->SetViewMapping(MyViewMapping) ;
1579 void V3d_View::SetAxialScale( const Standard_Real Sx, const Standard_Real Sy, const Standard_Real Sz )
1581 Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax,U,V,W ;
1582 Standard_Real Umin,Vmin,Wmin,Umax,Vmax,Wmax ;
1583 V3d_BadValue_Raise_if( Sx <= 0. || Sy <= 0. || Sz <= 0.,"V3d_View::SetAxialScale, bad coefficient");
1585 MyViewOrientation.SetAxialScale( Sx, Sy, Sz );
1586 Aspect_TypeOfUpdate updateMode = MyView->ViewManager()->UpdateMode();
1587 MyView->ViewManager()->SetUpdateMode(Aspect_TOU_ASAP);
1588 MyView->SetViewOrientation(MyViewOrientation);
1589 MyView->ViewManager()->SetUpdateMode(updateMode);
1591 MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
1593 Standard_Real LIM = ShortRealLast() -1.;
1594 if (Abs(Xmin) > LIM || Abs(Ymin) > LIM || Abs(Zmin) > LIM
1595 || Abs(Xmax) > LIM || Abs(Ymax) > LIM || Abs(Zmax) > LIM ) {
1599 MyView->Projects(Xmin,Ymin,Zmin,Umin,Vmin,Wmin) ;
1600 MyView->Projects(Xmax,Ymax,Zmax,Umax,Vmax,Wmax) ;
1601 Umax = Max(Umin,Umax) ; Vmax = Max(Vmin,Vmax) ;
1602 MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
1603 Umax = Max(Umax,U) ; Vmax = Max(Vmax,V) ;
1604 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1605 MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
1606 Umax = Max(Umax,U) ; Vmax = Max(Vmax,V) ;
1607 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1608 MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
1609 Umax = Max(Umax,U) ; Vmax = Max(Vmax,V) ;
1610 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1611 MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
1612 Umax = Max(Umax,U) ; Vmax = Max(Vmax,V) ;
1613 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1614 MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
1615 Umax = Max(Umax,U) ; Vmax = Max(Vmax,V) ;
1616 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1617 MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
1618 Umax = Max(Umax,U) ; Vmax = Max(Vmax,V) ;
1619 Umax = Max(Umax,Vmax) ;
1620 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1621 Wmax = Max(Abs(Wmin),Abs(Wmax)) ;
1622 Wmax = Max(Abs(Umax),Abs(Wmax)) ;
1625 SetZSize(2.*Wmax + Wmax) ;
1629 void V3d_View::FitAll(const Standard_Real Coef, const Standard_Boolean FitZ,
1630 const Standard_Boolean update)
1632 Standard_Real Umin, Umax, Vmin, Vmax, Xrp, Yrp, Zrp, U, V, W, U1, V1, W1;
1633 Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
1634 Standard_Real DxvOld, DyvOld, DxvNew, DyvNew;
1635 Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures();
1637 if ((Nstruct <= 0) || (Coef < 0.0) || (Coef > 1.0))
1645 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint();
1646 MyProjReferencePoint.Coord (Xrp, Yrp, Zrp);
1647 if (MyView->IsDefined())
1649 Standard_Integer Xpixel, Ypixel;
1650 MyWindow->Size (Xpixel, Ypixel);
1656 MyViewMapping.WindowLimit (Umin, Vmin, Umax, Vmax);
1657 DxvOld = Abs (Umax - Umin);
1658 DyvOld = Abs (Vmax - Vmin);
1660 if ((DxvOld == 0.0) || (DyvOld == 0.0))
1665 Standard_Real aWinRatio = DxvOld / DyvOld;
1667 // retrieve min / max values for current displayed objects
1668 MyView->MinMaxValues (Xmin, Ymin, Zmin,
1671 Standard_Real LIM = ShortRealLast() - 1.0;
1672 if (Abs(Xmin) > LIM || Abs(Ymin) > LIM || Abs(Zmin) > LIM
1673 || Abs(Xmax) > LIM || Abs(Ymax) > LIM || Abs(Zmax) > LIM)
1681 // eliminate fluctuations between sequential FitAll() calls
1682 MyViewMapping.SetWindowLimit (-1.0 * aWinRatio, -1.0, 1.0 * aWinRatio, 1.0);
1683 if (MyType != V3d_PERSPECTIVE)
1685 MyProjReferencePoint.SetCoord (0.0, 0.0, Zrp);
1686 MyViewMapping.SetProjectionReferencePoint (MyProjReferencePoint);
1688 MyView->SetViewMapping (MyViewMapping);
1690 // iterate 2 times to find optimal view plane size
1691 // (use view plane values computed on previous iteration)
1692 for (Standard_Integer aIteration = 2; aIteration > 0; --aIteration)
1694 MyView->Projects (Xmin, Ymin, Zmin, U, V, W);
1695 MyView->Projects (Xmax, Ymax, Zmax, U1, V1, W1);
1696 Umin = Min (U, U1); Umax = Max (U, U1);
1697 Vmin = Min (V, V1); Vmax = Max (V, V1);
1699 MyView->Projects (Xmin, Ymin, Zmax, U, V, W);
1700 Umin = Min (U, Umin); Umax = Max (U, Umax);
1701 Vmin = Min (V, Vmin); Vmax = Max (V, Vmax);
1703 MyView->Projects (Xmax, Ymin, Zmax, U, V, W);
1704 Umin = Min (U, Umin); Umax = Max (U, Umax);
1705 Vmin = Min (V, Vmin); Vmax = Max (V, Vmax);
1707 MyView->Projects (Xmax, Ymin, Zmin, U, V, W);
1708 Umin = Min (U, Umin); Umax = Max (U, Umax);
1709 Vmin = Min (V, Vmin); Vmax = Max (V, Vmax);
1711 MyView->Projects (Xmax, Ymax, Zmin, U, V, W);
1712 Umin = Min (U, Umin); Umax = Max (U, Umax);
1713 Vmin = Min (V, Vmin); Vmax = Max (V, Vmax);
1715 MyView->Projects (Xmin, Ymax, Zmax, U, V, W);
1716 Umin = Min (U, Umin); Umax = Max (U, Umax);
1717 Vmin = Min (V, Vmin); Vmax = Max (V, Vmax);
1719 MyView->Projects (Xmin, Ymax, Zmin, U, V, W);
1720 Umin = Min (U, Umin); Umax = Max (U, Umax);
1721 Vmin = Min (V, Vmin); Vmax = Max (V, Vmax);
1723 DxvNew = Abs (Umax - Umin);
1724 DyvNew = Abs (Vmax - Vmin);
1726 if (DyvNew < 10.0 * Precision::Confusion())
1728 if (DxvNew < 10.0 * Precision::Confusion())
1730 // whole scene projected to point
1731 DxvNew = Max (Abs (Zmax - Zmin), (Max (Abs (Xmax - Xmin), Abs (Ymax - Ymin))));
1732 if (DxvNew < 10.0 * Precision::Confusion())
1734 // this is really just one (!) point and zooming has no any effect
1735 // just center the view
1741 // we look along some line
1742 // fit view like that to see whole scene on rotation
1743 DxvNew += Coef * DxvNew;
1744 DyvNew = DxvNew / aWinRatio;
1749 // whole scene projected to horizontal line
1750 DxvNew += Coef * DxvNew;
1751 DyvNew = DxvNew / aWinRatio;
1756 // general case (or DxvNew == 0.0 - vertical line)
1757 // safe original ratio
1758 Standard_Real aFitRatio = DxvNew / DyvNew;
1759 if (aFitRatio >= aWinRatio)
1761 DxvNew += Coef * DxvNew;
1762 DyvNew = DxvNew / aWinRatio;
1766 DyvNew += Coef * DyvNew;
1767 DxvNew = DyvNew * aWinRatio;
1772 Xrp = 0.5 * (Umin + Umax);
1773 Yrp = 0.5 * (Vmin + Vmax);
1775 // new window limits
1776 Umin = Xrp - 0.5 * DxvNew;
1777 Umax = Xrp + 0.5 * DxvNew;
1778 Vmin = Yrp - 0.5 * DyvNew;
1779 Vmax = Yrp + 0.5 * DyvNew;
1780 MyViewMapping.SetWindowLimit (Umin, Vmin, Umax, Vmax);
1782 if (MyType != V3d_PERSPECTIVE)
1785 MyProjReferencePoint.SetCoord (Xrp, Yrp, Zrp);
1786 MyViewMapping.SetProjectionReferencePoint (MyProjReferencePoint);
1788 MyView->SetViewMapping (MyViewMapping);
1802 if (!myImmediateUpdate && update)
1809 void V3d_View::ZFitAll(const Standard_Real Coef)
1811 Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax,U,V,W ;
1812 Standard_Real Umin,Vmin,Wmin,Umax,Vmax,Wmax ;
1814 Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
1816 if( MyType == V3d_PERSPECTIVE ) {
1821 if( (Nstruct <= 0) || (Coef < 0.) ) {
1826 MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
1828 Standard_Real LIM = ShortRealLast() -1.;
1829 if (Abs(Xmin) > LIM || Abs(Ymin) > LIM || Abs(Zmin) > LIM
1830 || Abs(Xmax) > LIM || Abs(Ymax) > LIM || Abs(Zmax) > LIM ) {
1836 // Case when view contains only a point
1837 if (Xmin == Xmax && Ymin == Ymax && Zmin == Zmax) {
1841 MyView->Projects(Xmin,Ymin,Zmin,Umin,Vmin,Wmin) ;
1842 MyView->Projects(Xmax,Ymax,Zmax,Umax,Vmax,Wmax) ;
1843 MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
1844 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1845 MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
1846 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1847 MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
1848 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1849 MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
1850 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1851 MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
1852 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1853 MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
1854 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1855 Wmax = Max(Abs(Wmin),Abs(Wmax)) ;
1857 SetZSize(2.*Wmax + Coef * Wmax) ;
1862 void V3d_View::DepthFitAll(const Quantity_Coefficient Aspect,
1863 const Quantity_Coefficient Margin)
1865 Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax,U,V,W,U1,V1,W1 ;
1866 Standard_Real Umin,Vmin,Wmin,Umax,Vmax,Wmax ;
1867 Standard_Real Xrp,Yrp,Zrp,Dx,Dy,Dz,Size;
1869 Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
1871 if( (Nstruct <= 0) || (Aspect < 0.) || (Margin < 0.) || (Margin > 1.)) {
1876 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
1877 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
1879 MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
1881 Standard_Real LIM = ShortRealLast() -1.;
1882 if (Abs(Xmin) > LIM || Abs(Ymin) > LIM || Abs(Zmin) > LIM
1883 || Abs(Xmax) > LIM || Abs(Ymax) > LIM || Abs(Zmax) > LIM ) {
1888 if (Xmin == Xmax && Ymin == Ymax && Zmin == Zmax) {
1892 MyView->Projects(Xmin,Ymin,Zmin,U,V,W) ;
1893 MyView->Projects(Xmax,Ymax,Zmax,U1,V1,W1) ;
1894 Umin = Min(U,U1) ; Umax = Max(U,U1) ;
1895 Vmin = Min(V,V1) ; Vmax = Max(V,V1) ;
1896 Wmin = Min(W,W1) ; Wmax = Max(W,W1) ;
1897 MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
1898 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1899 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1900 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1901 MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
1902 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1903 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1904 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1905 MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
1906 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1907 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1908 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1909 MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
1910 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1911 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1912 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1913 MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
1914 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1915 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1916 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1917 MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
1918 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
1919 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
1920 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
1923 Wmax = Max(Abs(Wmin),Abs(Wmax)) ;
1924 Dz = 2.*Wmax + Margin * Wmax;
1926 // Compute depth value
1927 Dx = Abs(Umax - Umin) ; Dy = Abs(Vmax - Vmin) ; // Dz = Abs(Wmax - Wmin);
1928 Dx += Margin * Dx; Dy += Margin * Dy;
1929 Size = Sqrt(Dx*Dx + Dy*Dy + Dz*Dz);
1932 SetDepth( Aspect * Size / 2.);
1938 void V3d_View::FitAll(const Standard_Real Xmin, const Standard_Real Ymin, const Standard_Real Xmax, const Standard_Real Ymax)
1940 FitAll(MyWindow,Xmin,Ymin,Xmax,Ymax);
1946 void V3d_View::WindowFitAll(const Standard_Integer Xmin, const Standard_Integer Ymin, const Standard_Integer Xmax, const Standard_Integer Ymax)
1948 WindowFit(Xmin,Ymin,Xmax,Ymax);
1951 void V3d_View::WindowFit(const Standard_Integer Xmin, const Standard_Integer Ymin, const Standard_Integer Xmax, const Standard_Integer Ymax)
1953 Standard_Real x1,y1,x2,y2;
1954 Convert(Xmin,Ymin,x1,y1);
1955 Convert(Xmax,Ymax,x2,y2);
1956 FitAll(x1,y1,x2,y2);
1959 void V3d_View::SetViewMapping(const Visual3d_ViewMapping& VM)
1962 // ajust view type according to mapping projection
1963 // NOTE: Might be dangerous, potentially conflicts with the C++ view class
1964 // (orthographic or perspective)! Use with care!
1965 if ( VM.Projection() == Visual3d_TOP_PERSPECTIVE )
1966 MyType = V3d_PERSPECTIVE;
1967 else MyType = V3d_ORTHOGRAPHIC;
1969 MyView->SetViewMapping(MyViewMapping) ;
1973 void V3d_View::SetViewMappingDefault()
1975 MyView->SetViewMapping(MyViewMapping) ;
1976 MyView->SetViewMappingDefault();
1980 void V3d_View::ResetViewMapping()
1982 MyView->ViewMappingReset();
1983 MyViewMapping = MyView->ViewMapping() ;
1992 Standard_Real V3d_View::Convert(const Standard_Integer Vp) const
1994 Standard_Real Umin,Umax,Vmin,Vmax,Dxv,Vv ;
1995 Standard_Integer Dxw,Dyw ;
1997 V3d_UnMapped_Raise_if( !MyView->IsDefined(), "view has no window");
1999 MyWindow->Size(Dxw,Dyw);
2000 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2002 Vv = Dxv*(Standard_Real)Vp/(Standard_Real)Dxw ;
2007 void V3d_View::Convert(const Standard_Integer Xp, const Standard_Integer Yp, Standard_Real& Xv, Standard_Real& Yv) const
2009 Standard_Real Umin,Umax,Vmin,Vmax,Dxv,Dyv ;
2010 Standard_Integer Dxw,Dyw ;
2012 V3d_UnMapped_Raise_if( !MyView->IsDefined(), "view has no window");
2014 MyWindow->Size(Dxw,Dyw);
2015 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2016 Dxv = Umax - Umin ; Dyv = Vmax - Vmin ;
2017 Xv = Umin + Dxv*(Standard_Real)Xp/(Standard_Real)Dxw ;
2018 Yv = Vmin + Dyv*(Standard_Real)(Dyw-Yp)/(Standard_Real)Dyw ;
2021 Standard_Integer V3d_View::Convert(const Standard_Real Vv) const
2023 V3d_UnMapped_Raise_if( !MyView->IsDefined(), "view has no window");
2025 Standard_Integer Dxw, Dyw;
2026 MyWindow->Size(Dxw,Dyw);
2028 Standard_Real Umin,Umax,Vmin,Vmax;
2029 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2030 Standard_Real Dxv = Umax - Umin;
2031 return RealToInt ( Dxw * Vv / Dxv );
2034 void V3d_View::Convert(const Standard_Real Xv, const Standard_Real Yv, Standard_Integer& Xp, Standard_Integer& Yp) const
2036 V3d_UnMapped_Raise_if( !MyView->IsDefined(), "view has no window");
2038 Standard_Integer Dxw, Dyw;
2039 MyWindow->Size(Dxw,Dyw);
2041 Standard_Real Umin,Umax,Vmin,Vmax;
2042 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2043 Standard_Real Dxv = Umax - Umin;
2044 Standard_Real Dyv = Vmax - Vmin;
2046 // CAL 15/12/93 warning: double assigned to int
2047 Xp = RealToInt (Dxw*(Xv - Umin)/Dxv);
2048 // CAL 15/12/93 warning: double assigned to int
2049 Yp = Dyw - RealToInt (Dyw*(Yv - Vmin)/Dyv);
2052 void V3d_View::Convert(const Standard_Integer Xp, const Standard_Integer Yp, Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2054 Graphic3d_Vertex Vrp ;
2055 Vrp = (MyViewer->Viewer())->ConvertCoord(MyWindow,Xp,Yp) ;
2058 if( MyViewer->Grid()->IsActive() ) {
2059 Graphic3d_Vertex NewVrp = Compute(Vrp) ;
2060 NewVrp.Coord(X,Y,Z) ;
2065 void V3d_View::ConvertWithProj(const Standard_Integer Xp, const Standard_Integer Yp, Standard_Real& X, Standard_Real& Y, Standard_Real& Z, Standard_Real& Dx, Standard_Real& Dy, Standard_Real& Dz) const
2067 Graphic3d_Vertex Vrp ;
2068 Graphic3d_Vector Proj ;
2069 (MyViewer->Viewer())->ConvertCoordWithProj(MyWindow,Xp,Yp, Vrp, Proj) ;
2071 Proj.Coord(Dx,Dy,Dz) ;
2073 if( MyViewer->Grid()->IsActive() ) {
2074 Graphic3d_Vertex NewVrp = Compute(Vrp) ;
2075 NewVrp.Coord(X,Y,Z) ;
2081 void V3d_View::ConvertToGrid(const Standard_Integer Xp, const Standard_Integer Yp, Standard_Real& Xg, Standard_Real& Yg, Standard_Real& Zg) const
2083 Graphic3d_Vertex Vrp ;
2084 Vrp = (MyViewer->Viewer())->ConvertCoord(MyWindow,Xp,Yp) ;
2085 if( MyViewer->Grid()->IsActive() ) {
2086 Graphic3d_Vertex NewVrp = Compute(Vrp) ;
2087 NewVrp.Coord(Xg,Yg,Zg) ;
2089 Vrp.Coord(Xg,Yg,Zg) ;
2092 void V3d_View::ConvertToGrid(const Standard_Real X, const Standard_Real Y, const Standard_Real Z, Standard_Real& Xg, Standard_Real& Yg, Standard_Real& Zg) const
2094 if( MyViewer->Grid()->IsActive() ) {
2095 Graphic3d_Vertex Vrp(X,Y,Z) ;
2096 Graphic3d_Vertex NewVrp = Compute(Vrp) ;
2097 NewVrp.Coord(Xg,Yg,Zg) ;
2099 Xg = X; Yg = Y; Zg = Z;
2105 void V3d_View::PixToRef(const Standard_Integer Xp, const Standard_Integer Yp, Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2107 Graphic3d_Vertex Vrp ;
2108 Vrp = (MyViewer->Viewer())->ConvertCoord(MyWindow,Xp,Yp) ;
2110 if( MyViewer->Grid()->IsActive() ) {
2111 Graphic3d_Vertex NewVrp = Compute(Vrp) ;
2112 NewVrp.Coord(X,Y,Z) ;
2118 void V3d_View::Convert(const Standard_Real X, const Standard_Real Y, const Standard_Real Z, Standard_Integer& Xp, Standard_Integer& Yp) const
2120 void V3d_View::RefToPix(const Standard_Real X, const Standard_Real Y, const Standard_Real Z, Standard_Integer& Xp, Standard_Integer& Yp) const
2123 Graphic3d_Vertex Vrp(X,Y,Z) ;
2124 (MyViewer->Viewer())->ConvertCoord(MyWindow,Vrp,Xp,Yp) ;
2127 void V3d_View::Project(const Standard_Real X, const Standard_Real Y, const Standard_Real Z, Standard_Real &Xp, Standard_Real &Yp) const
2129 if ( MyType != V3d_PERSPECTIVE )
2131 // use old implementation
2133 MyView->Projects( X, Y, Z, Xp, Yp, Zp );
2137 // NKV - Using raster projection
2138 Standard_Integer Xpx, Ypx;
2139 Convert(X, Y, Z, Xpx, Ypx);
2140 Convert(Xpx, Ypx, Xp, Yp);
2144 void V3d_View::BackgroundColor(const Quantity_TypeOfColor Type,Standard_Real& V1, Standard_Real& V2, Standard_Real& V3) const
2146 Quantity_Color C = BackgroundColor() ;
2147 C.Values(V1,V2,V3,Type) ;
2150 Quantity_Color V3d_View::BackgroundColor() const
2152 return MyBackground.Color() ;
2155 void V3d_View::GradientBackgroundColors(Quantity_Color& Color1,Quantity_Color& Color2) const
2157 MyGradientBackground.Colors(Color1, Color2);
2160 Aspect_GradientBackground V3d_View::GradientBackground() const
2162 return MyGradientBackground;
2165 Standard_Real V3d_View::Scale() const
2167 Standard_Real Umin,Vmin,Umax,Vmax,Dxv ;
2168 Visual3d_ViewMapping VMD = MyView->ViewMappingDefault() ;
2169 Standard_Real S = 0. ;
2171 VMD.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2173 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2174 if( Umax > Umin && Vmax > Vmin ) S = Dxv/(Umax - Umin) ;
2178 void V3d_View::AxialScale(Standard_Real& Sx, Standard_Real& Sy, Standard_Real& Sz) const
2180 MyViewOrientation.AxialScale( Sx, Sy, Sz );
2183 void V3d_View::Center(Standard_Real& Xc, Standard_Real& Yc) const
2185 Standard_Real Umin,Vmin,Umax,Vmax ;
2187 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2188 Xc = (Umin + Umax)/2. ;
2189 Yc = (Vmin + Vmax)/2. ;
2192 void V3d_View::Size(Standard_Real& Width, Standard_Real& Height) const
2194 Standard_Real Umin,Vmin,Umax,Vmax ;
2196 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2197 Width = Umax - Umin ;
2198 Height = Vmax - Vmin ;
2201 Standard_Real V3d_View::ZSize() const
2203 Standard_Real Wmin,Wmax,Depth ;
2205 Wmax = MyViewMapping.FrontPlaneDistance() ;
2206 Wmin = MyViewMapping.BackPlaneDistance() ;
2207 Depth = 2. * Max(Wmin,Wmax) ;
2211 Standard_Integer V3d_View::MinMax(Standard_Real& Umin, Standard_Real& Vmin, Standard_Real& Umax, Standard_Real& Vmax) const
2213 Standard_Real Wmin,Wmax,U,V,W ;
2214 Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax ;
2216 Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
2219 MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
2220 MyView->Projects(Xmin,Ymin,Zmin,Umin,Vmin,Wmin) ;
2221 MyView->Projects(Xmax,Ymax,Zmax,Umax,Vmax,Wmax) ;
2222 MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
2223 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2224 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2225 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2226 MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
2227 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2228 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2229 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2230 MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
2231 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2232 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2233 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2234 MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
2235 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2236 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2237 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2238 MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
2239 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2240 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2241 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2242 MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
2243 Umin = Min(U,Umin) ; Umax = Max(U,Umax) ;
2244 Vmin = Min(V,Vmin) ; Vmax = Max(V,Vmax) ;
2245 Wmin = Min(W,Wmin) ; Wmax = Max(W,Wmax) ;
2250 Standard_Integer V3d_View::MinMax(Standard_Real& Xmin, Standard_Real& Ymin, Standard_Real& Zmin, Standard_Real& Xmax, Standard_Real& Ymax, Standard_Real& Zmax) const
2253 // Standard_Integer Nstruct = (MyView->DisplayedStructures())->Extent() ;
2254 Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
2257 MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
2262 Standard_Integer V3d_View::Gravity(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2264 Standard_Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax,U,V,W ;
2265 Standard_Real Umin,Vmin,Umax,Vmax ;
2266 Standard_Integer Nstruct,Npoint ;
2267 Graphic3d_MapOfStructure MySetOfStructures;
2269 MyView->DisplayedStructures (MySetOfStructures);
2270 Nstruct = MySetOfStructures.Extent() ;
2272 Graphic3d_MapIteratorOfMapOfStructure MyIterator(MySetOfStructures) ;
2274 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
2275 Npoint = 0 ; X = Y = Z = 0. ;
2276 for( ; MyIterator.More(); MyIterator.Next()) {
2277 if (!(MyIterator.Key())->IsEmpty()) {
2278 (MyIterator.Key())->MinMaxValues(Xmin,Ymin,Zmin,
2281 Standard_Real LIM = ShortRealLast() -1.;
2282 if (! (Abs(Xmin) > LIM || Abs(Ymin) > LIM || Abs(Zmin) > LIM
2283 || Abs(Xmax) > LIM || Abs(Ymax) > LIM || Abs(Zmax) > LIM )) {
2285 MyView->Projects(Xmin,Ymin,Zmin,U,V,W) ;
2286 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2287 Npoint++ ; X += Xmin ; Y += Ymin ; Z += Zmin ;
2289 MyView->Projects(Xmax,Ymin,Zmin,U,V,W) ;
2290 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2291 Npoint++ ; X += Xmax ; Y += Ymin ; Z += Zmin ;
2293 MyView->Projects(Xmin,Ymax,Zmin,U,V,W) ;
2294 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2295 Npoint++ ; X += Xmin ; Y += Ymax ; Z += Zmin ;
2297 MyView->Projects(Xmax,Ymax,Zmin,U,V,W) ;
2298 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2299 Npoint++ ; X += Xmax ; Y += Ymax ; Z += Zmin ;
2301 MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
2302 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2303 Npoint++ ; X += Xmin ; Y += Ymin ; Z += Zmax ;
2305 MyView->Projects(Xmax,Ymin,Zmax,U,V,W) ;
2306 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2307 Npoint++ ; X += Xmax ; Y += Ymin ; Z += Zmax ;
2309 MyView->Projects(Xmin,Ymax,Zmax,U,V,W) ;
2310 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2311 Npoint++ ; X += Xmin ; Y += Ymax ; Z += Zmax ;
2313 MyView->Projects(Xmax,Ymax,Zmax,U,V,W) ;
2314 if( U >= Umin && U <= Umax && V >= Vmin && V <= Vmax ) {
2315 Npoint++ ; X += Xmax ; Y += Ymax ; Z += Zmax ;
2321 X /= Npoint ; Y /= Npoint ; Z /= Npoint ;
2327 void V3d_View::Eye(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2329 Graphic3d_Vertex Prp ;
2330 Graphic3d_Vector Vpn ;
2331 Standard_Real Xrp,Yrp,Zrp,Xpn,Ypn,Zpn,Xat,Yat,Zat ;
2333 MyViewReferencePoint = MyViewOrientation.ViewReferencePoint() ;
2334 MyViewReferencePoint.Coord(Xat,Yat,Zat) ;
2335 Prp = MyViewMapping.ProjectionReferencePoint() ;
2336 Prp.Coord(Xrp,Yrp,Zrp) ;
2337 Vpn = MyViewOrientation.ViewReferencePlane() ;
2338 Vpn.Coord(Xpn,Ypn,Zpn) ;
2339 X = Zrp*Xpn + Xat; Y = Zrp*Ypn + Yat; Z = Zrp*Zpn + Zat;
2342 void V3d_View::FocalReferencePoint(Standard_Real& X, Standard_Real& Y,Standard_Real& Z) const
2344 Graphic3d_Vertex PRP,VRPoint;
2345 Graphic3d_Vector VRPlane;
2346 Standard_Real FPD,Xprp,Yprp,Zprp;
2347 Standard_Real Xvrp,Yvrp,Zvrp,DXvrp,DYvrp,DZvrp;
2349 if ( MyType == V3d_PERSPECTIVE ) {
2350 PRP = MyViewMapping.ProjectionReferencePoint() ;
2351 FPD = MyViewMapping.FrontPlaneDistance();
2352 PRP.Coord(Xprp,Yprp,Zprp);
2353 VRPoint = MyViewOrientation.ViewReferencePoint();
2354 VRPoint.Coord(Xvrp,Yvrp,Zvrp);
2355 VRPlane = MyViewOrientation.ViewReferencePlane();
2356 VRPlane.Coord(DXvrp,DYvrp,DZvrp);
2357 X = (FPD + Zprp) * DXvrp + Xvrp;
2358 Y = (FPD + Zprp) * DYvrp + Yvrp;
2359 Z = (FPD + Zprp) * DZvrp + Zvrp;
2364 void V3d_View::ProjReferenceAxe(const Standard_Integer Xpix, const Standard_Integer Ypix, Standard_Real& XP, Standard_Real& YP, Standard_Real& ZP, Standard_Real& VX, Standard_Real& VY, Standard_Real& VZ) const
2366 Standard_Real Xo,Yo,Zo;
2368 Convert(Xpix,Ypix,XP,YP,ZP);
2369 if ( MyType == V3d_PERSPECTIVE ) {
2370 FocalReferencePoint(Xo,Yo,Zo);
2380 Standard_Real V3d_View::Depth() const
2382 Graphic3d_Vertex Prp ;
2383 Standard_Real Xrp,Yrp,Zrp ;
2385 Prp = MyViewMapping.ProjectionReferencePoint() ;
2386 Prp.Coord(Xrp,Yrp,Zrp) ;
2390 void V3d_View::Proj(Standard_Real& Dx, Standard_Real& Dy, Standard_Real& Dz) const
2392 Graphic3d_Vector Vpn ;
2394 Vpn = MyViewOrientation.ViewReferencePlane() ;
2395 Vpn.Coord(Dx,Dy,Dz) ;
2398 void V3d_View::At(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const
2400 Graphic3d_Vertex Vrp ;
2402 Vrp = MyViewOrientation.ViewReferencePoint() ;
2406 void V3d_View::Up(Standard_Real& Vx, Standard_Real& Vy, Standard_Real& Vz) const
2408 Graphic3d_Vector Vup ;
2410 Vup = MyViewOrientation.ViewReferenceUp() ;
2411 Vup.Coord(Vx,Vy,Vz) ;
2414 Standard_Real V3d_View::Twist() const
2416 Standard_Real Xup,Yup,Zup,Xpn,Ypn,Zpn,X0,Y0,Z0 ;
2417 Standard_Real pvx,pvy,pvz,pvn,sca,angle ;
2418 Graphic3d_Vector Vpn,Vup,Xaxis,Yaxis,Zaxis ;
2419 Standard_Boolean TheStatus ;
2421 Vpn = MyViewOrientation.ViewReferencePlane() ;
2422 Vpn.Coord(Xpn,Ypn,Zpn) ;
2423 Vup.SetCoord(0.,0.,1.) ;
2424 TheStatus = ScreenAxis(Vpn,Vup,Xaxis,Yaxis,Zaxis) ;
2426 Vup.SetCoord(0.,1.,0.) ;
2427 TheStatus = ScreenAxis(Vpn,Vup,Xaxis,Yaxis,Zaxis) ;
2430 Vup.SetCoord(1.,0.,0.) ;
2431 TheStatus = ScreenAxis(Vpn,Vup,Xaxis,Yaxis,Zaxis) ;
2433 Yaxis.Coord(X0,Y0,Z0) ;
2434 Vup = MyViewOrientation.ViewReferenceUp() ;
2435 Vup.Coord(Xup,Yup,Zup) ;
2436 /* Compute Cross Vector From Up & Origin */
2437 pvx = Y0*Zup - Z0*Yup ;
2438 pvy = Z0*Xup - X0*Zup ;
2439 pvz = X0*Yup - Y0*Xup ;
2440 pvn = pvx*pvx + pvy*pvy + pvz*pvz ;
2441 sca = X0*Xup + Y0*Yup + Z0*Zup ;
2444 if( angle > 1. ) angle = 1. ;
2445 else if( angle < -1. ) angle = -1. ;
2446 angle = asin(angle) ;
2447 if( sca < 0. ) angle = M_PI - angle ;
2448 if( angle > 0. && angle < M_PI ) {
2449 sca = pvx*Xpn + pvy*Ypn + pvz*Zpn ;
2450 if( sca < 0. ) angle = DEUXPI - angle ;
2455 V3d_TypeOfShadingModel V3d_View::ShadingModel() const
2457 V3d_TypeOfShadingModel SM = (V3d_TypeOfShadingModel)MyViewContext.Model() ;
2461 V3d_TypeOfSurfaceDetail V3d_View::SurfaceDetail() const
2463 V3d_TypeOfSurfaceDetail SM = (V3d_TypeOfSurfaceDetail)MyViewContext.SurfaceDetail() ;
2467 Handle_Graphic3d_TextureEnv V3d_View::TextureEnv() const
2469 Handle(Graphic3d_TextureEnv) SM = MyViewContext.TextureEnv() ;
2473 V3d_TypeOfVisualization V3d_View::Visualization() const
2475 V3d_TypeOfVisualization V =
2476 (V3d_TypeOfVisualization)MyViewContext.Visualization() ;
2480 Standard_Boolean V3d_View::Antialiasing() const
2482 Standard_Boolean A = MyViewContext.AliasingIsOn() ;
2486 Handle(V3d_Viewer) V3d_View::Viewer() const
2491 Standard_Boolean V3d_View::IfWindow() const
2493 Standard_Boolean TheStatus = MyView->IsDefined() ;
2497 Handle(Aspect_Window) V3d_View::Window() const
2502 V3d_TypeOfView V3d_View::Type() const
2507 void V3d_View::SetFocale( const Standard_Real focale )
2509 Standard_TypeMismatch_Raise_if (MyType != V3d_PERSPECTIVE,
2510 "the view is not a perspective view");
2511 Standard_Real Xrp,Yrp,Zrp,ViewPlane,FrontPlane ;
2512 Graphic3d_Vertex Prp ;
2513 Prp = MyViewMapping.ProjectionReferencePoint() ;
2514 Prp.Coord(Xrp,Yrp,Zrp) ;
2515 if( MyProjModel == V3d_TPM_WALKTHROUGH ) {
2516 ViewPlane = Zrp - focale ;
2518 FrontPlane = MyViewMapping.FrontPlaneDistance() ;
2519 ViewPlane = FrontPlane + Zrp - focale ;
2521 MyViewMapping.SetViewPlaneDistance(ViewPlane) ;
2522 MyView->SetViewMapping(MyViewMapping) ;
2527 Standard_Real V3d_View::Focale( ) const
2529 Standard_Real Xrp,Yrp,Zrp,ViewPlane,FrontPlane ;
2530 Standard_Real focale = 0.0 ;
2531 Graphic3d_Vertex Prp ;
2533 if( MyType == V3d_PERSPECTIVE ) {
2534 Prp = MyViewMapping.ProjectionReferencePoint() ;
2535 Prp.Coord(Xrp,Yrp,Zrp) ;
2536 ViewPlane = MyViewMapping.ViewPlaneDistance() ;
2537 if( MyProjModel == V3d_TPM_WALKTHROUGH ) {
2538 focale = Zrp - ViewPlane ;
2540 FrontPlane = MyViewMapping.FrontPlaneDistance() ;
2541 focale = FrontPlane + Zrp - ViewPlane ;
2547 void V3d_View::SetViewingVolume(const Standard_Real Left, const Standard_Real Right,
2548 const Standard_Real Bottom, const Standard_Real Top,
2549 const Standard_Real ZNear, const Standard_Real ZFar)
2551 Standard_Real Umin,Vmin,Umax,Vmax,Xrp,Yrp,Zrp;
2553 V3d_BadValue_Raise_if ( ZNear <= 0. || ZFar <= 0. || ZNear >= ZFar, "V3d_View::SetVolume, bad distances");
2555 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
2556 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
2559 Standard_Real size = (ZFar - ZNear) / 2.;
2561 MyViewMapping.SetFrontPlaneDistance(size);
2562 MyViewMapping.SetBackPlaneDistance(-size);
2564 // keep view plane at front plane distance
2565 MyViewMapping.SetViewPlaneDistance(MyType == V3d_PERSPECTIVE ? 0. : size);
2567 // set window limits
2568 Umin = Left; Umax = Right;
2569 Vmin = Bottom; Vmax = Top;
2570 MyViewMapping.SetWindowLimit(Left, Bottom, Right, Top);
2572 // Update window center
2573 if ( MyType == V3d_PERSPECTIVE ) {
2577 Xrp = (Umin + Umax)/2. ; Yrp = (Vmin + Vmax)/2. ;
2579 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
2580 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint);
2582 MyView->SetViewMapping(MyViewMapping) ;
2587 Handle(Visual3d_View) V3d_View::View() const
2592 Visual3d_ViewMapping V3d_View::ViewMapping() const
2594 return MyViewMapping;
2597 Visual3d_ViewOrientation V3d_View::ViewOrientation() const
2599 return MyViewOrientation;
2602 Standard_Boolean V3d_View::ScreenAxis( const Graphic3d_Vector &Vpn, const Graphic3d_Vector &Vup, Graphic3d_Vector &Xaxe, Graphic3d_Vector &Yaxe, Graphic3d_Vector &Zaxe)
2604 Standard_Real Xpn,Ypn,Zpn,Xup,Yup,Zup ;
2605 Standard_Real dx1,dy1,dz1,dx2,dy2,dz2,xx,yy,zz ;
2607 Vpn.Coord(Xpn,Ypn,Zpn) ;
2608 Vup.Coord(Xup,Yup,Zup) ;
2609 xx = Yup*Zpn - Zup*Ypn ;
2610 yy = Zup*Xpn - Xup*Zpn ;
2611 zz = Xup*Ypn - Yup*Xpn ;
2612 Xaxe.SetCoord(xx,yy,zz) ;
2613 if( Xaxe.LengthZero() ) return Standard_False;
2614 Xaxe.Normalize() ; Xaxe.Coord(dx1,dy1,dz1) ;
2615 xx = Ypn*dz1 - Zpn*dy1 ;
2616 yy = Zpn*dx1 - Xpn*dz1 ;
2617 zz = Xpn*dy1 - Ypn*dx1 ;
2618 Yaxe.SetCoord(xx,yy,zz) ;
2619 if( Yaxe.LengthZero() ) return Standard_False;
2620 Yaxe.Normalize() ; Yaxe.Coord(dx2,dy2,dz2) ;
2621 xx = dy1*dz2 - dz1*dy2 ;
2622 yy = dz1*dx2 - dx1*dz2 ;
2623 zz = dx1*dy2 - dy1*dx2 ;
2624 Zaxe.SetCoord(xx,yy,zz) ;
2625 if( Zaxe.LengthZero() ) return Standard_False;
2627 return Standard_True ;
2630 void V3d_View::InitMatrix( TColStd_Array2OfReal& Matrix )
2632 Standard_Integer LR = Matrix.LowerRow() ;
2633 Standard_Integer UR = Matrix.UpperRow() ;
2634 Standard_Integer LC = Matrix.LowerCol() ;
2635 Standard_Integer UC = Matrix.UpperCol() ;
2636 Standard_Integer I,J ;
2638 for( I=LR ; I<=UR ; I++ ) {
2639 for( J=LC ; J<=UC ; J++ ) Matrix(I,J) = 0. ;
2641 for( I=LR,J=LC ; I<=UR ; I++,J++ ) Matrix(I,J) = 1. ;
2644 Standard_Boolean V3d_View::Multiply (const TColStd_Array2OfReal& Left, const TColStd_Array2OfReal& Right, TColStd_Array2OfReal& Matrix)
2646 Standard_Integer llr = Left.LowerRow ();
2647 Standard_Integer llc = Left.LowerCol ();
2648 Standard_Integer luc = Left.UpperCol ();
2650 Standard_Integer rlr = Right.LowerRow ();
2651 Standard_Integer rur = Right.UpperRow ();
2652 Standard_Integer rlc = Right.LowerCol ();
2654 Standard_Integer mlr = Matrix.LowerRow ();
2655 Standard_Integer mur = Matrix.UpperRow ();
2656 Standard_Integer mlc = Matrix.LowerCol ();
2657 Standard_Integer muc = Matrix.UpperCol ();
2659 TColStd_Array2OfReal Result (mlr, mur, mlc, muc);
2661 InitMatrix (Result);
2663 // Left et Right incompatibles
2664 if (luc - llc + 1 != rur - rlr + 1)
2665 return Standard_False;
2667 Standard_Integer i, j, k;
2670 Standard_Integer I1 = llr;
2672 for (i=mlr; i<=mur; i++) {
2673 Standard_Integer J2 = rlc;
2674 for (j=mlc; j<=muc; j++) {
2676 Standard_Integer J1 = llc;
2677 Standard_Integer I2 = rlr;
2678 for (k=llc; k<=luc; k++) {
2679 Som = Som + Left (I1, J1) * Right (I2, J2);
2683 Result (i, j) = Som;
2689 for (i=mlr; i<=mur; i++)
2690 for (j=mlc; j<=muc; j++)
2691 Matrix (i, j) = Result (i, j);
2693 return Standard_True;
2696 /*----------------------------------------------------------------------*/
2698 void V3d_View::RotAxis( const Graphic3d_Vertex &Vrp, const Graphic3d_Vector &Axe, const Standard_Real angle, TColStd_Array2OfReal& Matrix )
2700 Standard_Real Xrp,Yrp,Zrp,Xaxe,Yaxe,Zaxe ;
2701 Standard_Real sina,cosa,cos1m,terms1,terms2,terms3 ;
2702 Standard_Real termc12,termc13,termc23,vcal ;
2703 TColStd_Array2OfReal Tmatrix(0,3,0,3) ;
2704 TColStd_Array2OfReal Rmatrix(0,3,0,3) ;
2706 InitMatrix(Matrix) ;
2707 InitMatrix(Tmatrix) ;
2709 Vrp.Coord(Xrp,Yrp,Zrp) ;
2710 Axe.Coord(Xaxe,Yaxe,Zaxe) ;
2711 /* translation of x,y,z */
2712 Tmatrix(0,3) = Xrp ; Tmatrix(1,3) = Yrp ; Tmatrix(2,3) = Zrp ;
2713 /* rotation around an axis */
2714 cosa = cos(angle); sina = sin(angle); cos1m = 1. - cosa ;
2715 termc12 = Xaxe * Yaxe * cos1m ;
2716 termc13 = Xaxe * Zaxe * cos1m ;
2717 termc23 = Yaxe * Zaxe * cos1m ;
2718 terms1 = Xaxe * sina ;
2719 terms2 = Yaxe * sina ;
2720 terms3 = Zaxe * sina ;
2722 vcal = Xaxe * Xaxe ;
2723 Rmatrix(0,0) = vcal + ( 1. - vcal ) * cosa ;
2724 Rmatrix(1,0) = termc12 + terms3 ;
2725 Rmatrix(2,0) = termc13 - terms2 ;
2727 Rmatrix(0,1) = termc12 - terms3 ;
2728 vcal = Yaxe * Yaxe ;
2729 Rmatrix(1,1) = vcal + ( 1. - vcal ) * cosa ;
2730 Rmatrix(2,1) = termc23 + terms1 ;
2732 Rmatrix(0,2) = termc13 + terms2 ;
2733 Rmatrix(1,2) = termc23 - terms1 ;
2734 vcal = Zaxe * Zaxe ;
2735 Rmatrix(2,2) = vcal + ( 1. - vcal ) * cosa ;
2741 /* produced by two matrices */
2742 Multiply(Tmatrix, Rmatrix, Matrix);
2743 /* translation invert */
2744 Tmatrix(0,3) = -Xrp;
2745 Tmatrix(1,3) = -Yrp;
2746 Tmatrix(2,3) = -Zrp;
2748 Multiply(Matrix, Tmatrix, Matrix);
2751 /*----------------------------------------------------------------------*/
2753 Graphic3d_Vertex V3d_View::TrsPoint( const Graphic3d_Vertex &P, const TColStd_Array2OfReal &Matrix )
2755 Graphic3d_Vertex PP ;
2756 Standard_Real X,Y,Z,XX,YY,ZZ ;
2759 Standard_Integer lr, ur, lc, uc;
2760 lr = Matrix.LowerRow ();
2761 ur = Matrix.UpperRow ();
2762 lc = Matrix.LowerCol ();
2763 uc = Matrix.UpperCol ();
2764 if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) ) {
2766 PP.SetCoord(X,Y,Z) ;
2770 XX = (Matrix(lr,lc+3) + X*Matrix(lr,lc) + Y*Matrix(lr,lc+1)+
2771 Z*Matrix(lr,lc+2))/Matrix(lr+3,lc+3) ;
2773 YY = (Matrix(lr+1,lc+3) + X*Matrix(lr+1,lc) + Y*Matrix(lr+1,lc+1) +
2774 Z*Matrix(lr+1,lc+2))/Matrix(lr+3,lc+3) ;
2776 ZZ = (Matrix(lr+2,lc+3) + X*Matrix(lr+2,lc) + Y*Matrix(lr+2,lc+1) +
2777 Z*Matrix(lr+2,lc+2))/Matrix(lr+3,lc+3) ;
2778 PP.SetCoord(XX,YY,ZZ) ;
2782 Graphic3d_Vector V3d_View::TrsPoint( const Graphic3d_Vector& V, const TColStd_Array2OfReal& Matrix )
2784 Graphic3d_Vector VV ;
2785 Standard_Real X,Y,Z,XX,YY,ZZ ;
2788 Standard_Integer lr, ur, lc, uc;
2789 lr = Matrix.LowerRow ();
2790 ur = Matrix.UpperRow ();
2791 lc = Matrix.LowerCol ();
2792 uc = Matrix.UpperCol ();
2793 if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) ) {
2795 VV.SetCoord(X,Y,Z) ;
2799 XX = X*Matrix(lr,lc)+Y*Matrix(lr,lc+1)+Z*Matrix(lr,lc+2) ;
2800 YY = X*Matrix(lr+1,lc)+Y*Matrix(lr+1,lc+1)+Z*Matrix(lr+1,lc+2) ;
2801 ZZ = X*Matrix(lr+2,lc)+Y*Matrix(lr+2,lc+1)+Z*Matrix(lr+2,lc+2) ;
2802 VV.SetCoord(XX,YY,ZZ) ; VV.Normalize() ;
2806 void V3d_View::Pan(const Standard_Integer Dx, const Standard_Integer Dy,const Quantity_Factor aZoomFactor)
2808 Panning(Convert(Dx),Convert(Dy),aZoomFactor,Standard_True);
2811 void V3d_View::Zoom (const Standard_Integer X1,
2812 const Standard_Integer Y1,
2813 const Standard_Integer X2,
2814 const Standard_Integer Y2)
2817 Standard_Real dx = Standard_Real (X2-X1);
2818 Standard_Real dy = Standard_Real (Y2-Y1);
2819 if ( dx != 0. || dy != 0. ) {
2820 Standard_Real dzoom = Sqrt(dx*dx + dy*dy) / 100. + 1;
2821 dzoom = (dx > 0) ? dzoom : 1./dzoom;
2822 SetZoom(dzoom, Standard_True);
2826 void V3d_View::Zoom (const Standard_Integer X1,
2827 const Standard_Integer Y1)
2831 Standard_Integer ix,iy;
2836 // Defines the point (pixel) of zooming (for the method ZoomAtPoint()).
2837 void V3d_View::StartZoomAtPoint(const Standard_Integer xpix, const Standard_Integer ypix)
2839 MyZoomAtPointX = xpix;
2840 MyZoomAtPointY = ypix;
2843 // Zooms the model at a pixel defined by the method StartZoomAtPoint().
2844 void V3d_View::ZoomAtPoint(const Standard_Integer mouseStartX,
2845 const Standard_Integer mouseStartY,
2846 const Standard_Integer mouseEndX,
2847 const Standard_Integer mouseEndY)
2849 Standard_Boolean update;
2850 V3d_Coordinate X0, Y0, XS, YS;
2852 // Forbid any update.
2853 update = SetImmediateUpdate(Standard_False);
2858 // Pan the point to the center of window.
2859 Convert(MyZoomAtPointX, MyZoomAtPointY, XS, YS);
2860 Panning(X0-XS, Y0-YS);
2863 Standard_Real d = Standard_Real ((mouseEndX + mouseEndY) - (mouseStartX + mouseStartY));
2865 Standard_Real dzoom = fabs(d) / 100.0 + 1.0;
2866 dzoom = (d > 0) ? dzoom : 1.0 / dzoom;
2867 V3d_BadValue_Raise_if( dzoom <= 0.,"V3d_View::ZoomAtPoint, bad coefficient");
2869 Standard_Real Umin,Vmin,Umax,Vmax;
2870 MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax);
2872 MyXwindowCenter = (Umin + Umax) / 2.0;
2873 MyYwindowCenter = (Vmin + Vmax) / 2.0;
2874 MyWindowWidth = Abs(Umax - Umin);
2875 MyWindowHeight = Abs(Vmax - Vmin);
2877 // Ensure that zoom will not be too small or too big.
2878 Standard_Real coef = dzoom;
2879 if (MyWindowWidth < coef * Precision::Confusion())
2880 coef = MyWindowWidth / Precision::Confusion();
2881 else if (MyWindowWidth > coef * 1e12)
2882 coef = MyWindowWidth / 1e12;
2883 if (MyWindowHeight < coef * Precision::Confusion())
2884 coef = MyWindowHeight / Precision::Confusion();
2885 else if (MyWindowHeight > coef * 1e12)
2886 coef = MyWindowHeight / 1e12;
2888 Standard_Real Dxv = MyWindowWidth / coef;
2889 Standard_Real Dyv = MyWindowHeight / coef;
2891 Umin = MyXwindowCenter - Dxv/2.0; Umax = MyXwindowCenter + Dxv/2.0;
2892 Vmin = MyYwindowCenter - Dyv/2.0; Vmax = MyYwindowCenter + Dyv/2.0;
2894 // Pan the point backwards.
2895 Dxv = (XS - X0) / coef;
2896 Dyv = (YS - Y0) / coef;
2898 MyXwindowCenter = (Umin + Umax) / 2.0;
2899 MyYwindowCenter = (Vmin + Vmax) / 2.0;
2900 MyWindowWidth = Abs(Umax - Umin);
2901 MyWindowHeight = Abs(Vmax - Vmin);
2903 Standard_Real Xrp,Yrp,Zrp;
2904 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint();
2905 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp);
2907 Xrp = MyXwindowCenter - Dxv;
2908 Yrp = MyYwindowCenter - Dyv;
2910 Umin = Xrp - MyWindowWidth / 2.0; Umax = Xrp + MyWindowWidth / 2.0;
2911 Vmin = Yrp - MyWindowHeight / 2.0; Vmax = Yrp + MyWindowHeight / 2.0;
2913 // Set new reference plane coordintes of the window.
2914 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax);
2915 if (MyType != V3d_PERSPECTIVE)
2917 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp);
2918 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint);
2920 MyView->SetViewMapping(MyViewMapping);
2923 SetImmediateUpdate(update);
2927 void V3d_View::AxialScale (const Standard_Integer Dx,
2928 const Standard_Integer Dy,
2929 const V3d_TypeOfAxe Axis)
2931 if( Dx != 0. || Dy != 0. ) {
2932 Standard_Real Sx, Sy, Sz;
2933 AxialScale( Sx, Sy, Sz );
2934 Standard_Real dscale = Sqrt(Dx*Dx + Dy*Dy) / 100. + 1;
2935 dscale = (Dx > 0) ? dscale : 1./dscale;
2936 if( Axis == V3d_X ) Sx = dscale;
2937 if( Axis == V3d_Y ) Sy = dscale;
2938 if( Axis == V3d_Z ) Sz = dscale;
2939 SetAxialScale( Sx, Sy, Sz );
2943 void V3d_View::FitAll(const Handle(Aspect_Window)& aWindow,
2944 const Standard_Real Xmin,
2945 const Standard_Real Ymin,
2946 const Standard_Real Xmax,
2947 const Standard_Real Ymax)
2950 Standard_Real Umin,Umax,Vmin,Vmax,Xrp,Yrp,Zrp ;
2951 Standard_Real DxvOld,DyvOld,DxvNew,DyvNew,RapOld,RapNew ;
2952 Standard_Integer Xpixel,Ypixel;
2953 //Standard_Integer Xleft,Yup,Xright,Ylow ;
2955 V3d_BadValue_Raise_if( (Xmin == Xmax) || (Ymin == Ymax) ,
2956 "V3d_View::FitAll, Window Size is NULL");
2958 MyProjReferencePoint = MyViewMapping.ProjectionReferencePoint() ;
2959 MyProjReferencePoint.Coord(Xrp,Yrp,Zrp) ;
2960 aWindow->Size(Xpixel,Ypixel);
2961 DxvOld = Xpixel; DyvOld = Ypixel;
2963 if( (DxvOld == 0.) || (DyvOld == 0.) ) return ;
2964 RapOld = DxvOld/DyvOld ;
2965 DxvNew = Abs(Xmax - Xmin) ; DyvNew = Abs(Ymax - Ymin) ;
2966 RapNew = DxvNew/DyvNew ;
2967 if( RapNew >= RapOld ) {
2968 DyvNew = DxvNew/RapOld ;
2970 DxvNew = DyvNew*RapOld ;
2972 Xrp = (Xmin + Xmax)/2. ; Yrp = (Ymin + Ymax)/2. ;
2973 Umin = Xrp - DxvNew/2. ; Vmin = Yrp - DyvNew/2. ;
2974 Umax = Xrp + DxvNew/2. ; Vmax = Yrp + DyvNew/2. ;
2975 MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
2976 if( MyType != V3d_PERSPECTIVE ) {
2977 MyProjReferencePoint.SetCoord(Xrp,Yrp,Zrp) ;
2978 MyViewMapping.SetProjectionReferencePoint(MyProjReferencePoint);
2980 MyView->SetViewMapping(MyViewMapping) ;
2989 static Standard_Boolean zRotation = Standard_False;
2991 void V3d_View::StartRotation(const Standard_Integer X,
2992 const Standard_Integer Y,
2993 const Quantity_Ratio zRotationThreshold)
2999 rx = Standard_Real(Convert(x));
3000 ry = Standard_Real(Convert(y));
3002 Rotate(0.,0.,0.,gx,gy,gz,Standard_True);
3004 zRotation = Standard_False;
3005 if( zRotationThreshold > 0. ) {
3006 Standard_Real dx = Abs(sx - rx/2.);
3007 Standard_Real dy = Abs(sy - ry/2.);
3008 // if( dx > rx/3. || dy > ry/3. ) zRotation = Standard_True;
3009 Standard_Real dd = zRotationThreshold * (rx + ry)/2.;
3010 if( dx > dd || dy > dd ) zRotation = Standard_True;
3016 void V3d_View::Rotation(const Standard_Integer X,
3017 const Standard_Integer Y)
3021 if( rx == 0. || ry == 0. ) {
3027 Standard_Real dx=0.,dy=0.,dz=0.;
3029 dz = atan2(Standard_Real(X)-rx/2., ry/2.-Standard_Real(Y)) -
3030 atan2(sx-rx/2.,ry/2.-sy);
3032 dx = (Standard_Real(X) - sx) * M_PI / rx;
3033 dy = (sy - Standard_Real(Y)) * M_PI / ry;
3035 Rotate(dx, dy, dz, gx, gy, gz, Standard_False);
3037 Standard_Real dx = (Standard_Real(X - sx)) * M_PI;
3038 Standard_Real dy = (Standard_Real(sy - Y)) * M_PI;
3039 Rotate(dx/rx, dy/ry, 0., gx, gy, gz, Standard_False);
3042 if( !myImmediateUpdate ) Update();
3044 myImmediateUpdate = Standard_False;
3045 Rotate(dx/rx, dy/ry, 0., gx, gy, gz, Standard_False);
3046 ZFitAll (Zmargin); //Don't do that, perf improvment
3047 myImmediateUpdate = Standard_True;
3052 void V3d_View :: SetComputedMode ( const Standard_Boolean aMode )
3055 if( myComputedMode ) {
3056 MyView -> SetComputedMode ( Standard_True );
3060 MyView -> SetComputedMode ( Standard_False );
3065 Standard_Boolean V3d_View :: ComputedMode () const
3067 return MyView -> ComputedMode ();
3070 void V3d_View :: SetBackFacingModel (const V3d_TypeOfBackfacingModel aModel)
3072 MyView -> SetBackFacingModel ( Visual3d_TypeOfBackfacingModel(aModel) );
3076 V3d_TypeOfBackfacingModel V3d_View :: BackFacingModel () const
3078 return V3d_TypeOfBackfacingModel(MyView -> BackFacingModel ());
3081 Standard_Boolean V3d_View::TransientManagerBeginDraw(const Standard_Boolean DoubleBuffer,const Standard_Boolean RetainMode) const
3083 return Visual3d_TransientManager::BeginDraw(MyView,DoubleBuffer,RetainMode);
3086 void V3d_View::TransientManagerClearDraw() const
3088 Visual3d_TransientManager::ClearDraw(MyView);
3091 Standard_Boolean V3d_View::TransientManagerBeginAddDraw() const
3093 return Visual3d_TransientManager::BeginAddDraw(MyView);
3096 void V3d_View::Init()
3098 myComputedMode = MyViewer->ComputedMode();
3099 if( !myComputedMode || !MyViewer->DefaultComputedMode() ) {
3100 SetComputedMode(Standard_False);
3104 OSD_Environment env_walkthrow("CSF_WALKTHROUGH");
3105 env_walkthrow.SetName( "CSF_WALKTHROUGH" );
3106 if ( env_walkthrow.Value () != "" ) MyProjModel = V3d_TPM_WALKTHROUGH;
3107 else MyProjModel = V3d_TPM_SCREEN;
3111 void V3d_View::SetPlotter(const Handle(Graphic3d_Plotter)& aPlotter)
3113 MyPlotter = aPlotter;
3116 void V3d_View::Plot()
3118 V3d_BadValue_Raise_if( !MyPlotter.IsNull(), "view has no plotter");
3119 MyView->Plot(MyPlotter);
3122 #include <Aspect.hxx>
3123 #include <Visual3d_Layer.hxx>
3125 ////////////////////////////////////////////////////////////////
3126 Standard_Boolean V3d_View::Dump (const Standard_CString theFile,
3127 const Graphic3d_BufferType& theBufferType)
3129 Standard_Integer aWinWidth, aWinHeight;
3130 MyWindow->Size (aWinWidth, aWinHeight);
3131 Image_AlienPixMap anImage;
3132 return ToPixMap (anImage, aWinWidth, aWinHeight, theBufferType) && anImage.Save (theFile);
3135 ////////////////////////////////////////////////////////////////
3136 Standard_Boolean V3d_View::ToPixMap (Image_PixMap& theImage,
3137 const Standard_Integer theWidth,
3138 const Standard_Integer theHeight,
3139 const Graphic3d_BufferType& theBufferType,
3140 const Standard_Boolean theIsForceCentred)
3142 Graphic3d_CView* cView = (Graphic3d_CView* )MyView->CView();
3144 // always prefer hardware accelerated offscreen buffer
3145 Graphic3d_PtrFrameBuffer aFBOPtr = NULL;
3146 Graphic3d_PtrFrameBuffer aPrevFBOPtr = (Graphic3d_PtrFrameBuffer )cView->ptrFBO;
3147 Standard_Integer aFBOVPSizeX (theWidth), aFBOVPSizeY (theHeight), aFBOSizeXMax (0), aFBOSizeYMax (0);
3148 Standard_Integer aPrevFBOVPSizeX (0), aPrevFBOVPSizeY (0), aPrevFBOSizeXMax (0), aPrevFBOSizeYMax (0);
3149 if (aPrevFBOPtr != NULL)
3151 MyView->FBOGetDimensions (aPrevFBOPtr,
3152 aPrevFBOVPSizeX, aPrevFBOVPSizeY,
3153 aPrevFBOSizeXMax, aPrevFBOSizeYMax);
3154 if (aFBOVPSizeX <= aPrevFBOSizeXMax && aFBOVPSizeY <= aPrevFBOSizeYMax)
3156 MyView->FBOChangeViewport (aPrevFBOPtr, aFBOVPSizeX, aFBOVPSizeY);
3157 aFBOPtr = aPrevFBOPtr;
3161 if (aFBOPtr == NULL)
3163 // Try to create hardware accelerated buffer
3164 aFBOPtr = MyView->FBOCreate (aFBOVPSizeX, aFBOVPSizeY);
3165 if (aFBOPtr != NULL)
3167 MyView->FBOGetDimensions (aFBOPtr,
3168 aFBOVPSizeX, aFBOVPSizeY,
3169 aFBOSizeXMax, aFBOSizeYMax);
3170 // reduce viewport in case of hardware limits
3171 if (aFBOVPSizeX > aFBOSizeXMax) aFBOVPSizeX = aFBOSizeXMax;
3172 if (aFBOVPSizeY > aFBOSizeYMax) aFBOVPSizeY = aFBOSizeYMax;
3173 MyView->FBOChangeViewport (aFBOPtr, aFBOVPSizeX, aFBOVPSizeY);
3176 cView->ptrFBO = aFBOPtr;
3178 // If hardware accelerated buffer - try to use onscreen buffer
3179 // Results may be bad!
3180 if (aFBOPtr == NULL)
3182 // retrieve window sizes
3183 Standard_Integer aWinWidth, aWinHeight;
3184 MyWindow->Size (aWinWidth, aWinHeight);
3186 // technically we can reduce existing viewport...
3187 // but currently allow only dumping the window itself
3188 if (aFBOVPSizeX != aWinWidth || aFBOVPSizeY != aWinHeight)
3190 return Standard_False;
3195 Visual3d_ViewMapping prevMapping = MyView->ViewMapping();
3196 Standard_Real Umin, Vmin, Umax, Vmax;
3198 if (theIsForceCentred)
3200 //szv: get mapping frame
3201 Standard_Real PUmin, PVmin, PUmax, PVmax;
3202 prevMapping.WindowLimit (PUmin, PVmin, PUmax, PVmax);
3204 //szv: calculate expansion
3205 Umin = PUmin; Vmin = PVmin; Umax = PUmax; Vmax = PVmax;
3206 Standard_Real oldWidth = (PUmax - PUmin), oldHeight = (PVmax - PVmin);
3207 Standard_Real newWidth = (oldHeight * aFBOVPSizeX) / aFBOVPSizeY;
3208 if (newWidth < oldWidth)
3210 Standard_Real newHeight = (oldWidth * aFBOVPSizeY) / aFBOVPSizeX;
3212 Standard_Real delta = 0.5 * (newHeight - oldHeight);
3213 Vmin = PVmin - delta;
3214 Vmax = PVmax + delta;
3219 Standard_Real delta = 0.5 * (newWidth - oldWidth);
3220 Umin = PUmin - delta;
3221 Umax = PUmax + delta;
3224 //szv: apply expanded mapping
3225 MyViewMapping.SetWindowLimit (Umin, Vmin, Umax, Vmax);
3226 MyView->SetViewMapping (MyViewMapping);
3229 //workround for rendering list of Over and Under Layers
3230 if (!MyLayerMgr.IsNull())
3232 MyLayerMgr->Compute();
3235 // render immediate structures into back buffer rather than front
3236 Handle(Graphic3d_GraphicDriver) aDriver = Handle(Graphic3d_GraphicDriver)::DownCast (MyView->GraphicDriver());
3237 const Standard_Boolean aPrevImmediateMode = aDriver.IsNull() ? Standard_True : aDriver->SetImmediateModeDrawToFront (*cView, Standard_False);
3241 if (!aDriver.IsNull())
3243 aDriver->SetImmediateModeDrawToFront (*cView, aPrevImmediateMode);
3246 //szv: restore mapping
3247 MyViewMapping = prevMapping;
3248 MyView->SetViewMapping (prevMapping);
3250 Standard_Boolean isSuccess = Standard_True;
3252 // allocate image buffer for dumping
3253 if (theImage.IsEmpty()
3254 || (Standard_Size )aFBOVPSizeX != theImage.SizeX()
3255 || (Standard_Size )aFBOVPSizeY != theImage.SizeY())
3257 bool isBigEndian = Image_PixMap::IsBigEndianHost();
3258 Image_PixMap::ImgFormat aFormat = Image_PixMap::ImgUNKNOWN;
3259 switch (theBufferType)
3261 case Graphic3d_BT_RGB: aFormat = isBigEndian ? Image_PixMap::ImgRGB : Image_PixMap::ImgBGR; break;
3262 case Graphic3d_BT_RGBA: aFormat = isBigEndian ? Image_PixMap::ImgRGBA : Image_PixMap::ImgBGRA; break;
3263 case Graphic3d_BT_Depth: aFormat = Image_PixMap::ImgGrayF; break;
3266 isSuccess = isSuccess && theImage.InitZero (aFormat, aFBOVPSizeX, aFBOVPSizeY);
3268 isSuccess = isSuccess && MyView->BufferDump (theImage, theBufferType);
3270 // FBO now useless, free resources
3271 if (aFBOPtr != aPrevFBOPtr)
3273 MyView->FBORelease (aFBOPtr);
3275 else if (aPrevFBOPtr != NULL)
3277 MyView->FBOChangeViewport (aPrevFBOPtr, aPrevFBOVPSizeX, aPrevFBOVPSizeY);
3279 cView->ptrFBO = aPrevFBOPtr;
3283 void V3d_View::ImmediateUpdate() const
3285 if (myImmediateUpdate) Update();
3288 Standard_Boolean V3d_View::SetImmediateUpdate (const Standard_Boolean theImmediateUpdate)
3290 Standard_Boolean aPreviousMode = myImmediateUpdate;
3291 myImmediateUpdate = theImmediateUpdate;
3292 return aPreviousMode;