X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSVTK%2FSVTK_Renderer.cxx;h=d5ccedbefe59f7690d755967d4b7c4002986c054;hb=02904c3728214667f919cfe06072a91e1687b12f;hp=cad43a139ad925709e6a2317a4c09b14acc79017;hpb=9f1a66957ba9a2308f8fdc3f9397140af9df5fd0;p=modules%2Fgui.git diff --git a/src/SVTK/SVTK_Renderer.cxx b/src/SVTK/SVTK_Renderer.cxx index cad43a139..d5ccedbef 100644 --- a/src/SVTK/SVTK_Renderer.cxx +++ b/src/SVTK/SVTK_Renderer.cxx @@ -1,44 +1,43 @@ -// SALOME VTKViewer : build VTK viewer into Salome desktop +// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + +// SALOME VTKViewer : build VTK viewer into Salome desktop // File : // Author : -// Module : -// $Header$ #include "SVTK_Renderer.h" #include "SVTK_Trihedron.h" #include "SVTK_CubeAxesActor2D.h" -#include "SVTK_RectPicker.h" +#include "SVTK_AreaPicker.h" #include "SALOME_Actor.h" #include "VTKViewer_Actor.h" +#include "VTKViewer_Algorithm.h" #include "VTKViewer_Transform.h" #include "VTKViewer_Utilities.h" +#include "VTKViewer_OpenGLRenderer.h" #include -#include #include #include #include @@ -48,6 +47,7 @@ #include #include +#include // undefining min and max because CASCADE's defines them and // it clashes with std::min(), std::max() included in utilities.h @@ -55,41 +55,41 @@ #undef max -//---------------------------------------------------------------------------- vtkStandardNewMacro(SVTK_Renderer); -//---------------------------------------------------------------------------- +/*! + Constructor +*/ SVTK_Renderer ::SVTK_Renderer(): - myDevice(vtkRenderer::New()), + myDevice(VTKViewer_OpenGLRenderer::New()), myInteractor(NULL), myPriority(0.0), myEventCallbackCommand(vtkCallbackCommand::New()), myPointPicker(vtkPointPicker::New()), myCellPicker(vtkCellPicker::New()), - myPointRectPicker(SVTK_RectPicker::New()), - myCellRectPicker(SVTK_RectPicker::New()), + myPointAreaPicker(SVTK_AreaPicker::New()), + myCellAreaPicker(SVTK_AreaPicker::New()), myPreHighlightProperty(vtkProperty::New()), myHighlightProperty(vtkProperty::New()), myTransform(VTKViewer_Transform::New()), myCubeAxes(SVTK_CubeAxesActor2D::New()), myTrihedron(SVTK_Trihedron::New()), - myTrihedronSize(105) + myTrihedronSize(105), + myIsTrihedronRelative(true) { myDevice->Delete(); myTransform->Delete(); - SetSelectionTolerance(); - myPointPicker->Delete(); myCellPicker->Delete(); - myPointRectPicker->Delete(); - myPointRectPicker->PickFromListOn(); + myPointAreaPicker->Delete(); + myPointAreaPicker->PickFromListOn(); - myCellRectPicker->Delete(); - myCellRectPicker->PickFromListOn(); - myCellRectPicker->PickPointsOff(); + myCellAreaPicker->Delete(); + myCellAreaPicker->PickFromListOn(); + myCellAreaPicker->PickPointsOff(); //SetPreselectionProp(); myPreHighlightProperty->Delete(); @@ -105,12 +105,15 @@ SVTK_Renderer myHighlightProperty->SetLineWidth(SALOME_LINE_WIDTH+2); myHighlightProperty->SetRepresentationToPoints(); + // Bug 0020123, note 0005217 - Problem with zoom + GetDevice()->SetNearClippingPlaneTolerance( 0.00001 ); + myTrihedron->Delete(); myCubeAxes->Delete(); myEventCallbackCommand->Delete(); myTrihedron->AddToRender(GetDevice()); - GetDevice()->AddProp(GetCubeAxes()); + GetDevice()->AddViewProp(GetCubeAxes()); myBndBox[0] = myBndBox[2] = myBndBox[4] = 0; myBndBox[1] = myBndBox[3] = myBndBox[5] = myTrihedron->GetSize(); @@ -141,20 +144,24 @@ SVTK_Renderer myEventCallbackCommand->SetClientData(this); myEventCallbackCommand->SetCallback(SVTK_Renderer::ProcessEvents); GetDevice()->AddObserver(vtkCommand::ConfigureEvent, - myEventCallbackCommand.GetPointer(), - myPriority); + myEventCallbackCommand.GetPointer(), + myPriority); GetDevice()->AddObserver(vtkCommand::ResetCameraEvent, - myEventCallbackCommand.GetPointer(), - myPriority); + myEventCallbackCommand.GetPointer(), + myPriority); GetDevice()->AddObserver(vtkCommand::ResetCameraClippingRangeEvent, - myEventCallbackCommand.GetPointer(), - myPriority); + myEventCallbackCommand.GetPointer(), + myPriority); } +/*! + Destructor +*/ SVTK_Renderer ::~SVTK_Renderer() { - vtkActorCollection* anActors = GetDevice()->GetActors(); + VTK::ActorCollectionCopy aCopy(GetDevice()->GetActors()); + vtkActorCollection* anActors = aCopy.GetActors(); vtkActorCollection* anActors2 = vtkActorCollection::New(); anActors->InitTraversal(); @@ -175,12 +182,15 @@ SVTK_Renderer } +/*! + Main process event method +*/ void SVTK_Renderer ::ProcessEvents(vtkObject* vtkNotUsed(theObject), - unsigned long theEvent, - void* theClientData, - void* vtkNotUsed(theCallData)) + unsigned long theEvent, + void* theClientData, + void* vtkNotUsed(theCallData)) { SVTK_Renderer* self = reinterpret_cast(theClientData); @@ -197,7 +207,9 @@ SVTK_Renderer } } -//---------------------------------------------------------------------------- +/*! + \return renderer's device +*/ vtkRenderer* SVTK_Renderer ::GetDevice() @@ -205,19 +217,25 @@ SVTK_Renderer return myDevice.GetPointer(); } +/*! + Initialize renderer +*/ void SVTK_Renderer ::Initialize(vtkRenderWindowInteractor* theInteractor, - SVTK_Selector* theSelector) + SVTK_Selector* theSelector) { myInteractor = theInteractor; mySelector = theSelector; + SetSelectionTolerance(); } -//---------------------------------------------------------------------------- +/*! + Publishes pointed actor into the renderer +*/ void SVTK_Renderer -::AddActor(VTKViewer_Actor* theActor) +::AddActor(VTKViewer_Actor* theActor, bool theIsAdjustActors) { if(SALOME_Actor* anActor = dynamic_cast(theActor)){ anActor->SetInteractor(myInteractor); @@ -227,20 +245,26 @@ SVTK_Renderer anActor->SetPointPicker(myPointPicker.GetPointer()); anActor->SetCellPicker(myCellPicker.GetPointer()); - anActor->SetPointRectPicker(myPointRectPicker.GetPointer()); - anActor->SetCellRectPicker(myCellRectPicker.GetPointer()); + anActor->SetPointAreaPicker(myPointAreaPicker.GetPointer()); + anActor->SetCellAreaPicker(myCellAreaPicker.GetPointer()); anActor->SetPreHighlightProperty(myPreHighlightProperty.GetPointer()); anActor->SetHighlightProperty(myHighlightProperty.GetPointer()); anActor->AddToRender(GetDevice()); - AdjustActors(); + anActor->UpdateNameActors(); + + if(theIsAdjustActors) + AdjustActors(); } } +/*! + Removes pointed actor from the renderer +*/ void SVTK_Renderer -::RemoveActor(VTKViewer_Actor* theActor) +::RemoveActor(VTKViewer_Actor* theActor, bool theIsAdjustActors) { if(SALOME_Actor* anActor = dynamic_cast(theActor)){ // Order of the calls are important because VTKViewer_Actor::RemoveFromRender @@ -252,17 +276,32 @@ SVTK_Renderer anActor->SetPointPicker(NULL); anActor->SetCellPicker(NULL); - anActor->SetPointRectPicker(NULL); - anActor->SetCellRectPicker(NULL); + anActor->SetPointAreaPicker(NULL); + anActor->SetCellAreaPicker(NULL); anActor->SetPreHighlightProperty(NULL); anActor->SetHighlightProperty(NULL); anActor->RemoveFromRender(GetDevice()); - AdjustActors(); + + while ( int i = myPointPicker->GetProp3Ds()->IsItemPresent( theActor )) + myPointPicker->GetProp3Ds()->RemoveItem( i-1 ); + while ( int i = myCellPicker->GetProp3Ds()->IsItemPresent( theActor )) + myCellPicker->GetProp3Ds()->RemoveItem( i-1 ); + + while ( int i = myPointPicker->GetActors()->IsItemPresent( theActor )) + myPointPicker->GetActors()->RemoveItem( i-1 ); + while ( int i = myCellPicker->GetActors()->IsItemPresent( theActor )) + myCellPicker->GetActors()->RemoveItem( i-1 ); + + if(theIsAdjustActors) + AdjustActors(); } } +/*! + Get special container that keeps scaling of the scene +*/ VTKViewer_Transform* SVTK_Renderer ::GetTransform() @@ -270,6 +309,9 @@ SVTK_Renderer return myTransform.GetPointer(); } +/*! + Allows to get a scale that is applied on the whole scene +*/ void SVTK_Renderer ::GetScale( double theScale[3] ) @@ -277,63 +319,81 @@ SVTK_Renderer myTransform->GetMatrixScale( theScale ); } +/*! + Allows to apply a scale on the whole scene +*/ void SVTK_Renderer ::SetScale( double theScale[3] ) { myTransform->SetMatrixScale( theScale[0], theScale[1], theScale[2] ); AdjustActors(); -} + VTK::ActorCollectionCopy aCopy(GetDevice()->GetActors()); + vtkActorCollection* anActors = aCopy.GetActors(); + anActors->InitTraversal(); + while(vtkActor* anAct = anActors->GetNextActor()) + if(SALOME_Actor* anActor = dynamic_cast(anAct)) + if(anActor->isHighlighted() && !anActor->IsInfinitive()) + anActor->highlight(true); +} -//---------------------------------------------------------------------------- +/*! + Applies color and size (PointSize and LineWidth) of primitives in selection mode +*/ void SVTK_Renderer ::SetSelectionProp(const double& theRed, - const double& theGreen, - const double& theBlue, - const int& theWidth) + const double& theGreen, + const double& theBlue, + const int& theWidth) { myHighlightProperty->SetColor( theRed, theGreen, theBlue ); myHighlightProperty->SetLineWidth( theWidth ); myHighlightProperty->SetPointSize( theWidth ); } -//---------------------------------------------------------------------------- +/*! + Applies color and size (PointSize and LineWidth) of primitives in preselection mode +*/ void SVTK_Renderer ::SetPreselectionProp(const double& theRed, - const double& theGreen, - const double& theBlue, - const int& theWidth) + const double& theGreen, + const double& theBlue, + const int& theWidth) { myPreHighlightProperty->SetColor( theRed, theGreen, theBlue ); myPreHighlightProperty->SetLineWidth( theWidth ); myPreHighlightProperty->SetPointSize( theWidth ); } -//---------------------------------------------------------------------------- +/*! + Setup requested tolerance for the picking +*/ void SVTK_Renderer ::SetSelectionTolerance(const double& theTolNodes, - const double& theTolCell) + const double& theTolCell, + const double& theTolObjects) { myPointPicker->SetTolerance( theTolNodes ); myCellPicker->SetTolerance( theTolCell ); - myPointRectPicker->SetTolerance( theTolNodes ); - myCellRectPicker->SetTolerance( theTolCell ); + myPointAreaPicker->SetTolerance( theTolNodes ); + myCellAreaPicker->SetTolerance( theTolCell ); + + mySelector->SetTolerance( theTolObjects ); } -//---------------------------------------------------------------------------- /*! If parameter theIsForcedUpdate is true, recalculate parameters for * trihedron and cube axes, even if trihedron and cube axes is invisible. */ inline bool -CheckBndBox(const float theBounds[6]) +CheckBndBox(const double theBounds[6]) { if(theBounds[0] > -VTK_LARGE_FLOAT && theBounds[1] < VTK_LARGE_FLOAT && theBounds[2] > -VTK_LARGE_FLOAT && theBounds[3] < VTK_LARGE_FLOAT && @@ -342,6 +402,9 @@ CheckBndBox(const float theBounds[6]) return false; } +/*! + Adjusts size of actors +*/ bool SVTK_Renderer ::OnAdjustActors() @@ -349,7 +412,7 @@ SVTK_Renderer bool aTDisplayed = IsTrihedronDisplayed(); bool aCDisplayed = IsCubeAxesDisplayed(); - float aNewBndBox[6]; + double aNewBndBox[6]; aNewBndBox[ 0 ] = aNewBndBox[ 2 ] = aNewBndBox[ 4 ] = VTK_LARGE_FLOAT; aNewBndBox[ 1 ] = aNewBndBox[ 3 ] = aNewBndBox[ 5 ] = -VTK_LARGE_FLOAT; @@ -363,25 +426,31 @@ SVTK_Renderer // if the new trihedron size have sufficient difference, then apply the value double aSize = myTrihedron->GetSize(); - ComputeTrihedronSize(GetDevice(),aSize,aSize,myTrihedronSize); - myTrihedron->SetSize(aSize); + if ( IsTrihedronRelative() ) + { + ComputeTrihedronSize(GetDevice(),aSize,aSize,myTrihedronSize); + myTrihedron->SetSize(aSize); + } + else + myTrihedron->SetSize( myTrihedronSize ); // iterate through displayed objects and set size if necessary - vtkActorCollection* anActors = GetDevice()->GetActors(); + VTK::ActorCollectionCopy aCopy(GetDevice()->GetActors()); + vtkActorCollection* anActors = aCopy.GetActors(); anActors->InitTraversal(); while(vtkActor* anAct = anActors->GetNextActor()){ if(SALOME_Actor* anActor = dynamic_cast(anAct)){ - if(anActor->IsResizable()) - anActor->SetSize(0.5*aSize); + if(anActor->IsResizable()) + anActor->SetSize(0.5*aSize); if(anActor->GetVisibility() && !anActor->IsInfinitive()){ - float *aBounds = anActor->GetBounds(); + double *aBounds = anActor->GetBounds(); if(CheckBndBox(aBounds)) - for(int i = 0; i < 5; i = i + 2){ - if(aBounds[i] < aNewBndBox[i]) - aNewBndBox[i] = aBounds[i]; - if(aBounds[i+1] > aNewBndBox[i+1]) - aNewBndBox[i+1] = aBounds[i+1]; - } + for(int i = 0; i < 5; i = i + 2){ + if(aBounds[i] < aNewBndBox[i]) + aNewBndBox[i] = aBounds[i]; + if(aBounds[i+1] > aNewBndBox[i+1]) + aNewBndBox[i+1] = aBounds[i+1]; + } } } } @@ -408,6 +477,9 @@ SVTK_Renderer return false; } +/*! + Adjusts size of actors +*/ void SVTK_Renderer ::AdjustActors() @@ -416,25 +488,46 @@ SVTK_Renderer ::ResetCameraClippingRange(GetDevice()); } +/*! + Set size of the trihedron + \param theSize - new size + \param theRelative - if it is true, then size is mesured in percents from bounding box of the scene, + otherwise - in viewer units +*/ void SVTK_Renderer -::SetTrihedronSize(int theSize) +::SetTrihedronSize(double theSize, const bool theRelative) { - if(myTrihedronSize != theSize){ + if(myTrihedronSize != theSize || myIsTrihedronRelative != theRelative){ myTrihedronSize = theSize; + myIsTrihedronRelative = theRelative; AdjustActors(); } } -int +/*! + \return size of the trihedron in percents from bounding box of the scene +*/ +double SVTK_Renderer ::GetTrihedronSize() const { return myTrihedronSize; } +/*! + \return true if the size of the trihedron is relative +*/ +bool +SVTK_Renderer +::IsTrihedronRelative() const +{ + return myIsTrihedronRelative; +} -//---------------------------------------------------------------------------- +/*! + \return trihedron control +*/ VTKViewer_Trihedron* SVTK_Renderer ::GetTrihedron() @@ -442,6 +535,9 @@ SVTK_Renderer return myTrihedron.GetPointer(); } +/*! + \return true if trihedron is displayed +*/ bool SVTK_Renderer ::IsTrihedronDisplayed() @@ -449,6 +545,9 @@ SVTK_Renderer return myTrihedron->GetVisibility() == VTKViewer_Trihedron::eOn; } +/*! + Toggle trihedron visibility +*/ void SVTK_Renderer ::OnViewTrihedron() @@ -459,6 +558,21 @@ SVTK_Renderer myTrihedron->VisibilityOn(); } +/*! + Set trihedron visibility +*/ +void +SVTK_Renderer +::SetTrihedronVisibility( const bool show ) { + if(show) + myTrihedron->VisibilityOn(); + else + myTrihedron->VisibilityOff(); +} + +/*! + Adjust size of the trihedron to the bounding box of the scene +*/ void SVTK_Renderer ::OnAdjustTrihedron() @@ -466,8 +580,9 @@ SVTK_Renderer AdjustActors(); } - -//---------------------------------------------------------------------------- +/*! + \return graduated rules control +*/ SVTK_CubeAxesActor2D* SVTK_Renderer ::GetCubeAxes() @@ -475,6 +590,9 @@ SVTK_Renderer return myCubeAxes.GetPointer(); } +/*! + \return true if graduated rules displayed +*/ bool SVTK_Renderer ::IsCubeAxesDisplayed() @@ -482,6 +600,9 @@ SVTK_Renderer return myCubeAxes->GetVisibility() == 1; } +/*! + Toggle graduated rules visibility +*/ void SVTK_Renderer ::OnViewCubeAxes() @@ -492,6 +613,9 @@ SVTK_Renderer myCubeAxes->VisibilityOn(); } +/*! + Adjust size of the graduated rules to the bounding box of the scene +*/ void SVTK_Renderer ::OnAdjustCubeAxes() @@ -499,8 +623,9 @@ SVTK_Renderer AdjustActors(); } - -//---------------------------------------------------------------------------- +/*! + Sets camera into predefined state +*/ void SVTK_Renderer ::OnResetView() @@ -527,12 +652,13 @@ SVTK_Renderer else myCubeAxes->VisibilityOff(); - static float aCoeff = 3.0; + static double aCoeff = 3.0; aCamera->SetParallelScale(aCoeff*aCamera->GetParallelScale()); } - -//---------------------------------------------------------------------------- +/*! + Fit all presentation in the scene into the window +*/ void SVTK_Renderer ::OnFitAll() @@ -571,8 +697,9 @@ SVTK_Renderer ::ResetCameraClippingRange(GetDevice()); } - -//---------------------------------------------------------------------------- +/*! + Reset camera clipping range to adjust the range to the bounding box of the scene +*/ void SVTK_Renderer ::OnResetClippingRange() @@ -581,8 +708,9 @@ SVTK_Renderer ::ResetCameraClippingRange(GetDevice()); } - -//---------------------------------------------------------------------------- +/*! + To reset direction of the camera to front view +*/ void SVTK_Renderer ::OnFrontView() @@ -594,7 +722,9 @@ SVTK_Renderer this->OnFitAll(); } -//---------------------------------------------------------------------------- +/*! + To reset direction of the camera to back view +*/ void SVTK_Renderer ::OnBackView() @@ -606,7 +736,9 @@ SVTK_Renderer this->OnFitAll(); } -//---------------------------------------------------------------------------- +/*! + To reset direction of the camera to top view +*/ void SVTK_Renderer ::OnTopView() @@ -618,7 +750,9 @@ SVTK_Renderer this->OnFitAll(); } -//---------------------------------------------------------------------------- +/*! + To reset direction of the camera to bottom view +*/ void SVTK_Renderer ::OnBottomView() @@ -630,7 +764,9 @@ SVTK_Renderer this->OnFitAll(); } -//---------------------------------------------------------------------------- +/*! + To reset direction of the camera to left view +*/ void SVTK_Renderer ::OnLeftView() @@ -642,7 +778,34 @@ SVTK_Renderer this->OnFitAll(); } -//---------------------------------------------------------------------------- + +/*! + To rotate view 90 degrees clockwise +*/ +void +SVTK_Renderer +::onClockWiseView() +{ + vtkCamera* aCamera = GetDevice()->GetActiveCamera(); + aCamera->Roll(-90); + aCamera->OrthogonalizeViewUp(); +} + +/*! + To rotate view 90 degrees counterclockwise +*/ +void +SVTK_Renderer +::onAntiClockWiseView() +{ + vtkCamera* aCamera = GetDevice()->GetActiveCamera(); + aCamera->Roll(90); + aCamera->OrthogonalizeViewUp(); +} + +/*! + To reset direction of the camera to right view +*/ void SVTK_Renderer ::OnRightView()