src/OBJECT/SMESH_Actor.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  SMESH OBJECT : interactive object for SMESH visualization
  23 //  File   : SMESH_Actor.cxx
  24 //  Author : Nicolas REJNERI
  25 //  Module : SMESH
  26
  27
  28 #include "SMESH_ActorDef.h"
  29 #include "SMESH_ActorUtils.h"
  30 #include "SMESH_DeviceActor.h"
  31 #include "SMESH_ObjectDef.h"
  32 #include "SMESH_ControlsDef.hxx"
  33 #include "VTKViewer_ExtractUnstructuredGrid.h"
  34 #include "VTKViewer_FramedTextActor.h"
  35 #include "SALOME_InteractiveObject.hxx"
  36
  37 #include "SUIT_Session.h"
  38 #include "SUIT_ResourceMgr.h"
  39
  40 #include <vtkProperty.h>
  41 #include <vtkTimeStamp.h>
  42 #include <vtkObjectFactory.h>
  43 #include <vtkShrinkPolyData.h>
  44 #include <vtkMergeFilter.h>
  45
  46 #include <vtkMatrix4x4.h>
  47 #include <vtkUnstructuredGrid.h>
  48 #include <vtkPointData.h>
  49 #include <vtkCellData.h>
  50
  51 #include <vtkMapper.h>
  52 #include <vtkRenderer.h>
  53
  54 #include <vtkCell.h>
  55 #include <vtkIdList.h>
  56 #include <vtkIntArray.h>
  57
  58 #include <vtkActor2D.h>
  59 #include <vtkProperty2D.h>
  60 #include <vtkPolyData.h>
  61 #include <vtkMaskPoints.h>
  62 #include <vtkCellCenters.h>
  63 #include <vtkTextProperty.h>
  64 #include <vtkLabeledDataMapper.h>
  65 #include <vtkSelectVisiblePoints.h>
  66
  67 #include <vtkScalarBarActor.h>
  68 #include <vtkLookupTable.h>
  69
  70 #include <vtkMath.h>
  71 #include <vtkPlane.h>
  72 #include <vtkImplicitBoolean.h>
  73 #include <vtkImplicitFunctionCollection.h>
  74
  75 #include <vtkConfigure.h>
  76 #if !defined(VTK_XVERSION)
  77 #define VTK_XVERSION (VTK_MAJOR_VERSION<<16)+(VTK_MINOR_VERSION<<8)+(VTK_BUILD_VERSION)
  78 #endif
  79
  80 #include "utilities.h"
  81
  82 #ifdef _DEBUG_
  83 static int MYDEBUG = 1;
  84 #else
  85 static int MYDEBUG = 0;
  86 #endif
  87
  88 static int aLineWidthInc = 2;
  89 static int aPointSizeInc = 2;
  90
  91
  92 SMESH_ActorDef* SMESH_ActorDef::New(){
  93   return new SMESH_ActorDef();
  94 }
  95
  96
  97 SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj,
  98                               const char* theEntry,
  99                               const char* theName,
 100                               int theIsClear)
 101 {
 102   SMESH_ActorDef* anActor = SMESH_ActorDef::New();
 103   if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){
 104     anActor->Delete();
 105     anActor = NULL;
 106   }
 107   if( anActor )
 108     anActor->UpdateScalarBar();
 109   return anActor;
 110 }
 111
 112
 113 SMESH_ActorDef::SMESH_ActorDef()
 114 {
 115   if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
 116
 117   myTimeStamp = vtkTimeStamp::New();
 118
 119   myIsPointsVisible = false;
 120
 121   myIsShrinkable = false;
 122   myIsShrunk = false;
 123
 124   myIsFacesOriented = false;
 125
 126   myControlsPrecision = -1;
 127   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
 128
 129   if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
 130     myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
 131
 132   vtkFloatingPointType aPointSize  = SMESH::GetFloat("SMESH:node_size",3);
 133   vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
 134   vtkFloatingPointType aLineWidth  = SMESH::GetFloat("SMESH:element_width",1);
 135
 136   vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
 137   VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
 138
 139   //Definition 2D and 3D devices of the actor
 140   //-----------------------------------------
 141   vtkFloatingPointType anRGB[3] = {1,1,1};
 142   mySurfaceProp = vtkProperty::New();
 143   SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
 144   mySurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
 145
 146   myBackSurfaceProp = vtkProperty::New();
 147   SMESH::GetColor( "SMESH", "backface_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 0, 255 ) );
 148   myBackSurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
 149
 150   my2DActor = SMESH_DeviceActor::New();
 151   my2DActor->SetUserMatrix(aMatrix);
 152   my2DActor->PickableOff();
 153   my2DActor->SetProperty(mySurfaceProp);
 154   my2DActor->SetBackfaceProperty(myBackSurfaceProp);
 155   my2DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
 156   aFilter = my2DActor->GetExtractUnstructuredGrid();
 157   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 158   aFilter->RegisterCellsWithType(VTK_TRIANGLE);
 159   aFilter->RegisterCellsWithType(VTK_POLYGON);
 160   aFilter->RegisterCellsWithType(VTK_QUAD);
 161   aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
 162   aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
 163
 164   my2DExtProp = vtkProperty::New();
 165   my2DExtProp->DeepCopy(mySurfaceProp);
 166   SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
 167   anRGB[0] = 1 - anRGB[0];
 168   anRGB[1] = 1 - anRGB[1];
 169   anRGB[2] = 1 - anRGB[2];
 170   my2DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 171
 172   my2DExtActor = SMESH_DeviceActor::New();
 173   my2DExtActor->SetUserMatrix(aMatrix);
 174   my2DExtActor->PickableOff();
 175   my2DExtActor->SetProperty(my2DExtProp);
 176   my2DExtActor->SetBackfaceProperty(my2DExtProp);
 177   my2DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
 178   aFilter = my2DExtActor->GetExtractUnstructuredGrid();
 179   aFilter->RegisterCellsWithType(VTK_TRIANGLE);
 180   aFilter->RegisterCellsWithType(VTK_POLYGON);
 181   aFilter->RegisterCellsWithType(VTK_QUAD);
 182   aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
 183   aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
 184
 185   my3DActor = SMESH_DeviceActor::New();
 186   my3DActor->SetUserMatrix(aMatrix);
 187   my3DActor->PickableOff();
 188   my3DActor->SetProperty(mySurfaceProp);
 189   my3DActor->SetBackfaceProperty(myBackSurfaceProp);
 190   my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
 191   aFilter = my3DActor->GetExtractUnstructuredGrid();
 192   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 193   aFilter->RegisterCellsWithType(VTK_TETRA);
 194   aFilter->RegisterCellsWithType(VTK_VOXEL);
 195   aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
 196   aFilter->RegisterCellsWithType(VTK_WEDGE);
 197   aFilter->RegisterCellsWithType(VTK_PYRAMID);
 198   aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
 199   aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
 200   aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
 201   aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
 202
 203   //Definition 1D device of the actor
 204   //---------------------------------
 205   myEdgeProp = vtkProperty::New();
 206   myEdgeProp->SetAmbient(1.0);
 207   myEdgeProp->SetDiffuse(0.0);
 208   myEdgeProp->SetSpecular(0.0);
 209   SMESH::GetColor( "SMESH", "outline_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
 210   myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 211   myEdgeProp->SetLineWidth(aLineWidth);
 212
 213   my1DActor = SMESH_DeviceActor::New();
 214   my1DActor->SetUserMatrix(aMatrix);
 215   my1DActor->PickableOff();
 216   my1DActor->SetHighlited(true);
 217   my1DActor->SetProperty(myEdgeProp);
 218   my1DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
 219   aFilter = my1DActor->GetExtractUnstructuredGrid();
 220   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 221   aFilter->RegisterCellsWithType(VTK_LINE);
 222   aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
 223
 224   my1DProp = vtkProperty::New();
 225   my1DProp->DeepCopy(myEdgeProp);
 226   my1DProp->SetLineWidth(aLineWidth + aLineWidthInc);
 227   my1DProp->SetPointSize(aPointSize);
 228
 229   my1DExtProp = vtkProperty::New();
 230   my1DExtProp->DeepCopy(myEdgeProp);
 231   anRGB[0] = 1 - anRGB[0];
 232   anRGB[1] = 1 - anRGB[1];
 233   anRGB[2] = 1 - anRGB[2];
 234   my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 235   my1DExtProp->SetLineWidth(aLineWidth + aLineWidthInc);
 236   my1DExtProp->SetPointSize(aPointSize + aPointSizeInc);
 237
 238   my1DExtActor = SMESH_DeviceActor::New();
 239   my1DExtActor->SetUserMatrix(aMatrix);
 240   my1DExtActor->PickableOff();
 241   my1DExtActor->SetHighlited(true);
 242   my1DExtActor->SetVisibility(false);
 243   my1DExtActor->SetProperty(my1DExtProp);
 244   my1DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
 245   aFilter = my1DExtActor->GetExtractUnstructuredGrid();
 246   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 247   aFilter->RegisterCellsWithType(VTK_LINE);
 248   aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
 249
 250
 251   //Definition 0D device of the actor (0d elements)
 252   //-----------------------------------------------
 253   my0DProp = vtkProperty::New();
 254   SMESH::GetColor( "SMESH", "elem0d_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) );
 255   my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 256   my0DProp->SetPointSize(aElem0DSize);
 257
 258   my0DActor = SMESH_DeviceActor::New();
 259   my0DActor->SetUserMatrix(aMatrix);
 260   my0DActor->SetStoreClippingMapping(true);
 261   my0DActor->PickableOff();
 262   my0DActor->SetVisibility(false);
 263   my0DActor->SetProperty(my0DProp);
 264   my0DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
 265   aFilter = my0DActor->GetExtractUnstructuredGrid();
 266   //aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
 267   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 268   aFilter->RegisterCellsWithType(VTK_VERTEX);
 269
 270   //my0DExtProp = vtkProperty::New();
 271   //my0DExtProp->DeepCopy(my0DProp);
 272   //anRGB[0] = 1 - anRGB[0];
 273   //anRGB[1] = 1 - anRGB[1];
 274   //anRGB[2] = 1 - anRGB[2];
 275   //my0DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 276   //my0DExtProp->SetPointSize(aElem0DSize);
 277   //
 278   //my0DExtActor = SMESH_DeviceActor::New();
 279   //my0DExtActor->SetUserMatrix(aMatrix);
 280   //my0DExtActor->SetStoreClippingMapping(true);
 281   //my0DExtActor->PickableOff();
 282   //my0DExtActor->SetHighlited(true);
 283   //my0DExtActor->SetVisibility(false);
 284   //my0DExtActor->SetProperty(my0DExtProp);
 285   //my0DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
 286   //aFilter = my0DExtActor->GetExtractUnstructuredGrid();
 287   ////aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
 288   //aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 289   //aFilter->RegisterCellsWithType(VTK_VERTEX);
 290
 291
 292   //Definition 0D device of the actor (nodes)
 293   //-----------------------------------------
 294   myNodeProp = vtkProperty::New();
 295   SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) );
 296   myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 297   myNodeProp->SetPointSize(aPointSize);
 298
 299   myNodeActor = SMESH_DeviceActor::New();
 300   myNodeActor->SetUserMatrix(aMatrix);
 301   myNodeActor->SetStoreClippingMapping(true);
 302   myNodeActor->PickableOff();
 303   myNodeActor->SetVisibility(false);
 304   myNodeActor->SetProperty(myNodeProp);
 305   myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
 306   aFilter = myNodeActor->GetExtractUnstructuredGrid();
 307   aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
 308
 309   myNodeExtProp = vtkProperty::New();
 310   myNodeExtProp->DeepCopy(myNodeProp);
 311   anRGB[0] = 1 - anRGB[0];
 312   anRGB[1] = 1 - anRGB[1];
 313   anRGB[2] = 1 - anRGB[2];
 314   myNodeExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 315   myNodeExtProp->SetPointSize(aPointSize);
 316
 317   myNodeExtActor = SMESH_DeviceActor::New();
 318   myNodeExtActor->SetUserMatrix(aMatrix);
 319   myNodeExtActor->SetStoreClippingMapping(true);
 320   myNodeExtActor->PickableOff();
 321   myNodeExtActor->SetHighlited(true);
 322   myNodeExtActor->SetVisibility(false);
 323   myNodeExtActor->SetProperty(myNodeExtProp);
 324   myNodeExtActor->SetRepresentation(SMESH_DeviceActor::ePoint);
 325   aFilter = myNodeExtActor->GetExtractUnstructuredGrid();
 326   aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
 327   aFilter->RegisterCellsWithType(VTK_VERTEX);
 328
 329   //Definition of Pickable and Highlitable engines
 330   //----------------------------------------------
 331
 332   myBaseActor = SMESH_DeviceActor::New();
 333   myBaseActor->SetUserMatrix(aMatrix);
 334   myBaseActor->SetStoreGemetryMapping(true);
 335   myBaseActor->GetProperty()->SetOpacity(0.0);
 336
 337   myPickableActor = myBaseActor;
 338
 339   myHighlightProp = vtkProperty::New();
 340   myHighlightProp->SetAmbient(1.0);
 341   myHighlightProp->SetDiffuse(0.0);
 342   myHighlightProp->SetSpecular(0.0);
 343   SMESH::GetColor( "SMESH", "selection_object_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
 344   myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 345   //myHighlightProp->SetPointSize(aPointSize);
 346   myHighlightProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ??
 347   myHighlightProp->SetRepresentation(1);
 348
 349   myPreselectProp = vtkProperty::New();
 350   myPreselectProp->SetAmbient(1.0);
 351   myPreselectProp->SetDiffuse(0.0);
 352   myPreselectProp->SetSpecular(0.0);
 353   SMESH::GetColor( "SMESH", "highlight_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 255 ) );
 354   myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
 355   //myPreselectProp->SetPointSize(aPointSize);
 356   myPreselectProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ??
 357   myPreselectProp->SetRepresentation(1);
 358
 359   myHighlitableActor = SMESH_DeviceActor::New();
 360   myHighlitableActor->SetUserMatrix(aMatrix);
 361   myHighlitableActor->PickableOff();
 362   myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
 363
 364   aMatrix->Delete();
 365
 366   myName = "";
 367   myIO = NULL;
 368
 369   myControlMode = eNone;
 370   myControlActor = my2DActor;
 371
 372   //Definition of myScalarBarActor
 373   //------------------------------
 374   myLookupTable = vtkLookupTable::New();
 375   //Fix for Bug PAL5195 - SMESH764:
 376   //Controls - Aspect Ratio: incorrect colors of the best and worst values
 377   myLookupTable->SetHueRange(0.667,0.0);
 378
 379   myScalarBarActor = vtkScalarBarActor::New();
 380   myScalarBarActor->SetVisibility(false);
 381   myScalarBarActor->SetLookupTable(myLookupTable);
 382
 383   //Fix for Bug 13314:
 384   //Incorrect "Min value" in Scalar Bar in Mesh:
 385   //  myScalarBarActor->SetLabelFormat("%.4g");
 386   // changes was commented because of regression bug IPAL 19981
 387
 388   mgr = SUIT_Session::session()->resourceMgr();
 389   if( !mgr )
 390     return;
 391
 392   //Definition of points numbering pipeline
 393   //---------------------------------------
 394   myPointsNumDataSet = vtkUnstructuredGrid::New();
 395
 396   myPtsMaskPoints = vtkMaskPoints::New();
 397   myPtsMaskPoints->SetInput(myPointsNumDataSet);
 398   myPtsMaskPoints->SetOnRatio(1);
 399
 400   myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
 401   myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput());
 402   myPtsSelectVisiblePoints->SelectInvisibleOff();
 403   myPtsSelectVisiblePoints->SetTolerance(0.1);
 404
 405   myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
 406   myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
 407 #if (VTK_XVERSION < 0x050200)
 408   myPtsLabeledDataMapper->SetLabelFormat("%g");
 409 #endif
 410   myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
 411
 412   vtkTextProperty* aPtsTextProp = vtkTextProperty::New();
 413   aPtsTextProp->SetFontFamilyToTimes();
 414   static int aPointsFontSize = 10;
 415   aPtsTextProp->SetFontSize(aPointsFontSize);
 416   aPtsTextProp->SetBold(1);
 417   aPtsTextProp->SetItalic(0);
 418   aPtsTextProp->SetShadow(0);
 419   myPtsLabeledDataMapper->SetLabelTextProperty(aPtsTextProp);
 420   aPtsTextProp->Delete();
 421
 422   myEntityMode = eAllEntity;
 423
 424   myIsPointsLabeled = false;
 425
 426   myPointLabels = vtkActor2D::New();
 427   myPointLabels->SetMapper(myPtsLabeledDataMapper);
 428   myPointLabels->GetProperty()->SetColor(1,1,1);
 429   myPointLabels->SetVisibility(myIsPointsLabeled);
 430
 431
 432   //Definition of cells numbering pipeline
 433   //---------------------------------------
 434   myCellsNumDataSet = vtkUnstructuredGrid::New();
 435
 436   myCellCenters = vtkCellCenters::New();
 437   myCellCenters->SetInput(myCellsNumDataSet);
 438
 439   myClsMaskPoints = vtkMaskPoints::New();
 440   myClsMaskPoints->SetInput(myCellCenters->GetOutput());
 441   myClsMaskPoints->SetOnRatio(1);
 442
 443   myClsSelectVisiblePoints = vtkSelectVisiblePoints::New();
 444   myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput());
 445   myClsSelectVisiblePoints->SelectInvisibleOff();
 446   myClsSelectVisiblePoints->SetTolerance(0.1);
 447
 448   myClsLabeledDataMapper = vtkLabeledDataMapper::New();
 449   myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
 450 #if (VTK_XVERSION < 0x050200)
 451   myClsLabeledDataMapper->SetLabelFormat("%g");
 452 #endif
 453   myClsLabeledDataMapper->SetLabelModeToLabelScalars();
 454
 455   vtkTextProperty* aClsTextProp = vtkTextProperty::New();
 456   aClsTextProp->SetFontFamilyToTimes();
 457   static int aCellsFontSize = 12;
 458   aClsTextProp->SetFontSize(aCellsFontSize);
 459   aClsTextProp->SetBold(1);
 460   aClsTextProp->SetItalic(0);
 461   aClsTextProp->SetShadow(0);
 462   myClsLabeledDataMapper->SetLabelTextProperty(aClsTextProp);
 463   aClsTextProp->Delete();
 464
 465   myIsCellsLabeled = false;
 466
 467   myCellsLabels = vtkActor2D::New();
 468   myCellsLabels->SetMapper(myClsLabeledDataMapper);
 469   myCellsLabels->GetProperty()->SetColor(0,1,0);
 470   myCellsLabels->SetVisibility(myIsCellsLabeled);
 471
 472   // Clipping planes
 473   myImplicitBoolean = vtkImplicitBoolean::New();
 474   myImplicitBoolean->SetOperationTypeToIntersection();
 475
 476
 477
 478   //Quadratic 2D elements representation
 479   //-----------------------------------------------------------------------------
 480   int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0);
 481   if(aQuadratic2DMode == 0){
 482     myHighlitableActor->SetQuadraticArcMode(false);
 483     my2DActor->SetQuadraticArcMode(false);
 484     my1DActor->SetQuadraticArcMode(false);
 485   }
 486   else if(aQuadratic2DMode == 1){
 487     myHighlitableActor->SetQuadraticArcMode(true);
 488     my2DActor->SetQuadraticArcMode(true);
 489     my1DActor->SetQuadraticArcMode(true);
 490   }
 491
 492   int aQuadraticAngle = mgr->integerValue( "SMESH", "max_angle", 2);
 493   myHighlitableActor->SetQuadraticArcAngle(aQuadraticAngle);
 494   my2DActor->SetQuadraticArcAngle(aQuadraticAngle);
 495
 496   // Set color of the name actor
 497   SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
 498   myNameActor->SetBackgroundColor(anRGB[0], anRGB[1], anRGB[2]);
 499 }
 500
 501
 502 SMESH_ActorDef::~SMESH_ActorDef()
 503 {
 504   if(MYDEBUG) MESSAGE("~SMESH_ActorDef - "<<this);
 505
 506   myScalarBarActor->Delete();
 507   myLookupTable->Delete();
 508
 509   mySurfaceProp->Delete();
 510   myBackSurfaceProp->Delete();
 511
 512   myEdgeProp->Delete();
 513   myHighlightProp->Delete();
 514   myPreselectProp->Delete();
 515
 516   myNodeProp->Delete();
 517   myNodeExtProp->Delete();
 518
 519   my0DProp->Delete();
 520   my0DActor->Delete();
 521
 522   //my0DExtProp->Delete();
 523   //my0DExtActor->Delete();
 524
 525   my1DProp->Delete();
 526   my1DActor->Delete();
 527
 528   my1DExtProp->Delete();
 529   my1DExtActor->Delete();
 530
 531   my2DActor->Delete();
 532   my2DExtProp->Delete();
 533   my2DExtActor->Delete();
 534   my3DActor->Delete();
 535
 536   myNodeActor->Delete();
 537   myBaseActor->Delete();
 538
 539   myNodeExtActor->Delete();
 540
 541   myHighlitableActor->Delete();
 542
 543   //Deleting of points numbering pipeline
 544   //---------------------------------------
 545   myPointsNumDataSet->Delete();
 546
 547   // commented: porting to vtk 5.0
 548   //  myPtsLabeledDataMapper->RemoveAllInputs();
 549   myPtsLabeledDataMapper->Delete();
 550
 551   // commented: porting to vtk 5.0
 552   //  myPtsSelectVisiblePoints->UnRegisterAllOutputs();
 553   myPtsSelectVisiblePoints->Delete();
 554
 555   // commented: porting to vtk 5.0
 556   //  myPtsMaskPoints->UnRegisterAllOutputs();
 557   myPtsMaskPoints->Delete();
 558
 559   myPointLabels->Delete();
 560
 561
 562   //Deleting of cells numbering pipeline
 563   //---------------------------------------
 564   myCellsNumDataSet->Delete();
 565
 566   myClsLabeledDataMapper->RemoveAllInputs();
 567   myClsLabeledDataMapper->Delete();
 568
 569   // commented: porting to vtk 5.0
 570   //  myClsSelectVisiblePoints->UnRegisterAllOutputs();
 571   myClsSelectVisiblePoints->Delete();
 572
 573   // commented: porting to vtk 5.0
 574   //  myClsMaskPoints->UnRegisterAllOutputs();
 575   myClsMaskPoints->Delete();
 576
 577   // commented: porting to vtk 5.0
 578   //  myCellCenters->UnRegisterAllOutputs();
 579   myCellCenters->Delete();
 580
 581   myCellsLabels->Delete();
 582
 583   myImplicitBoolean->Delete();
 584
 585   myTimeStamp->Delete();
 586 }
 587
 588
 589 void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
 590 {
 591   vtkUnstructuredGrid* aGrid = GetUnstructuredGrid();
 592
 593   myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints();
 594
 595   if ( myIsPointsLabeled )
 596   {
 597     myPointsNumDataSet->ShallowCopy(aGrid);
 598     vtkDataSet *aDataSet = myPointsNumDataSet;
 599
 600     int aNbElem = aDataSet->GetNumberOfPoints();
 601
 602     vtkIntArray *anArray = vtkIntArray::New();
 603     anArray->SetNumberOfValues( aNbElem );
 604
 605     for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
 606     {
 607       int aSMDSId = myVisualObj->GetNodeObjId( anId );
 608       anArray->SetValue( anId, aSMDSId );
 609     }
 610
 611     aDataSet->GetPointData()->SetScalars( anArray );
 612     anArray->Delete();
 613     myPtsMaskPoints->SetInput( aDataSet );
 614     myPointLabels->SetVisibility( GetVisibility() );
 615   }
 616   else
 617   {
 618     myPointLabels->SetVisibility( false );
 619   }
 620   SetRepresentation(GetRepresentation());
 621   myTimeStamp->Modified();
 622 }
 623
 624
 625 void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled)
 626 {
 627   vtkUnstructuredGrid* aGrid = GetUnstructuredGrid();
 628   myIsCellsLabeled = theIsCellsLabeled && aGrid->GetNumberOfPoints();
 629   if(myIsCellsLabeled){
 630     myCellsNumDataSet->ShallowCopy(aGrid);
 631     vtkDataSet *aDataSet = myCellsNumDataSet;
 632     int aNbElem = aDataSet->GetNumberOfCells();
 633     vtkIntArray *anArray = vtkIntArray::New();
 634     anArray->SetNumberOfValues(aNbElem);
 635     for(int anId = 0; anId < aNbElem; anId++){
 636       int aSMDSId = myVisualObj->GetElemObjId(anId);
 637       anArray->SetValue(anId,aSMDSId);
 638     }
 639     aDataSet->GetCellData()->SetScalars(anArray);
 640     myCellCenters->SetInput(aDataSet);
 641     myCellsLabels->SetVisibility(GetVisibility());
 642   }else{
 643     myCellsLabels->SetVisibility(false);
 644   }
 645   myTimeStamp->Modified();
 646 }
 647
 648
 649 void SMESH_ActorDef::SetFacesOriented(bool theIsFacesOriented)
 650 {
 651   myIsFacesOriented = theIsFacesOriented;
 652
 653   my2DActor->SetFacesOriented(theIsFacesOriented);
 654   my3DActor->SetFacesOriented(theIsFacesOriented);
 655
 656   myTimeStamp->Modified();
 657 }
 658
 659 bool SMESH_ActorDef::GetFacesOriented()
 660 {
 661   return myIsFacesOriented;
 662 }
 663
 664 void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType theColor[3])
 665 {
 666   my2DActor->SetFacesOrientationColor( theColor );
 667   my3DActor->SetFacesOrientationColor( theColor );
 668 }
 669
 670 void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType theColor[3])
 671 {
 672   my3DActor->GetFacesOrientationColor( theColor );
 673 }
 674
 675 void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale)
 676 {
 677   my2DActor->SetFacesOrientationScale( theScale );
 678   my3DActor->SetFacesOrientationScale( theScale );
 679 }
 680
 681 vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale()
 682 {
 683   return my3DActor->GetFacesOrientationScale();
 684 }
 685
 686 void SMESH_ActorDef::SetFacesOrientation3DVectors(bool theState)
 687 {
 688   my2DActor->SetFacesOrientation3DVectors( theState );
 689   my3DActor->SetFacesOrientation3DVectors( theState );
 690 }
 691
 692 bool SMESH_ActorDef::GetFacesOrientation3DVectors()
 693 {
 694   return my3DActor->GetFacesOrientation3DVectors();
 695 }
 696
 697
 698 void
 699 SMESH_ActorDef::
 700 SetControlMode(eControl theMode)
 701 {
 702   SetControlMode(theMode,true);
 703 }
 704
 705
 706 void
 707 SMESH_ActorDef::
 708 SetControlMode(eControl theMode,
 709                bool theCheckEntityMode)
 710 {
 711   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
 712   if( !mgr )
 713     return;
 714
 715   myControlMode = eNone;
 716   theCheckEntityMode &= mgr->booleanValue( "SMESH", "display_entity", false );
 717
 718   my0DActor->GetMapper()->SetScalarVisibility(false);
 719   my1DActor->GetMapper()->SetScalarVisibility(false);
 720   my2DActor->GetMapper()->SetScalarVisibility(false);
 721   my3DActor->GetMapper()->SetScalarVisibility(false);
 722   myScalarBarActor->SetVisibility(false);
 723
 724   bool anIsScalarVisible = theMode > eNone;
 725
 726   if(anIsScalarVisible){
 727     SMESH::Controls::FunctorPtr aFunctor;
 728     switch(theMode){
 729     case eLength:
 730     {
 731       SMESH::Controls::Length* aControl = new SMESH::Controls::Length();
 732       aControl->SetPrecision( myControlsPrecision );
 733       aFunctor.reset( aControl );
 734       myControlActor = my1DActor;
 735       break;
 736     }
 737     case eLength2D:
 738     {
 739       aFunctor.reset(new SMESH::Controls::Length2D());
 740       myControlActor = my2DActor;
 741       break;
 742     }
 743     case eFreeBorders:
 744       aFunctor.reset(new SMESH::Controls::FreeBorders());
 745       myControlActor = my1DActor;
 746       break;
 747     case eFreeEdges:
 748       aFunctor.reset(new SMESH::Controls::FreeEdges());
 749       myControlActor = my2DActor;
 750       break;
 751     case eFreeNodes:
 752       aFunctor.reset(new SMESH::Controls::FreeNodes());
 753       myControlActor = myNodeActor;
 754       break;
 755     case eFreeFaces:
 756       aFunctor.reset(new SMESH::Controls::FreeFaces());
 757       myControlActor = my2DActor;
 758       break;
 759     case eMultiConnection:
 760       aFunctor.reset(new SMESH::Controls::MultiConnection());
 761       myControlActor = my1DActor;
 762       break;
 763     case eMultiConnection2D:
 764       aFunctor.reset(new SMESH::Controls::MultiConnection2D());
 765       myControlActor = my2DActor;
 766       break;
 767     case eArea:
 768     {
 769       SMESH::Controls::Area* aControl = new SMESH::Controls::Area();
 770       aControl->SetPrecision( myControlsPrecision );
 771       aFunctor.reset( aControl );
 772       myControlActor = my2DActor;
 773       break;
 774     }
 775     case eTaper:
 776     {
 777       SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper();
 778       aControl->SetPrecision( myControlsPrecision );
 779       aFunctor.reset( aControl );
 780       myControlActor = my2DActor;
 781       break;
 782     }
 783     case eAspectRatio:
 784     {
 785       SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio();
 786       aControl->SetPrecision( myControlsPrecision );
 787       aFunctor.reset( aControl );
 788       myControlActor = my2DActor;
 789       break;
 790     }
 791     case eAspectRatio3D:
 792     {
 793       SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D();
 794       aControl->SetPrecision( myControlsPrecision );
 795       aFunctor.reset( aControl );
 796       myControlActor = my3DActor;
 797       break;
 798     }
 799     case eVolume3D:
 800     {
 801       SMESH::Controls::Volume* aControl = new SMESH::Controls::Volume();
 802       aControl->SetPrecision( myControlsPrecision );
 803       aFunctor.reset( aControl );
 804       myControlActor = my3DActor;
 805       break;
 806     }
 807     case eMinimumAngle:
 808     {
 809       SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle();
 810       aControl->SetPrecision( myControlsPrecision );
 811       aFunctor.reset( aControl );
 812       myControlActor = my2DActor;
 813       break;
 814     }
 815     case eWarping:
 816     {
 817       SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping();
 818       aControl->SetPrecision( myControlsPrecision );
 819       aFunctor.reset( aControl );
 820       myControlActor = my2DActor;
 821       break;
 822     }
 823     case eSkew:
 824     {
 825       SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew();
 826       aControl->SetPrecision( myControlsPrecision );
 827       aFunctor.reset( aControl );
 828       myControlActor = my2DActor;
 829       break;
 830     }
 831     default:
 832       return;
 833     }
 834
 835     vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid();
 836     vtkIdType aNbCells = aGrid->GetNumberOfCells();
 837     if(aNbCells){
 838       myControlMode = theMode;
 839       switch(myControlMode){
 840       case eFreeNodes:
 841         myNodeExtActor->SetExtControlMode(aFunctor);
 842         break;
 843       case eFreeEdges:
 844       case eFreeBorders:
 845         my1DExtActor->SetExtControlMode(aFunctor);
 846         break;
 847       case eFreeFaces:
 848         my2DExtActor->SetExtControlMode(aFunctor);
 849         break;
 850       case eLength2D:
 851       case eMultiConnection2D:
 852         my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable);
 853         break;
 854       default:
 855         myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable);
 856       }
 857     }
 858
 859     if(theCheckEntityMode){
 860       if(myControlActor == my1DActor)
 861         SetEntityMode(eEdges);
 862       else if(myControlActor == my2DActor){
 863         switch(myControlMode){
 864         case eLength2D:
 865         case eFreeEdges:
 866         case eFreeFaces:
 867         case eMultiConnection2D:
 868           //SetEntityMode(eEdges);
 869           SetEntityMode(eFaces);
 870           break;
 871         default:
 872           SetEntityMode(eFaces);
 873         }
 874       }else if(myControlActor == my3DActor)
 875         SetEntityMode(eVolumes);
 876     }
 877
 878   }else if(theCheckEntityMode){
 879     myEntityMode = eAllEntity;
 880   }
 881
 882   SetRepresentation(GetRepresentation());
 883
 884   myTimeStamp->Modified();
 885   Modified();
 886 }
 887
 888
 889 void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
 890   SALOME_Actor::AddToRender(theRenderer);
 891
 892   theRenderer->AddActor(myNodeActor);
 893   theRenderer->AddActor(myBaseActor);
 894
 895   theRenderer->AddActor(myNodeExtActor);
 896
 897   my3DActor->AddToRender(theRenderer);
 898   my2DActor->AddToRender(theRenderer);
 899   my2DExtActor->AddToRender(theRenderer);
 900
 901   theRenderer->AddActor(my1DActor);
 902   theRenderer->AddActor(my1DExtActor);
 903
 904   theRenderer->AddActor(my0DActor);
 905   //theRenderer->AddActor(my0DExtActor);
 906
 907   theRenderer->AddActor(myHighlitableActor);
 908
 909   theRenderer->AddActor2D(myScalarBarActor);
 910
 911   myPtsSelectVisiblePoints->SetRenderer(theRenderer);
 912   myClsSelectVisiblePoints->SetRenderer(theRenderer);
 913
 914   theRenderer->AddActor2D(myPointLabels);
 915   theRenderer->AddActor2D(myCellsLabels);
 916 }
 917
 918 void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){
 919   SALOME_Actor::RemoveFromRender(theRenderer);
 920
 921   theRenderer->RemoveActor(myNodeActor);
 922   theRenderer->RemoveActor(myBaseActor);
 923
 924   theRenderer->RemoveActor(myNodeExtActor);
 925
 926   theRenderer->RemoveActor(myHighlitableActor);
 927
 928   theRenderer->RemoveActor(my0DActor);
 929   //theRenderer->RemoveActor(my0DExtActor);
 930
 931   theRenderer->RemoveActor(my1DActor);
 932   theRenderer->RemoveActor(my1DExtActor);
 933
 934   my2DActor->RemoveFromRender(theRenderer);
 935   my2DExtActor->RemoveFromRender(theRenderer);
 936   my3DActor->RemoveFromRender(theRenderer);
 937
 938   theRenderer->RemoveActor(myScalarBarActor);
 939   theRenderer->RemoveActor(myPointLabels);
 940   theRenderer->RemoveActor(myCellsLabels);
 941 }
 942
 943
 944 bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
 945                           const char* theEntry,
 946                           const char* theName,
 947                           int theIsClear)
 948 {
 949   Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName);
 950   setIO(anIO);
 951   setName(theName);
 952
 953   myVisualObj = theVisualObj;
 954   myVisualObj->Update(theIsClear);
 955
 956   myNodeActor->Init(myVisualObj,myImplicitBoolean);
 957   myBaseActor->Init(myVisualObj,myImplicitBoolean);
 958
 959   myHighlitableActor->Init(myVisualObj,myImplicitBoolean);
 960
 961   myNodeExtActor->Init(myVisualObj,myImplicitBoolean);
 962
 963   my0DActor->Init(myVisualObj,myImplicitBoolean);
 964   //my0DExtActor->Init(myVisualObj,myImplicitBoolean);
 965
 966   my1DActor->Init(myVisualObj,myImplicitBoolean);
 967   my1DExtActor->Init(myVisualObj,myImplicitBoolean);
 968
 969   my2DActor->Init(myVisualObj,myImplicitBoolean);
 970   my2DExtActor->Init(myVisualObj,myImplicitBoolean);
 971   my3DActor->Init(myVisualObj,myImplicitBoolean);
 972
 973   my0DActor->GetMapper()->SetLookupTable(myLookupTable);
 974   //my0DExtActor->GetMapper()->SetLookupTable(myLookupTable);
 975
 976   my1DActor->GetMapper()->SetLookupTable(myLookupTable);
 977   my1DExtActor->GetMapper()->SetLookupTable(myLookupTable);
 978
 979   my2DActor->GetMapper()->SetLookupTable(myLookupTable);
 980   my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
 981   my3DActor->GetMapper()->SetLookupTable(myLookupTable);
 982
 983   vtkFloatingPointType aFactor, aUnits;
 984   my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
 985   my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
 986   my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
 987
 988   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
 989   if( !mgr )
 990     return false;
 991
 992   //SetIsShrunkable(theGrid->GetNumberOfCells() > 10);
 993   SetIsShrunkable(true);
 994
 995   SetShrinkFactor( SMESH::GetFloat( "SMESH:shrink_coeff", 75 ) / 100. );
 996
 997   int aMode = mgr->integerValue( "SMESH", "display_mode" );
 998   SetRepresentation(-1);
 999
