-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "SMESHGUI_VTKUtils.h"
#include "SMESHGUI.h"
-#include "SMESHGUI_Utils.h"
#include "SMESHGUI_Filter.h"
+#include "SMESHGUI_Utils.h"
+#include "SMDS_Mesh.hxx"
+#include "SMESH_Actor.h"
+#include "SMESH_ActorUtils.h"
+#include "SMESH_CellLabelActor.h"
#include "SMESH_ControlsDef.hxx"
-
-#include <SMESH_Actor.h>
-#include <SMESH_ActorUtils.h>
#include "SMESH_NodeLabelActor.h"
-#include "SMESH_CellLabelActor.h"
-#include <SMESH_ObjectDef.h>
-#include <SMDS_Mesh.hxx>
+#include "SMESH_ObjectDef.h"
// SALOME GUI includes
#include <SUIT_Desktop.h>
#include <SUIT_ResourceMgr.h>
#include <SALOME_ListIO.hxx>
-#include <SALOME_ListIteratorOfListIO.hxx>
#include <SVTK_Selector.h>
#include <SVTK_ViewModel.h>
SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( theModule );
if ( !mgr ) return;
//
- vtkFloatingPointType anRGBNd[3] = {1,1,1};
+ double anRGBNd[3] = {1,1,1};
SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
int aSizeNd = 10;
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
aSizeNd = f.pointSize();
}
//
- vtkFloatingPointType anRGBEl[3] = {0,1,0};
+ double anRGBEl[3] = {0,1,0};
SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
int aSizeEl = 12;
SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
if ( mgr->hasValue( "SMESH", "numbering_elem_font" ) ) {
QFont f = mgr->fontValue( "SMESH", "numbering_elem_font" );
- if ( f.family() == "Arial" ) aFamilyEl = SMESH::FntArial;
+ if ( f.family() == "Arial" ) aFamilyEl = SMESH::FntArial;
else if ( f.family() == "Courier" ) aFamilyEl = SMESH::FntCourier;
else if ( f.family() == "Times" ) aFamilyEl = SMESH::FntTimes;
aBoldEl = f.bold();
foreach ( SUIT_ViewManager* vm, vmList ) {
QVector<SUIT_ViewWindow*> views = vm->getViews();
foreach ( SUIT_ViewWindow* vw, views ) {
- // update VTK viewer properties
- if ( SVTK_ViewWindow* aVtkView = GetVtkViewWindow( vw ) ) {
- // update actors
- vtkRenderer* aRenderer = aVtkView->getRenderer();
- VTK::ActorCollectionCopy aCopy( aRenderer->GetActors() );
- vtkActorCollection* aCollection = aCopy.GetActors();
- aCollection->InitTraversal();
- while ( vtkActor* anAct = aCollection->GetNextActor() ) {
- if ( SMESH_NodeLabelActor* anActor = dynamic_cast< SMESH_NodeLabelActor* >( anAct ) ) {
- anActor->SetFontProperties( aFamilyNd, aSizeNd, aBoldNd, anItalicNd, aShadowNd, anRGBNd[0], anRGBNd[1], anRGBNd[2] );
- }
- else if ( SMESH_CellLabelActor* anActor = dynamic_cast< SMESH_CellLabelActor* >( anAct ) ) {
- anActor->SetFontProperties( aFamilyEl, aSizeEl, aBoldEl, anItalicEl, aShadowEl, anRGBEl[0], anRGBEl[1], anRGBEl[2] );
- }
- }
- aVtkView->Repaint( false );
- }
+ // update VTK viewer properties
+ if ( SVTK_ViewWindow* aVtkView = GetVtkViewWindow( vw ) ) {
+ // update actors
+ vtkRenderer* aRenderer = aVtkView->getRenderer();
+ VTK::ActorCollectionCopy aCopy( aRenderer->GetActors() );
+ vtkActorCollection* aCollection = aCopy.GetActors();
+ aCollection->InitTraversal();
+ while ( vtkActor* anAct = aCollection->GetNextActor() ) {
+ if ( SMESH_NodeLabelActor* anActor = dynamic_cast< SMESH_NodeLabelActor* >( anAct ) ) {
+ anActor->SetFontProperties( aFamilyNd, aSizeNd, aBoldNd, anItalicNd, aShadowNd, anRGBNd[0], anRGBNd[1], anRGBNd[2] );
+ }
+ else if ( SMESH_CellLabelActor* anActor = dynamic_cast< SMESH_CellLabelActor* >( anAct ) ) {
+ anActor->SetFontProperties( aFamilyEl, aSizeEl, aBoldEl, anItalicEl, aShadowEl, anRGBEl[0], anRGBEl[1], anRGBEl[2] );
+ }
+ }
+ aVtkView->Repaint( false );
+ }
}
}
}
//----------------------------------------------------------------------------
// internal function
- void ComputeBoundsParam( vtkFloatingPointType theBounds[6],
- vtkFloatingPointType theDirection[3],
- vtkFloatingPointType theMinPnt[3],
- vtkFloatingPointType& theMaxBoundPrj,
- vtkFloatingPointType& theMinBoundPrj )
+ void ComputeBoundsParam( double theBounds[6],
+ double theDirection[3],
+ double theMinPnt[3],
+ double& theMaxBoundPrj,
+ double& theMinBoundPrj )
{
//Enlarge bounds in order to avoid conflicts of precision
for(int i = 0; i < 6; i += 2){
static double EPS = 1.0E-3;
- vtkFloatingPointType aDelta = (theBounds[i+1] - theBounds[i])*EPS;
+ double aDelta = (theBounds[i+1] - theBounds[i])*EPS;
theBounds[i] -= aDelta;
theBounds[i+1] += aDelta;
}
- vtkFloatingPointType aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
+ double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
{theBounds[1],theBounds[2],theBounds[4]},
{theBounds[0],theBounds[3],theBounds[4]},
{theBounds[1],theBounds[3],theBounds[4]},
theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
theMinBoundPrj = theMaxBoundPrj;
for(int i = 1; i < 8; i++){
- vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
+ double aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
if(theMaxBoundPrj < aTmp){
theMaxBoundPrj = aTmp;
aMaxId = i;
theMinBoundPrj = aTmp;
}
}
- vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId];
+ double *aMinPnt = aBoundPoints[aMaxId];
theMinPnt[0] = aMinPnt[0];
theMinPnt[1] = aMinPnt[1];
theMinPnt[2] = aMinPnt[2];
}
// internal function
- void DistanceToPosition( vtkFloatingPointType theBounds[6],
- vtkFloatingPointType theDirection[3],
- vtkFloatingPointType theDist,
- vtkFloatingPointType thePos[3] )
+ void DistanceToPosition( double theBounds[6],
+ double theDirection[3],
+ double theDist,
+ double thePos[3] )
{
- vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
+ double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
- vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
+ double aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
}
// internal function (currently unused, left just in case)
- void PositionToDistance( vtkFloatingPointType theBounds[6],
- vtkFloatingPointType theDirection[3],
- vtkFloatingPointType thePos[3],
- vtkFloatingPointType& theDist )
+ void PositionToDistance( double theBounds[6],
+ double theDirection[3],
+ double thePos[3],
+ double& theDist )
{
- vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
+ double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
- vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos);
+ double aPrj = vtkMath::Dot(theDirection,thePos);
theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
}
bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
- vtkFloatingPointType theNormal[3],
- vtkFloatingPointType theDist,
- vtkFloatingPointType theBounds[6],
- vtkFloatingPointType theOrigin[3] )
+ double theNormal[3],
+ double theDist,
+ double theBounds[6],
+ double theOrigin[3] )
+ {
+ bool anIsOk = false;
+ anIsOk = ComputeBounds( theActorList, theBounds );
+
+
+ if( !anIsOk )
+ return false;
+
+ DistanceToPosition( theBounds, theNormal, theDist, theOrigin );
+ return true;
+ }
+
+ bool ComputeBounds( std::list<vtkActor*> theActorList,
+ double theBounds[6])
{
bool anIsOk = false;
theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;
for( ; anIter != theActorList.end(); anIter++ ) {
if( vtkActor* aVTKActor = *anIter ) {
if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) ) {
- vtkFloatingPointType aBounds[6];
+ double aBounds[6];
anActor->GetUnstructuredGrid()->GetBounds( aBounds );
theBounds[0] = std::min( theBounds[0], aBounds[0] );
theBounds[1] = std::max( theBounds[1], aBounds[1] );
}
}
}
-
- if( !anIsOk )
- return false;
-
- DistanceToPosition( theBounds, theNormal, theDist, theOrigin );
- return true;
+ return anIsOk;
}
#ifndef DISABLE_PLOT2DVIEWER