1000   if(aMode == 0){
1001     SetRepresentation(eEdge);
1002   }else if(aMode == 1){
1003     SetRepresentation(eSurface);
1004   }else if(aMode == 2){
1005     SetRepresentation(ePoint);
1006   }
1007
1008   if(aMode == 3){
1009     SetShrink();
1010   }
1011
1012   if( dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
1013     SetIsDisplayNameActor( true );
1014
1015   myTimeStamp->Modified();
1016   Modified();
1017   return true;
1018 }
1019
1020
1021 vtkFloatingPointType* SMESH_ActorDef::GetBounds(){
1022   return myNodeActor->GetBounds();
1023 }
1024
1025
1026 vtkDataSet* SMESH_ActorDef::GetInput(){
1027   return GetUnstructuredGrid();
1028 }
1029
1030
1031 void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){
1032   Superclass::SetTransform(theTransform);
1033
1034   myNodeActor->SetTransform(theTransform);
1035   myBaseActor->SetTransform(theTransform);
1036
1037   myHighlitableActor->SetTransform(theTransform);
1038
1039   myNodeExtActor->SetTransform(theTransform);
1040
1041   my0DActor->SetTransform(theTransform);
1042   //my0DExtActor->SetTransform(theTransform);
1043
1044   my1DActor->SetTransform(theTransform);
1045   my1DExtActor->SetTransform(theTransform);
1046
1047   my2DActor->SetTransform(theTransform);
1048   my2DExtActor->SetTransform(theTransform);
1049   my3DActor->SetTransform(theTransform);
1050
1051   Modified();
1052 }
1053
1054
1055 void SMESH_ActorDef::SetMapper(vtkMapper* theMapper){
1056   vtkLODActor::SetMapper(theMapper);
1057 }
1058
1059
1060 void SMESH_ActorDef::ShallowCopy(vtkProp *prop){
1061   SALOME_Actor::ShallowCopy(prop);
1062 }
1063
1064
1065 vtkMapper* SMESH_ActorDef::GetMapper(){
1066   return myPickableActor->GetMapper();
1067 }
1068
1069
1070 vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid(){
1071   return myVisualObj->GetUnstructuredGrid();
1072 }
1073
1074
1075 bool SMESH_ActorDef::IsInfinitive(){
1076   vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
1077   aDataSet->Update();
1078   myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
1079     ( aDataSet->GetNumberOfCells() == 1 &&
1080     aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
1081   return SALOME_Actor::IsInfinitive();
1082 }
1083
1084
1085 void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
1086   if ( myIsShrinkable == theShrunkable )
1087     return;
1088   myIsShrinkable = theShrunkable;
1089   Modified();
1090 }
1091
1092 vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){
1093   return myBaseActor->GetShrinkFactor();
1094 }
1095
1096 void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){
1097   myBaseActor->SetShrinkFactor(theValue);
1098
1099   my1DActor->SetShrinkFactor(theValue);
1100   my1DExtActor->SetShrinkFactor(theValue);
1101
1102   my2DActor->SetShrinkFactor(theValue);
1103   my2DExtActor->SetShrinkFactor(theValue);
1104   my3DActor->SetShrinkFactor(theValue);
1105
1106   Modified();
1107 }
1108
1109 void SMESH_ActorDef::SetShrink(){
1110   if(!myIsShrinkable) return;
1111
1112   myBaseActor->SetShrink();
1113
1114   my1DActor->SetShrink();
1115   my1DExtActor->SetShrink();
1116
1117   my2DActor->SetShrink();
1118   my2DExtActor->SetShrink();
1119   my3DActor->SetShrink();
1120
1121   myIsShrunk = true;
1122   Modified();
1123 }
1124
1125 void SMESH_ActorDef::UnShrink(){
1126   if(!myIsShrunk) return;
1127
1128   myBaseActor->UnShrink();
1129
1130   my1DActor->UnShrink();
1131   my1DExtActor->UnShrink();
1132
1133   my2DActor->UnShrink();
1134   my2DExtActor->UnShrink();
1135   my3DActor->UnShrink();
1136
1137   myIsShrunk = false;
1138   Modified();
1139 }
1140
1141
1142 int SMESH_ActorDef::GetNodeObjId(int theVtkID){
1143   return myPickableActor->GetNodeObjId(theVtkID);
1144 }
1145
1146 vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){
1147   return myPickableActor->GetNodeCoord(theObjID);
1148 }
1149
1150
1151 int SMESH_ActorDef::GetElemObjId(int theVtkID){
1152   return myPickableActor->GetElemObjId(theVtkID);
1153 }
1154
1155 vtkCell* SMESH_ActorDef::GetElemCell(int theObjID){
1156   return myPickableActor->GetElemCell(theObjID);
1157 }
1158
1159
1160 void SMESH_ActorDef::SetVisibility(int theMode){
1161   SetVisibility(theMode,true);
1162 }
1163
1164
1165 void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
1166   SALOME_Actor::SetVisibility(theMode);
1167
1168   myNodeActor->VisibilityOff();
1169   myBaseActor->VisibilityOff();
1170
1171   myNodeExtActor->VisibilityOff();
1172
1173   my0DActor->VisibilityOff();
1174   //my0DExtActor->VisibilityOff();
1175
1176   my1DActor->VisibilityOff();
1177   my1DExtActor->VisibilityOff();
1178
1179   my2DActor->VisibilityOff();
1180   my2DExtActor->VisibilityOff();
1181   my3DActor->VisibilityOff();
1182
1183   myScalarBarActor->VisibilityOff();
1184   myPointLabels->VisibilityOff();
1185   myCellsLabels->VisibilityOff();
1186
1187   if(GetVisibility()){
1188     if(theIsUpdateRepersentation)
1189       SetRepresentation(GetRepresentation());
1190
1191     if(myControlMode != eNone){
1192       switch(myControlMode){
1193       case eFreeNodes:
1194         myNodeExtActor->VisibilityOn();
1195         break;
1196       case eFreeEdges:
1197       case eFreeBorders:
1198         my1DExtActor->VisibilityOn();
1199         break;
1200       case eFreeFaces:
1201         my2DExtActor->VisibilityOn();
1202         break;
1203       case eLength2D:
1204       case eMultiConnection2D:
1205         my1DExtActor->VisibilityOn();
1206       default:
1207         if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
1208           myScalarBarActor->VisibilityOn();
1209       }
1210     }
1211
1212     if(myRepresentation != ePoint)
1213       myPickableActor->VisibilityOn();
1214     else {
1215       myNodeActor->VisibilityOn();
1216     }
1217
1218     if(myEntityMode & e0DElements){
1219       my0DActor->VisibilityOn();
1220     }
1221
1222     if(myEntityMode & eEdges){
1223       my1DActor->VisibilityOn();
1224     }
1225
1226     if(myEntityMode & eFaces){
1227       my2DActor->VisibilityOn();
1228     }
1229
1230     if(myEntityMode & eVolumes){
1231       my3DActor->VisibilityOn();
1232     }
1233
1234     if(myIsPointsLabeled){
1235       myPointLabels->VisibilityOn();
1236       myNodeActor->VisibilityOn();
1237     }
1238
1239     if(myIsCellsLabeled)
1240       myCellsLabels->VisibilityOn();
1241   }
1242   UpdateHighlight();
1243   Modified();
1244 }
1245
1246
1247 void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
1248 {
1249   myEntityState = eAllEntity;
1250
1251   if(!myVisualObj->GetNbEntities(SMDSAbs_0DElement)) {
1252     myEntityState &= ~e0DElements;
1253     theMode &= ~e0DElements;
1254   }
1255
1256   if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) {
1257     myEntityState &= ~eEdges;
1258     theMode &= ~eEdges;
1259   }
1260
1261   if(!myVisualObj->GetNbEntities(SMDSAbs_Face)) {
1262     myEntityState &= ~eFaces;
1263     theMode &= ~eFaces;
1264   }
1265
1266   if(!myVisualObj->GetNbEntities(SMDSAbs_Volume)) {
1267     myEntityState &= ~eVolumes;
1268     theMode &= ~eVolumes;
1269   }
1270
1271   if (!theMode) {
1272     if(myVisualObj->GetNbEntities(SMDSAbs_0DElement))
1273       theMode |= e0DElements;
1274
1275     if(myVisualObj->GetNbEntities(SMDSAbs_Edge))
1276       theMode |= eEdges;
1277
1278     if(myVisualObj->GetNbEntities(SMDSAbs_Face))
1279       theMode |= eFaces;
1280
1281     if(myVisualObj->GetNbEntities(SMDSAbs_Volume))
1282       theMode |= eVolumes;
1283   }
1284
1285   myBaseActor->myGeomFilter->SetInside(myEntityMode != myEntityState);
1286
1287   myEntityMode = theMode;
1288   VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
1289   aFilter = myBaseActor->GetExtractUnstructuredGrid();
1290   aFilter->ClearRegisteredCellsWithType();
1291   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
1292
1293   VTKViewer_ExtractUnstructuredGrid* aHightFilter = myHighlitableActor->GetExtractUnstructuredGrid();
1294   aHightFilter->ClearRegisteredCellsWithType();
1295   aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
1296
1297   if (myEntityMode & e0DElements) {
1298     if (MYDEBUG) MESSAGE("0D ELEMENTS");
1299     aFilter->RegisterCellsWithType(VTK_VERTEX);
1300     aHightFilter->RegisterCellsWithType(VTK_VERTEX);
1301   }
1302
1303   if (myEntityMode & eEdges) {
1304     if (MYDEBUG) MESSAGE("EDGES");
1305     aFilter->RegisterCellsWithType(VTK_LINE);
1306     aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
1307
1308     aHightFilter->RegisterCellsWithType(VTK_LINE);
1309     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
1310   }
1311
1312   if (myEntityMode & eFaces) {
1313     if (MYDEBUG) MESSAGE("FACES");
1314     aFilter->RegisterCellsWithType(VTK_TRIANGLE);
1315     aFilter->RegisterCellsWithType(VTK_POLYGON);
1316     aFilter->RegisterCellsWithType(VTK_QUAD);
1317     aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
1318     aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
1319
1320     aHightFilter->RegisterCellsWithType(VTK_TRIANGLE);
1321     aHightFilter->RegisterCellsWithType(VTK_POLYGON);
1322     aHightFilter->RegisterCellsWithType(VTK_QUAD);
1323     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
1324     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
1325   }
1326
1327   if (myEntityMode & eVolumes) {
1328     if (MYDEBUG) MESSAGE("VOLUMES");
1329     aFilter->RegisterCellsWithType(VTK_TETRA);
1330     aFilter->RegisterCellsWithType(VTK_VOXEL);
1331     aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
1332     aFilter->RegisterCellsWithType(VTK_WEDGE);
1333     aFilter->RegisterCellsWithType(VTK_PYRAMID);
1334     aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
1335     aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
1336     aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
1337     aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
1338
1339     aHightFilter->RegisterCellsWithType(VTK_TETRA);
1340     aHightFilter->RegisterCellsWithType(VTK_VOXEL);
1341     aHightFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
1342     aHightFilter->RegisterCellsWithType(VTK_WEDGE);
1343     aHightFilter->RegisterCellsWithType(VTK_PYRAMID);
1344     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
1345     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
1346     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
1347     aHightFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
1348   }
1349   aFilter->Update();
1350   if (MYDEBUG) MESSAGE(aFilter->GetOutput()->GetNumberOfCells());
1351   SetVisibility(GetVisibility(),false);
1352 }
1353
1354 void SMESH_ActorDef::SetRepresentation (int theMode)
1355 {
1356   int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
1357   int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
1358   int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
1359
1360   if (theMode < 0) {
1361     myRepresentation = eSurface;
1362     if (!aNbFaces && !aNbVolumes && aNbEdges) {
1363       myRepresentation = eEdge;
1364     } else if (!aNbFaces && !aNbVolumes && !aNbEdges) {
1365       myRepresentation = ePoint;
1366     }
1367   } else {
1368     switch (theMode) {
1369     case eEdge:
1370       if (!aNbFaces && !aNbVolumes && !aNbEdges) return;
1371       break;
1372     case eSurface:
1373       if (!aNbFaces && !aNbVolumes) return;
1374       break;
1375     }
1376     myRepresentation = theMode;
1377   }
1378
1379   if (!GetUnstructuredGrid()->GetNumberOfCells())
1380     myRepresentation = ePoint;
1381
1382   if (myIsShrunk) {
1383     if (myRepresentation == ePoint) {
1384       UnShrink();
1385       myIsShrunk = true;
1386     } else {
1387       SetShrink();
1388     }
1389   }
1390
1391   myPickableActor = myBaseActor;
1392   myNodeActor->SetVisibility(false);
1393   myNodeExtActor->SetVisibility(false);
1394   vtkProperty *aProp = NULL, *aBackProp = NULL;
1395   SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
1396   SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation();
1397   switch (myRepresentation) {
1398   case ePoint:
1399     myPickableActor = myNodeActor;
1400     myNodeActor->SetVisibility(true);
1401     aQuadraticMode = SMESH_Actor::eLines;
1402     aProp = aBackProp = myNodeProp;
1403     aReperesent = SMESH_DeviceActor::ePoint;
1404     break;
1405   case eEdge:
1406     aProp = aBackProp = myEdgeProp;
1407     aReperesent = SMESH_DeviceActor::eInsideframe;
1408     break;
1409   case eSurface:
1410     aProp = mySurfaceProp;
1411     aBackProp = myBackSurfaceProp;
1412     aReperesent = SMESH_DeviceActor::eSurface;
1413     break;
1414   }
1415
1416   my2DActor->SetProperty(aProp);
1417   my2DActor->SetBackfaceProperty(aBackProp);
1418   my2DActor->SetRepresentation(aReperesent);
1419
1420   if(aQuadraticMode == SMESH_Actor::eLines)
1421     my2DActor->SetQuadraticArcMode(false);
1422   else if(aQuadraticMode == SMESH_Actor::eArcs)
1423     my2DActor->SetQuadraticArcMode(true);
1424
1425   my2DExtActor->SetRepresentation(aReperesent);
1426
1427   my3DActor->SetProperty(aProp);
1428   my3DActor->SetBackfaceProperty(aBackProp);
1429   my3DActor->SetRepresentation(aReperesent);
1430
1431   //my0DExtActor->SetVisibility(false);
1432   my1DExtActor->SetVisibility(false);
1433   my2DExtActor->SetVisibility(false);
1434
1435   // ???
1436   //my0DActor->SetProperty(aProp);
1437   //my0DActor->SetBackfaceProperty(aBackProp);
1438   my0DActor->SetRepresentation(aReperesent);
1439   //my0DExtActor->SetRepresentation(aReperesent);
1440
1441   switch(myControlMode){
1442   case eLength:
1443   case eMultiConnection:
1444     aProp = aBackProp = my1DProp;
1445     if(myRepresentation != ePoint)
1446       aReperesent = SMESH_DeviceActor::eInsideframe;
1447     break;
1448   }
1449
1450   if(aQuadraticMode == SMESH_Actor::eLines)
1451     my1DActor->SetQuadraticArcMode(false);
1452   else if(aQuadraticMode == SMESH_Actor::eArcs)
1453     my1DActor->SetQuadraticArcMode(true);
1454
1455   my1DActor->SetProperty(aProp);
1456   my1DActor->SetBackfaceProperty(aBackProp);
1457   my1DActor->SetRepresentation(aReperesent);
1458
1459   my1DExtActor->SetRepresentation(aReperesent);
1460
1461   if(myIsPointsVisible)
1462     myPickableActor = myNodeActor;
1463   if(GetPointRepresentation())
1464     myNodeActor->SetVisibility(true);
1465
1466   SetMapper(myPickableActor->GetMapper());
1467
1468   SetVisibility(GetVisibility(),false);
1469
1470   Modified();
1471 }
1472
1473
1474 void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible){
1475   if ( myIsPointsVisible == theIsPointsVisible )
1476     return;
1477   myIsPointsVisible = theIsPointsVisible;
1478   SetRepresentation(GetRepresentation());
1479 }
1480
1481 bool SMESH_ActorDef::GetPointRepresentation(){
1482   return myIsPointsVisible || myIsPointsLabeled;
1483 }
1484
1485
1486 void SMESH_ActorDef::UpdateHighlight(){
1487   myHighlitableActor->SetVisibility(false);
1488   myHighlitableActor->SetHighlited(false);
1489
1490   if(myIsHighlighted){
1491     myHighlitableActor->SetProperty(myHighlightProp);
1492   }else if(myIsPreselected){
1493     myHighlitableActor->SetProperty(myPreselectProp);
1494   }
1495
1496   bool anIsVisible = GetVisibility();
1497
1498   if(myIsHighlighted || myIsPreselected){
1499     if(GetUnstructuredGrid()->GetNumberOfCells()){
1500       myHighlitableActor->SetHighlited(anIsVisible);
1501       myHighlitableActor->SetVisibility(anIsVisible);
1502       myHighlitableActor->GetExtractUnstructuredGrid()->
1503         SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
1504       myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
1505     }else if(myRepresentation == ePoint || GetPointRepresentation()){
1506       myHighlitableActor->SetHighlited(anIsVisible);
1507       myHighlitableActor->GetExtractUnstructuredGrid()->
1508         SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
1509       myHighlitableActor->SetVisibility(anIsVisible);
1510       myHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint);
1511     }
1512   }
1513 }
1514
1515
1516 void SMESH_ActorDef::highlight(bool theHighlight){
1517   if ( myIsHighlighted == theHighlight )
1518     return;
1519   myIsHighlighted = theHighlight;
1520   UpdateHighlight();
1521 }
1522
1523
1524 void SMESH_ActorDef::SetPreSelected(bool thePreselect){
1525   if ( myIsPreselected == thePreselect )
1526     return;
1527   myIsPreselected = thePreselect;
1528   UpdateHighlight();
1529 }
1530
1531
1532 // From vtkFollower
1533 int SMESH_ActorDef::RenderOpaqueGeometry(vtkViewport *vp)
1534 {
1535   if (myPickableActor->GetIsOpaque())
1536     {
1537     vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
1538     this->Render(ren);
1539     return 1;
1540     }
1541   return 0;
1542 }
1543
1544
1545 int SMESH_ActorDef::RenderTranslucentGeometry(vtkViewport *vp)
1546 {
1547   if (!myPickableActor->GetIsOpaque())
1548     {
1549     vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
1550     this->Render(ren);
1551     return 1;
1552     }
1553   return 0;
1554 }
1555
1556
1557 void SMESH_ActorDef::Render(vtkRenderer *ren){
1558   unsigned long aTime = myTimeStamp->GetMTime();
1559   unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
1560   unsigned long aClippingTime = myImplicitBoolean->GetMTime();
1561   if(anObjTime > aTime || aClippingTime > aTime)
1562     Update();
1563 }
1564
1565
1566 void SMESH_ActorDef::Update(){
1567   if(MYDEBUG) MESSAGE("SMESH_ActorDef::Update");
1568
1569   if(GetControlMode() != eNone) {
1570     unsigned long aTime = myTimeStamp->GetMTime();
1571     unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
1572     if (anObjTime > aTime)
1573       SetControlMode(GetControlMode(),false);
1574   }
1575   if(myIsPointsLabeled){
1576     SetPointsLabeled(myIsPointsLabeled);
1577   }
1578   if(myIsCellsLabeled){
1579     SetCellsLabeled(myIsCellsLabeled);
1580   }
1581   if(myIsFacesOriented){
1582     SetFacesOriented(myIsFacesOriented);
1583   }
1584   SetEntityMode(GetEntityMode());
1585   SetVisibility(GetVisibility());
1586
1587   myTimeStamp->Modified();
1588   Modified();
1589 }
1590
1591
1592 void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){
1593   SALOME_Actor::ReleaseGraphicsResources(renWin);
1594
1595   myPickableActor->ReleaseGraphicsResources(renWin);
1596 }
1597
1598
1599 static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1600   vtkFloatingPointType* aColor = theProperty->GetColor();
1601   r = aColor[0];
1602   g = aColor[1];
1603   b = aColor[2];
1604 }
1605
1606
1607 void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
1608   mySurfaceProp->SetOpacity(theValue);
1609   myBackSurfaceProp->SetOpacity(theValue);
1610   myEdgeProp->SetOpacity(theValue);
1611   myNodeProp->SetOpacity(theValue);
1612
1613   my1DProp->SetOpacity(theValue);
1614 }
1615
1616
1617 vtkFloatingPointType SMESH_ActorDef::GetOpacity(){
1618   return mySurfaceProp->GetOpacity();
1619 }
1620
1621
1622 void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1623   mySurfaceProp->SetColor(r,g,b);
1624   if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
1625     if( aGroupObj->GetElementType() == SMDSAbs_Face ||
1626         aGroupObj->GetElementType() == SMDSAbs_Volume )
1627       myNameActor->SetBackgroundColor(r,g,b);
1628   Modified();
1629 }
1630
1631 void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1632   ::GetColor(mySurfaceProp,r,g,b);
1633   my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
1634 }
1635
1636 void SMESH_ActorDef::SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1637   myBackSurfaceProp->SetColor(r,g,b);
1638   Modified();
1639 }
1640
1641 void SMESH_ActorDef::GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1642   ::GetColor(myBackSurfaceProp,r,g,b);
1643 }
1644
1645 void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1646   myEdgeProp->SetColor(r,g,b);
1647   my1DProp->SetColor(r,g,b);
1648   my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
1649   if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
1650     if( aGroupObj->GetElementType() == SMDSAbs_Edge )
1651       myNameActor->SetBackgroundColor(r,g,b);
1652   Modified();
1653 }
1654
1655 void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1656   ::GetColor(myEdgeProp,r,g,b);
1657 }
1658
1659 void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1660   myNodeProp->SetColor(r,g,b);
1661   myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
1662   if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
1663     if( aGroupObj->GetElementType() == SMDSAbs_Node )
1664       myNameActor->SetBackgroundColor(r,g,b);
1665   Modified();
1666 }
1667
1668 void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1669   ::GetColor(myNodeProp,r,g,b);
1670 }
1671
1672 void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1673   my0DProp->SetColor(r,g,b);
1674   Modified();
1675 }
1676
1677 void SMESH_ActorDef::Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1678   ::GetColor(my0DProp,r,g,b);
1679 }
1680
1681 void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1682   myHighlightProp->SetColor(r,g,b);
1683   Modified();
1684 }
1685
1686 void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1687   ::GetColor(myHighlightProp,r,g,b);
1688 }
1689
1690 void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
1691   myPreselectProp->SetColor(r,g,b);
1692   Modified();
1693 }
1694
1695 void SMESH_ActorDef::GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
1696   ::GetColor(myPreselectProp,r,g,b);
1697 }
1698
1699
1700 vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){
1701   return myEdgeProp->GetLineWidth();
1702 }
1703
1704
1705 void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
1706   myEdgeProp->SetLineWidth(theVal);
1707
1708   my1DProp->SetLineWidth(theVal + aLineWidthInc);
1709   my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
1710
1711   Modified();
1712 }
1713
1714
1715 void SMESH_ActorDef::SetNodeSize(vtkFloatingPointType theVal){
1716   myNodeProp->SetPointSize(theVal);
1717   myNodeExtProp->SetPointSize(theVal);
1718
1719   vtkFloatingPointType aPointSize = my0DProp->GetPointSize() > theVal ? my0DProp->GetPointSize() : theVal;
1720   //myHighlightProp->SetPointSize(theVal);
1721   myHighlightProp->SetPointSize(aPointSize); // ??
1722   //myPreselectProp->SetPointSize(theVal);
1723   myPreselectProp->SetPointSize(aPointSize); // ??
1724
1725   my1DProp->SetPointSize(theVal + aPointSizeInc);
1726   my1DExtProp->SetPointSize(theVal + aPointSizeInc);
1727
1728   Modified();
1729 }
1730
1731 vtkFloatingPointType SMESH_ActorDef::GetNodeSize(){
1732   return myNodeProp->GetPointSize();
1733 }
1734
1735 void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
1736   my0DProp->SetPointSize(theVal);
1737
1738   vtkFloatingPointType aPointSize = myNodeProp->GetPointSize() > theVal ? myNodeProp->GetPointSize() : theVal;
1739   //myHighlightProp->SetPointSize(theVal);
1740   myHighlightProp->SetPointSize(aPointSize); // ??
1741   //myPreselectProp->SetPointSize(theVal);
1742   myPreselectProp->SetPointSize(aPointSize); // ??
1743
1744   Modified();
1745 }
1746
1747 vtkFloatingPointType SMESH_ActorDef::Get0DSize(){
1748   return my0DProp->GetPointSize();
1749 }
1750
1751 int SMESH_ActorDef::GetObjDimension( const int theObjId )
1752 {
1753   return myVisualObj->GetElemDimension( theObjId );
1754 }
1755
1756 bool
1757 SMESH_ActorDef::
1758 IsImplicitFunctionUsed() const
1759 {
1760   return myBaseActor->IsImplicitFunctionUsed();
1761 }
1762
1763 void
1764 SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
1765 {
1766   myNodeActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1767   myBaseActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1768
1769   myHighlitableActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1770
1771   myNodeExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1772
1773   my0DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1774   //my0DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1775
1776   my1DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1777   my1DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1778
1779   my2DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1780   my2DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1781   my3DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
1782 }
1783
1784 vtkIdType
1785 SMESH_ActorDef::AddClippingPlane(vtkPlane* thePlane)
1786 {
1787   if(thePlane){
1788     myImplicitBoolean->GetFunction()->AddItem(thePlane);
1789     myCippingPlaneCont.push_back(thePlane);
1790     if(!IsImplicitFunctionUsed())
1791       SetImplicitFunctionUsed(true);
1792   }
1793   return myCippingPlaneCont.size();
1794 }
1795
1796 void
1797 SMESH_ActorDef::
1798 RemoveAllClippingPlanes()
1799 {
1800   myImplicitBoolean->GetFunction()->RemoveAllItems();
1801   myImplicitBoolean->GetFunction()->Modified(); // VTK bug
1802   myCippingPlaneCont.clear();
1803   SetImplicitFunctionUsed(false);
1804 }
1805
1806 vtkIdType
1807 SMESH_ActorDef::
1808 GetNumberOfClippingPlanes()
1809 {
1810   return myCippingPlaneCont.size();
1811 }
1812
1813 vtkPlane*
1814 SMESH_ActorDef::
1815 GetClippingPlane(vtkIdType theID)
1816 {
1817   if(theID >= myCippingPlaneCont.size())
1818     return NULL;
1819   return myCippingPlaneCont[theID].Get();
1820 }
1821
1822
1823 static void ComputeBoundsParam(vtkDataSet* theDataSet,
1824                                vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3],
1825                                vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj)
1826 {
1827   vtkFloatingPointType aBounds[6];
1828   theDataSet->GetBounds(aBounds);
1829
1830   //Enlarge bounds in order to avoid conflicts of precision
1831   for(int i = 0; i < 6; i += 2){
1832     static double EPS = 1.0E-3;
1833     vtkFloatingPointType aDelta = (aBounds[i+1] - aBounds[i])*EPS;
1834     aBounds[i] -= aDelta;
1835     aBounds[i+1] += aDelta;
1836   }
1837
1838   vtkFloatingPointType aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]},
1839                                {aBounds[1],aBounds[2],aBounds[4]},
1840                                {aBounds[0],aBounds[3],aBounds[4]},
1841                                {aBounds[1],aBounds[3],aBounds[4]},
1842                                {aBounds[0],aBounds[2],aBounds[5]},
1843                                {aBounds[1],aBounds[2],aBounds[5]},
1844                                {aBounds[0],aBounds[3],aBounds[5]},
1845                                {aBounds[1],aBounds[3],aBounds[5]}};
1846
1847   int aMaxId = 0, aMinId = aMaxId;
1848   theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
1849   theMinBoundPrj = theMaxBoundPrj;
1850   for(int i = 1; i < 8; i++){
1851     vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
1852     if(theMaxBoundPrj < aTmp){
1853       theMaxBoundPrj = aTmp;
1854       aMaxId = i;
1855     }
1856     if(theMinBoundPrj > aTmp){
1857       theMinBoundPrj = aTmp;
1858       aMinId = i;
1859     }
1860   }
1861   vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId];
1862   theMinPnt[0] = aMinPnt[0];
1863   theMinPnt[1] = aMinPnt[1];
1864   theMinPnt[2] = aMinPnt[2];
1865 }
1866
1867
1868 static void DistanceToPosition(vtkDataSet* theDataSet,
1869                                vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3])
1870 {
1871   vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
1872   ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
1873   vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
1874   thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
1875   thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
1876   thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
1877 }
1878
1879
1880 static void PositionToDistance(vtkDataSet* theDataSet,
1881                                vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist)
1882 {
1883   vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
1884   ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
1885   vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos);
1886   theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
1887 }
1888
1889
1890 void SMESH_ActorDef::SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane)
1891 {
1892   thePlane->SetNormal(theDir);
1893   vtkFloatingPointType anOrigin[3];
1894   ::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin);
1895   thePlane->SetOrigin(anOrigin);
1896 }
1897
1898
1899 void SMESH_ActorDef::GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane)
1900 {
1901   thePlane->GetNormal(theDir);
1902
1903   vtkFloatingPointType anOrigin[3];
1904   thePlane->GetOrigin(anOrigin);
1905   ::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist);
1906 }
1907
1908 void SMESH_ActorDef::UpdateScalarBar()
1909 {
1910   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
1911   if( !mgr )
1912     return;
1913
1914   vtkTextProperty* aScalarBarTitleProp = vtkTextProperty::New();
1915
1916   QColor aTColor = mgr->colorValue( "SMESH", "scalar_bar_title_color", QColor( 255, 255, 255 ) );
1917   aScalarBarTitleProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. );
1918
1919   aScalarBarTitleProp->SetFontFamilyToArial();
1920
1921   if ( mgr->hasValue( "SMESH", "scalar_bar_title_font" ) )
1922   {
1923     QFont f = mgr->fontValue( "SMESH", "scalar_bar_title_font" );
1924     if ( f.family() == "Arial" )
1925       aScalarBarTitleProp->SetFontFamilyToArial();
1926     else if ( f.family() == "Courier" )
1927       aScalarBarTitleProp->SetFontFamilyToCourier();
1928     else if ( f.family() == "Times" )
1929       aScalarBarTitleProp->SetFontFamilyToTimes();
1930
1931     if ( f.bold() )
1932       aScalarBarTitleProp->BoldOn();
1933     else
1934       aScalarBarTitleProp->BoldOff();
1935
1936     if ( f.italic() )
1937       aScalarBarTitleProp->ItalicOn();
1938     else
1939      aScalarBarTitleProp->ItalicOff();
1940
1941     if ( f.overline() )
1942       aScalarBarTitleProp->ShadowOn();
1943     else
1944       aScalarBarTitleProp->ShadowOff();
1945   }
1946
1947   myScalarBarActor->SetTitleTextProperty( aScalarBarTitleProp );
1948   aScalarBarTitleProp->Delete();
1949
1950   vtkTextProperty* aScalarBarLabelProp = vtkTextProperty::New();
1951
1952   aTColor = mgr->colorValue( "SMESH", "scalar_bar_label_color", QColor( 255, 255, 255 ) );
1953   aScalarBarLabelProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. );
1954
1955   aScalarBarLabelProp->SetFontFamilyToArial();
1956   if( mgr->hasValue( "SMESH", "scalar_bar_label_font" ) )
1957   {
1958     QFont f = mgr->fontValue( "SMESH", "scalar_bar_label_font" );
1959     if( f.family() == "Arial" )
1960       aScalarBarLabelProp->SetFontFamilyToArial();
1961     else if( f.family() == "Courier" )
1962       aScalarBarLabelProp->SetFontFamilyToCourier();
1963     else if( f.family() == "Times" )
1964       aScalarBarLabelProp->SetFontFamilyToTimes();
1965
1966     if ( f.bold() )
1967       aScalarBarLabelProp->BoldOn();
1968     else
1969       aScalarBarLabelProp->BoldOff();
1970
1971     if ( f.italic() )
1972       aScalarBarLabelProp->ItalicOn();
1973     else
1974       aScalarBarLabelProp->ItalicOff();
1975
1976     if( f.overline() )
1977       aScalarBarLabelProp->ShadowOn();
1978     else
1979       aScalarBarLabelProp->ShadowOff();
1980   }
1981
1982   myScalarBarActor->SetLabelTextProperty( aScalarBarLabelProp );
1983   aScalarBarLabelProp->Delete();
1984
1985   bool horiz = ( mgr->integerValue( "SMESH", "scalar_bar_orientation" ) == 1 );
1986   QString name = QString( "scalar_bar_%1_" ).arg( horiz ? "horizontal" : "vertical" );
1987   if( horiz )
1988     myScalarBarActor->SetOrientationToHorizontal();
1989   else
1990     myScalarBarActor->SetOrientationToVertical();
1991
1992
1993   vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01;
1994   if( mgr->hasValue( "SMESH", name + "x" ) )
1995     aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal );
1996
1997   vtkFloatingPointType aYVal = horiz ? 0.01 : 0.1;
1998   if( mgr->hasValue( "SMESH", name + "y" ) )
1999     aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal );
2000   myScalarBarActor->SetPosition( aXVal, aYVal );
2001
2002   vtkFloatingPointType aWVal = horiz ? 0.60 : 0.10;
2003   if( mgr->hasValue( "SMESH", name + "width" ) )
2004     aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal );
2005   myScalarBarActor->SetWidth( aWVal );
2006
2007   vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80;
2008   if( mgr->hasValue( "SMESH", name + "height" ) )
2009     aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal );
2010   myScalarBarActor->SetHeight( aHVal );
2011
2012   int anIntVal = 5;
2013   if( mgr->hasValue( "SMESH", "scalar_bar_num_labels" ) )
2014     anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_labels", anIntVal );
2015   myScalarBarActor->SetNumberOfLabels( anIntVal == 0 ? 5: anIntVal );
2016
2017   anIntVal = 64;
2018   if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) )
2019     anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal );
2020   myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal );
2021
2022 }
2023
2024 void SMESH_ActorDef::SetQuadratic2DRepresentation(EQuadratic2DRepresentation theMode)
2025 {
2026   switch(theMode) {
2027   case SMESH_Actor::eLines :
2028     myHighlitableActor->SetQuadraticArcMode(false);
2029     my2DActor->SetQuadraticArcMode(false);
2030     my1DActor->SetQuadraticArcMode(false);
2031     break;
2032   case SMESH_Actor::eArcs :
2033     myHighlitableActor->SetQuadraticArcMode(true);
2034     if(GetRepresentation() != SMESH_Actor::ePoint) {
2035       my2DActor->SetQuadraticArcMode(true);
2036       my1DActor->SetQuadraticArcMode(true);
2037     }
2038     break;
2039   default:
2040     break;
2041   }
2042 }
2043
2044
2045 SMESH_Actor::EQuadratic2DRepresentation SMESH_ActorDef::GetQuadratic2DRepresentation()
2046 {
2047   if(myHighlitableActor->GetQuadraticArcMode())
2048     return SMESH_Actor::eArcs;
2049   else
2050     return SMESH_Actor::eLines;
2051 }