src/OBJECT/SMESH_DeviceActor.cxx

   1 //  Copyright (C) 2007-2010  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
  23 //  SMESH OBJECT : interactive object for SMESH visualization
  24 //  File   : SMESH_DeviceActor.cxx
  25 //  Author :
  26 //  Module : SMESH
  27 //
  28 #include "SMESH_DeviceActor.h"
  29 #include "SMESH_ScalarBarActor.h"
  30 #include "SMESH_ExtractGeometry.h"
  31 #include "SMESH_ControlsDef.hxx"
  32 #include "SMESH_ActorUtils.h"
  33 #include "SMESH_FaceOrientationFilter.h"
  34 #include "VTKViewer_CellLocationsArray.h"
  35 #include "VTKViewer_PolyDataMapper.h"
  36
  37 #include <VTKViewer_Transform.h>
  38 #include <VTKViewer_TransformFilter.h>
  39 #include <VTKViewer_ExtractUnstructuredGrid.h>
  40
  41 // VTK Includes
  42 #include <vtkObjectFactory.h>
  43 #include <vtkShrinkFilter.h>
  44 #include <vtkShrinkPolyData.h>
  45
  46 #include <vtkProperty.h>
  47 #include <vtkPolyData.h>
  48 #include <vtkMergeFilter.h>
  49 #include <vtkPolyDataMapper.h>
  50 #include <vtkUnstructuredGrid.h>
  51
  52 #include <vtkLookupTable.h>
  53 #include <vtkDoubleArray.h>
  54 #include <vtkCellData.h>
  55
  56 #include <vtkCell.h>
  57 #include <vtkIdList.h>
  58 #include <vtkCellArray.h>
  59 #include <vtkUnsignedCharArray.h>
  60
  61 #include <vtkImplicitBoolean.h>
  62 #include <vtkPassThroughFilter.h>
  63
  64 #include <vtkRenderer.h>
  65
  66 #include "utilities.h"
  67
  68 #ifdef _DEBUG_
  69 static int MYDEBUG = 0;
  70 #else
  71 static int MYDEBUG = 0;
  72 #endif
  73
  74 using namespace std;
  75
  76
  77 vtkStandardNewMacro(SMESH_DeviceActor);
  78
  79
  80 SMESH_DeviceActor
  81 ::SMESH_DeviceActor()
  82 {
  83   if(MYDEBUG) MESSAGE("SMESH_DeviceActor - "<<this);
  84
  85   myIsShrinkable = false;
  86   myIsShrunk = false;
  87   myIsHighlited = false;
  88
  89   myRepresentation = eSurface;
  90
  91   myProperty = vtkProperty::New();
  92   myMapper = VTKViewer_PolyDataMapper::New();
  93
  94   vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(myPolygonOffsetFactor,
  95                                                                  myPolygonOffsetUnits);
  96
  97   myMapper->UseLookupTableScalarRangeOn();
  98   myMapper->SetColorModeToMapScalars();
  99
 100   myShrinkFilter = vtkShrinkFilter::New();
 101
 102   myStoreClippingMapping = false;
 103
 104   myExtractGeometry = SMESH_ExtractGeometry::New();
 105   myExtractGeometry->SetReleaseDataFlag(true);
 106   myIsImplicitFunctionUsed = false;
 107
 108   myExtractUnstructuredGrid = VTKViewer_ExtractUnstructuredGrid::New();
 109
 110   myMergeFilter = vtkMergeFilter::New();
 111
 112   myGeomFilter = VTKViewer_GeometryFilter::New();
 113
 114   myTransformFilter = VTKViewer_TransformFilter::New();
 115
 116   for(int i = 0; i < 6; i++)
 117     myPassFilter.push_back(vtkPassThroughFilter::New());
 118
 119   // Orientation of faces
 120   myIsFacesOriented = false;
 121
 122   vtkFloatingPointType anRGB[3] = { 1, 1, 1 };
 123   SMESH::GetColor( "SMESH", "orientation_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
 124
 125   myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
 126
 127   myFaceOrientationDataMapper = vtkPolyDataMapper::New();
 128   myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput());
 129
 130   myFaceOrientation = vtkActor::New();
 131   myFaceOrientation->SetMapper(myFaceOrientationDataMapper);
 132   myFaceOrientation->GetProperty()->SetColor(anRGB[0], anRGB[1], anRGB[2]);
 133 }
 134
 135
 136 SMESH_DeviceActor
 137 ::~SMESH_DeviceActor()
 138 {
 139   if(MYDEBUG) MESSAGE("~SMESH_DeviceActor - "<<this);
 140
 141   myProperty->Delete();
 142
 143   myMapper->Delete();
 144
 145   myShrinkFilter->Delete();
 146
 147   myExtractUnstructuredGrid->Delete();
 148
 149   myMergeFilter->Delete();
 150
 151   myGeomFilter->Delete();
 152
 153   myExtractGeometry->Delete();
 154
 155   myTransformFilter->Delete();
 156
 157   for(int i = 0, iEnd = myPassFilter.size(); i < iEnd; i++){
 158     myPassFilter[i]->Delete();
 159   }
 160
 161   // Orientation of faces
 162   myFaceOrientationFilter->Delete();
 163
 164   myFaceOrientationDataMapper->RemoveAllInputs();
 165   myFaceOrientationDataMapper->Delete();
 166
 167   myFaceOrientation->Delete();
 168 }
 169
 170
 171 void
 172 SMESH_DeviceActor
 173 ::SetStoreGemetryMapping(bool theStoreMapping)
 174 {
 175   myGeomFilter->SetStoreMapping(theStoreMapping);
 176   SetStoreClippingMapping(theStoreMapping);
 177 }
 178
 179
 180 void
 181 SMESH_DeviceActor
 182 ::SetStoreClippingMapping(bool theStoreMapping)
 183 {
 184   myStoreClippingMapping = theStoreMapping;
 185   myExtractGeometry->SetStoreMapping(theStoreMapping && myIsImplicitFunctionUsed);
 186   SetStoreIDMapping(theStoreMapping);
 187 }
 188
 189
 190 void
 191 SMESH_DeviceActor
 192 ::SetStoreIDMapping(bool theStoreMapping)
 193 {
 194   myExtractUnstructuredGrid->SetStoreMapping(theStoreMapping);
 195 }
 196
 197
 198 void
 199 SMESH_DeviceActor
 200 ::Init(TVisualObjPtr theVisualObj,
 201        vtkImplicitBoolean* theImplicitBoolean)
 202 {
 203   myVisualObj = theVisualObj;
 204   myExtractGeometry->SetImplicitFunction(theImplicitBoolean);
 205   SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
 206 }
 207
 208
 209 void
 210 SMESH_DeviceActor
 211 ::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
 212 {
 213   int anId = 0;
 214   if(theIsImplicitFunctionUsed)
 215     myPassFilter[ anId ]->SetInput( myExtractGeometry->GetOutput() );
 216   else
 217     myPassFilter[ anId ]->SetInput( myMergeFilter->GetOutput() );
 218
 219   myIsImplicitFunctionUsed = theIsImplicitFunctionUsed;
 220   SetStoreClippingMapping(myStoreClippingMapping);
 221 }
 222
 223
 224 void
 225 SMESH_DeviceActor
 226 ::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid)
 227 {
 228   if(theGrid){
 229     //myIsShrinkable = theGrid->GetNumberOfCells() > 10;
 230     myIsShrinkable = true;
 231
 232     myExtractUnstructuredGrid->SetInput(theGrid);
 233
 234     myMergeFilter->SetGeometry(myExtractUnstructuredGrid->GetOutput());
 235
 236     myExtractGeometry->SetInput(myMergeFilter->GetOutput());
 237
 238     int anId = 0;
 239     SetImplicitFunctionUsed(myIsImplicitFunctionUsed);
 240     myPassFilter[ anId + 1]->SetInput( myPassFilter[ anId ]->GetOutput() );
 241
 242     anId++; // 1
 243     myGeomFilter->SetInput( myPassFilter[ anId ]->GetOutput() );
 244
 245     anId++; // 2
 246     myPassFilter[ anId ]->SetInput( myGeomFilter->GetOutput() );
 247     myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() );
 248
 249     anId++; // 3
 250     myTransformFilter->SetInput( myPassFilter[ anId ]->GetPolyDataOutput() );
 251
 252     anId++; // 4
 253     myPassFilter[ anId ]->SetInput( myTransformFilter->GetOutput() );
 254     myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() );
 255
 256     anId++; // 5
 257     myMapper->SetInput( myPassFilter[ anId ]->GetPolyDataOutput() );
 258
 259     vtkLODActor::SetMapper( myMapper );
 260     Modified();
 261   }
 262 }
 263
 264
 265 VTKViewer_ExtractUnstructuredGrid*
 266 SMESH_DeviceActor
 267 ::GetExtractUnstructuredGrid()
 268 {
 269   return myExtractUnstructuredGrid;
 270 }
 271
 272
 273 vtkUnstructuredGrid*
 274 SMESH_DeviceActor
 275 ::GetUnstructuredGrid()
 276 {
 277   myExtractUnstructuredGrid->Update();
 278   return myExtractUnstructuredGrid->GetOutput();
 279 }
 280
 281
 282 void
 283 SMESH_DeviceActor
 284 ::SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
 285                  SMESH_ScalarBarActor* theScalarBarActor,
 286                  vtkLookupTable* theLookupTable)
 287 {
 288   bool anIsInitialized = theFunctor;
 289   if(anIsInitialized){
 290     vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New();
 291
 292     SetStoreIDMapping(true);
 293     myExtractUnstructuredGrid->Update();
 294     vtkUnstructuredGrid* aGrid = myExtractUnstructuredGrid->GetOutput();
 295
 296     aDataSet->ShallowCopy(aGrid);
 297
 298     vtkDoubleArray *aScalars = vtkDoubleArray::New();
 299     vtkIdType aNbCells = aGrid->GetNumberOfCells();
 300     aScalars->SetNumberOfComponents(1);
 301     aScalars->SetNumberOfTuples(aNbCells);
 302
 303     myVisualObj->UpdateFunctor(theFunctor);
 304
 305     using namespace SMESH::Controls;
 306     if(NumericalFunctor* aNumericalFunctor = dynamic_cast<NumericalFunctor*>(theFunctor.get())){
 307       for(vtkIdType i = 0; i < aNbCells; i++){
 308         vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i);
 309         vtkIdType anObjId = myVisualObj->GetElemObjId(anId);
 310         double aValue = aNumericalFunctor->GetValue(anObjId);
 311         aScalars->SetValue(i,aValue);
 312       }
 313       int nbIntervals = theScalarBarActor->GetMaximumNumberOfColors();
 314       std::vector<int> nbEvents;
 315       std::vector<double> funValues;
 316       aNumericalFunctor->GetHistogram(nbIntervals, nbEvents, funValues);
 317       theScalarBarActor->SetDistribution(nbEvents);
 318
 319     }else if(Predicate* aPredicate = dynamic_cast<Predicate*>(theFunctor.get())){
 320       for(vtkIdType i = 0; i < aNbCells; i++){
 321         vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i);
 322         vtkIdType anObjId = myVisualObj->GetElemObjId(anId);
 323         bool aValue = aPredicate->IsSatisfy(anObjId);
 324         aScalars->SetValue(i,aValue);
 325       }
 326     }
 327
 328     aDataSet->GetCellData()->SetScalars(aScalars);
 329     aScalars->Delete();
 330
 331     theLookupTable->SetRange(aScalars->GetRange());
 332     theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors());
 333     theLookupTable->Build();
 334
 335     myMergeFilter->SetScalars(aDataSet);
 336     aDataSet->Delete();
 337   }
 338   GetMapper()->SetScalarVisibility(anIsInitialized);
 339   theScalarBarActor->SetVisibility(anIsInitialized);
 340 }
 341
 342 void
 343 SMESH_DeviceActor
 344 ::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor,
 345                     SMESH_ScalarBarActor* theScalarBarActor,
 346                     vtkLookupTable* theLookupTable)
 347 {
 348   bool anIsInitialized = theFunctor;
 349   myExtractUnstructuredGrid->ClearRegisteredCells();
 350   myExtractUnstructuredGrid->ClearRegisteredCellsWithType();
 351   myExtractUnstructuredGrid->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::ePassAll);
 352   myVisualObj->UpdateFunctor(theFunctor);
 353
 354   using namespace SMESH::Controls;
 355   if (anIsInitialized){
 356     if (Length2D* aLength2D = dynamic_cast<Length2D*>(theFunctor.get())){
 357       SMESH::Controls::Length2D::TValues aValues;
 358
 359       aLength2D->GetValues(aValues);
 360       vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New();
 361       vtkUnstructuredGrid* aGrid = myVisualObj->GetUnstructuredGrid();
 362
 363       aDataSet->SetPoints(aGrid->GetPoints());
 364
 365       vtkIdType aNbCells = aValues.size();
 366
 367       vtkDoubleArray *aScalars = vtkDoubleArray::New();
 368       aScalars->SetNumberOfComponents(1);
 369       aScalars->SetNumberOfTuples(aNbCells);
 370
 371       vtkIdType aCellsSize = 3*aNbCells;
 372       vtkCellArray* aConnectivity = vtkCellArray::New();
 373       aConnectivity->Allocate( aCellsSize, 0 );
 374
 375       vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 376       aCellTypesArray->SetNumberOfComponents( 1 );
 377       aCellTypesArray->Allocate( aNbCells * aCellTypesArray->GetNumberOfComponents() );
 378
 379       vtkIdList *anIdList = vtkIdList::New();
 380       anIdList->SetNumberOfIds(2);
 381
 382       Length2D::TValues::const_iterator anIter = aValues.begin();
 383       for(vtkIdType aVtkId = 0; anIter != aValues.end(); anIter++,aVtkId++){
 384         const Length2D::Value& aValue = *anIter;
 385         int aNode[2] = {
 386           myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
 387           myVisualObj->GetNodeVTKId(aValue.myPntId[1])
 388         };
 389         if(aNode[0] >= 0 && aNode[1] >= 0){
 390           anIdList->SetId( 0, aNode[0] );
 391           anIdList->SetId( 1, aNode[1] );
 392           aConnectivity->InsertNextCell( anIdList );
 393           aCellTypesArray->InsertNextValue( VTK_LINE );
 394           aScalars->SetValue(aVtkId,aValue.myLength);
 395         }
 396       }
 397
 398       VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 399       aCellLocationsArray->SetNumberOfComponents( 1 );
 400       aCellLocationsArray->SetNumberOfTuples( aNbCells );
 401
 402       aConnectivity->InitTraversal();
 403       for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
 404         aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
 405
 406       aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
 407       SetUnstructuredGrid(aDataSet);
 408
 409       aDataSet->GetCellData()->SetScalars(aScalars);
 410       aScalars->Delete();
 411
 412       theLookupTable->SetRange(aScalars->GetRange());
 413       theLookupTable->Build();
 414
 415       myMergeFilter->SetScalars(aDataSet);
 416       aDataSet->Delete();
 417     }
 418     else if (MultiConnection2D* aMultiConnection2D = dynamic_cast<MultiConnection2D*>(theFunctor.get())){
 419       SMESH::Controls::MultiConnection2D::MValues aValues;
 420
 421       aMultiConnection2D->GetValues(aValues);
 422       vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New();
 423       vtkUnstructuredGrid* aGrid = myVisualObj->GetUnstructuredGrid();
 424       aDataSet->SetPoints(aGrid->GetPoints());
 425
 426       vtkIdType aNbCells = aValues.size();
 427       vtkDoubleArray *aScalars = vtkDoubleArray::New();
 428       aScalars->SetNumberOfComponents(1);
 429       aScalars->SetNumberOfTuples(aNbCells);
 430
 431       vtkIdType aCellsSize = 3*aNbCells;
 432       vtkCellArray* aConnectivity = vtkCellArray::New();
 433       aConnectivity->Allocate( aCellsSize, 0 );
 434
 435       vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 436       aCellTypesArray->SetNumberOfComponents( 1 );
 437       aCellTypesArray->Allocate( aNbCells * aCellTypesArray->GetNumberOfComponents() );
 438
 439       vtkIdList *anIdList = vtkIdList::New();
 440       anIdList->SetNumberOfIds(2);
 441
 442       MultiConnection2D::MValues::const_iterator anIter = aValues.begin();
 443       for(vtkIdType aVtkId = 0; anIter != aValues.end(); anIter++,aVtkId++){
 444         const MultiConnection2D::Value& aValue = (*anIter).first;
 445         int aNode[2] = {
 446           myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
 447           myVisualObj->GetNodeVTKId(aValue.myPntId[1])
 448         };
 449         if(aNode[0] >= 0 && aNode[1] >= 0){
 450           anIdList->SetId( 0, aNode[0] );
 451           anIdList->SetId( 1, aNode[1] );
 452           aConnectivity->InsertNextCell( anIdList );
 453           aCellTypesArray->InsertNextValue( VTK_LINE );
 454           aScalars->SetValue(aVtkId,(*anIter).second);
 455         }
 456       }
 457
 458       VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 459       aCellLocationsArray->SetNumberOfComponents( 1 );
 460       aCellLocationsArray->SetNumberOfTuples( aNbCells );
 461
 462       aConnectivity->InitTraversal();
 463       for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
 464         aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
 465
 466       aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
 467       SetUnstructuredGrid(aDataSet);
 468
 469       aDataSet->GetCellData()->SetScalars(aScalars);
 470       aScalars->Delete();
 471
 472       theLookupTable->SetRange(aScalars->GetRange());
 473       theLookupTable->Build();
 474
 475       myMergeFilter->SetScalars(aDataSet);
 476       aDataSet->Delete();
 477     }
 478
 479     //Set Distribution
 480     if(NumericalFunctor* aNumericalFunctor = dynamic_cast<NumericalFunctor*>(theFunctor.get())){
 481       int nbIntervals = theScalarBarActor->GetMaximumNumberOfColors();
 482       std::vector<int> nbEvents;
 483       std::vector<double> funValues;
 484       aNumericalFunctor->GetHistogram(nbIntervals, nbEvents, funValues);
 485       theScalarBarActor->SetDistribution(nbEvents);
 486     }
 487
 488   }
 489   GetMapper()->SetScalarVisibility(anIsInitialized);
 490   theScalarBarActor->SetVisibility(anIsInitialized);
 491 }
 492
 493 void
 494 SMESH_DeviceActor
 495 ::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor)
 496 {
 497   myExtractUnstructuredGrid->ClearRegisteredCells();
 498   myExtractUnstructuredGrid->ClearRegisteredCellsWithType();
 499   myExtractUnstructuredGrid->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::ePassAll);
 500   myVisualObj->UpdateFunctor(theFunctor);
 501
 502   using namespace SMESH::Controls;
 503   if ( dynamic_cast<FreeBorders*>(theFunctor.get()) ||
 504        dynamic_cast<FreeFaces*>(theFunctor.get()) ) {
 505     Predicate* aFreePredicate = dynamic_cast<Predicate*>(theFunctor.get());
 506     myExtractUnstructuredGrid->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 507     vtkUnstructuredGrid* aGrid = myVisualObj->GetUnstructuredGrid();
 508     vtkIdType aNbCells = aGrid->GetNumberOfCells();
 509     for( vtkIdType i = 0; i < aNbCells; i++ ){
 510       vtkIdType anObjId = myVisualObj->GetElemObjId(i);
 511       if(aFreePredicate->IsSatisfy(anObjId))
 512         myExtractUnstructuredGrid->RegisterCell(i);
 513     }
 514     if(!myExtractUnstructuredGrid->IsCellsRegistered())
 515       myExtractUnstructuredGrid->RegisterCell(-1);
 516     SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
 517   }else if(FreeEdges* aFreeEdges = dynamic_cast<FreeEdges*>(theFunctor.get())){
 518     SMESH::Controls::FreeEdges::TBorders aBorders;
 519     aFreeEdges->GetBoreders(aBorders);
 520     vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New();
 521     vtkUnstructuredGrid* aGrid = myVisualObj->GetUnstructuredGrid();
 522     aDataSet->SetPoints(aGrid->GetPoints());
 523
 524     vtkIdType aNbCells = aBorders.size();
 525     vtkIdType aCellsSize = 3*aNbCells;
 526     vtkCellArray* aConnectivity = vtkCellArray::New();
 527     aConnectivity->Allocate( aCellsSize, 0 );
 528
 529     vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 530     aCellTypesArray->SetNumberOfComponents( 1 );
 531     aCellTypesArray->Allocate( aNbCells * aCellTypesArray->GetNumberOfComponents() );
 532
 533     vtkIdList *anIdList = vtkIdList::New();
 534     anIdList->SetNumberOfIds(2);
 535
 536     FreeEdges::TBorders::const_iterator anIter = aBorders.begin();
 537     for(; anIter != aBorders.end(); anIter++){
 538       const FreeEdges::Border& aBorder = *anIter;
 539       int aNode[2] = {
 540         myVisualObj->GetNodeVTKId(aBorder.myPntId[0]),
 541         myVisualObj->GetNodeVTKId(aBorder.myPntId[1])
 542       };
 543       //cout<<"aNode = "<<aBorder.myPntId[0]<<"; "<<aBorder.myPntId[1]<<endl;
 544       if(aNode[0] >= 0 && aNode[1] >= 0){
 545         anIdList->SetId( 0, aNode[0] );
 546         anIdList->SetId( 1, aNode[1] );
 547         aConnectivity->InsertNextCell( anIdList );
 548         aCellTypesArray->InsertNextValue( VTK_LINE );
 549       }
 550     }
 551
 552     VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 553     aCellLocationsArray->SetNumberOfComponents( 1 );
 554     aCellLocationsArray->SetNumberOfTuples( aNbCells );
 555
 556     aConnectivity->InitTraversal();
 557     for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
 558       aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
 559
 560     aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
 561
 562     SetUnstructuredGrid(aDataSet);
 563     aDataSet->Delete();
 564   }else if(FreeNodes* aFreeNodes = dynamic_cast<FreeNodes*>(theFunctor.get())){
 565     myExtractUnstructuredGrid->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 566     vtkIdType aNbNodes = myVisualObj->GetNbEntities(SMDSAbs_Node);
 567     for( vtkIdType i = 0; i < aNbNodes; i++ ){
 568       vtkIdType anObjId = myVisualObj->GetNodeObjId(i);
 569       if(aFreeNodes->IsSatisfy(anObjId))
 570         myExtractUnstructuredGrid->RegisterCell(i);
 571     }
 572     if(!myExtractUnstructuredGrid->IsCellsRegistered())
 573       myExtractUnstructuredGrid->RegisterCell(-1);
 574     SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
 575   }
 576 }
 577
 578
 579
 580
 581 unsigned long int
 582 SMESH_DeviceActor
 583 ::GetMTime()
 584 {
 585   unsigned long mTime = this->Superclass::GetMTime();
 586   mTime = max(mTime,myExtractGeometry->GetMTime());
 587   mTime = max(mTime,myExtractUnstructuredGrid->GetMTime());
 588   mTime = max(mTime,myMergeFilter->GetMTime());
 589   mTime = max(mTime,myGeomFilter->GetMTime());
 590   mTime = max(mTime,myTransformFilter->GetMTime());
 591   mTime = max(mTime,myFaceOrientationFilter->GetMTime());
 592   return mTime;
 593 }
 594
 595
 596 void
 597 SMESH_DeviceActor
 598 ::SetTransform(VTKViewer_Transform* theTransform)
 599 {
 600   myTransformFilter->SetTransform(theTransform);
 601 }
 602
 603
 604 void
 605 SMESH_DeviceActor
 606 ::SetShrink()
 607 {
 608   if ( !myIsShrinkable ) return;
 609   if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
 610   {
 611     myShrinkFilter->SetInput( aDataSet );
 612     myPassFilter[ 1 ]->SetInput( myShrinkFilter->GetOutput() );
 613     myIsShrunk = true;
 614   }
 615 }
 616
 617 void
 618 SMESH_DeviceActor
 619 ::UnShrink()
 620 {
 621   if ( !myIsShrunk ) return;
 622   if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
 623   {
 624     myPassFilter[ 1 ]->SetInput( aDataSet );
 625     myPassFilter[ 1 ]->Modified();
 626     myIsShrunk = false;
 627     Modified();
 628   }
 629 }
 630
 631
 632 void
 633 SMESH_DeviceActor
 634 ::SetFacesOriented(bool theIsFacesOriented)
 635 {
 636   if ( vtkDataSet* aDataSet = myPassFilter[ 1 ]->GetOutput() )
 637   {
 638     myIsFacesOriented = theIsFacesOriented;
 639     if( theIsFacesOriented )
 640       myFaceOrientationFilter->SetInput( aDataSet );
 641     UpdateFaceOrientation();
 642   }
 643 }
 644
 645 void
 646 SMESH_DeviceActor
 647 ::SetFacesOrientationColor(vtkFloatingPointType theColor[3])
 648 {
 649   myFaceOrientation->GetProperty()->SetColor( theColor );
 650 }
 651
 652 void
 653 SMESH_DeviceActor
 654 ::GetFacesOrientationColor(vtkFloatingPointType theColor[3])
 655 {
 656   myFaceOrientation->GetProperty()->GetColor( theColor );
 657 }
 658
 659 void
 660 SMESH_DeviceActor
 661 ::SetFacesOrientationScale(vtkFloatingPointType theScale)
 662 {
 663   myFaceOrientationFilter->SetOrientationScale( theScale );
 664 }
 665
 666 vtkFloatingPointType
 667 SMESH_DeviceActor
 668 ::GetFacesOrientationScale()
 669 {
 670   return myFaceOrientationFilter->GetOrientationScale();
 671 }
 672
 673 void
 674 SMESH_DeviceActor
 675 ::SetFacesOrientation3DVectors(bool theState)
 676 {
 677   myFaceOrientationFilter->Set3dVectors( theState );
 678 }
 679
 680 bool
 681 SMESH_DeviceActor
 682 ::GetFacesOrientation3DVectors()
 683 {
 684   return myFaceOrientationFilter->Get3dVectors();
 685 }
 686
 687 void
 688 SMESH_DeviceActor
 689 ::UpdateFaceOrientation()
 690 {
 691   bool aShowFaceOrientation = myIsFacesOriented;
 692   aShowFaceOrientation &= GetVisibility();
 693   aShowFaceOrientation &= myRepresentation == eSurface;
 694   myFaceOrientation->SetVisibility(aShowFaceOrientation);
 695 }
 696
 697
 698 void
 699 SMESH_DeviceActor
 700 ::SetRepresentation(EReperesent theMode)
 701 {
 702   switch(theMode){
 703   case ePoint:
 704     myGeomFilter->SetInside(true);
 705     myGeomFilter->SetWireframeMode(false);
 706     GetProperty()->SetRepresentation(0);
 707     break;
 708   case eWireframe:
 709     myGeomFilter->SetInside(false);
 710     myGeomFilter->SetWireframeMode(true);
 711     GetProperty()->SetRepresentation(theMode);
 712     break;
 713   case eInsideframe:
 714     myGeomFilter->SetInside(true);
 715     myGeomFilter->SetWireframeMode(true);
 716     GetProperty()->SetRepresentation(1);
 717     break;
 718   case eSurface:
 719     myGeomFilter->SetInside(false);
 720     myGeomFilter->SetWireframeMode(false);
 721     GetProperty()->SetRepresentation(theMode);
 722   }
 723   SetMarkerEnabled(theMode == ePoint);
 724   myRepresentation = theMode;
 725   UpdateFaceOrientation();
 726   GetProperty()->Modified();
 727   myMapper->Modified();
 728   Modified();
 729 }
 730
 731
 732 void
 733 SMESH_DeviceActor
 734 ::SetVisibility(int theMode)
 735 {
 736   if(!myExtractUnstructuredGrid->GetInput() ||
 737      GetUnstructuredGrid()->GetNumberOfCells())
 738   {
 739     vtkLODActor::SetVisibility(theMode);
 740   }else{
 741     vtkLODActor::SetVisibility(false);
 742   }
 743   UpdateFaceOrientation();
 744 }
 745
 746
 747 int
 748 SMESH_DeviceActor
 749 ::GetVisibility()
 750 {
 751   if(!GetUnstructuredGrid()->GetNumberOfCells()){
 752     vtkLODActor::SetVisibility(false);
 753   }
 754   return vtkLODActor::GetVisibility();
 755 }
 756
 757
 758 void
 759 SMESH_DeviceActor
 760 ::AddToRender(vtkRenderer* theRenderer)
 761 {
 762   theRenderer->AddActor(this);
 763   theRenderer->AddActor(myFaceOrientation);
 764 }
 765
 766 void
 767 SMESH_DeviceActor
 768 ::RemoveFromRender(vtkRenderer* theRenderer)
 769 {
 770   theRenderer->RemoveActor(this);
 771   theRenderer->RemoveActor(myFaceOrientation);
 772 }
 773
 774
 775 int
 776 SMESH_DeviceActor
 777 ::GetNodeObjId(int theVtkID)
 778 {
 779   vtkIdType anID = theVtkID;
 780
 781   if(IsImplicitFunctionUsed())
 782     anID = myExtractGeometry->GetNodeObjId(theVtkID);
 783
 784   vtkIdType aRetID = myVisualObj->GetNodeObjId(anID);
 785   if(MYDEBUG) MESSAGE("GetNodeObjId - theVtkID = "<<theVtkID<<"; anID = "<<anID<<"; aRetID = "<<aRetID);
 786   return aRetID;
 787 }
 788
 789 vtkFloatingPointType*
 790 SMESH_DeviceActor
 791 ::GetNodeCoord(int theObjID)
 792 {
 793   vtkDataSet* aDataSet = myMergeFilter->GetOutput();
 794   vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
 795   vtkFloatingPointType* aCoord = (anID >=0) ? aDataSet->GetPoint(anID) : NULL;
 796   if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
 797   return aCoord;
 798 }
 799
 800
 801 int
 802 SMESH_DeviceActor
 803 ::GetElemObjId(int theVtkID)
 804 {
 805   vtkIdType anId = myGeomFilter->GetElemObjId(theVtkID);
 806   if(anId < 0)
 807     return -1;
 808
 809   vtkIdType anId2 = anId;
 810   if(IsImplicitFunctionUsed())
 811     anId2 = myExtractGeometry->GetElemObjId(anId);
 812   if(anId2 < 0)
 813     return -1;
 814
 815   vtkIdType anId3 = myExtractUnstructuredGrid->GetInputId(anId2);
 816   if(anId3 < 0)
 817     return -1;
 818
 819   vtkIdType aRetID = myVisualObj->GetElemObjId(anId3);
 820   if(MYDEBUG)
 821      MESSAGE("GetElemObjId - theVtkID = "<<theVtkID<<"; anId2 = "<<anId2<<"; anId3 = "<<anId3<<"; aRetID = "<<aRetID);
 822   return aRetID;
 823 }
 824
 825 vtkCell*
 826 SMESH_DeviceActor
 827 ::GetElemCell(int theObjID)
 828 {
 829   vtkDataSet* aDataSet = myVisualObj->GetUnstructuredGrid();
 830   vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID);
 831   vtkCell* aCell = (aGridID >= 0 ) ? aDataSet->GetCell(aGridID) : NULL;
 832   if(MYDEBUG)
 833     MESSAGE("GetElemCell - theObjID = "<<theObjID<<"; aGridID = "<<aGridID);
 834   return aCell;
 835 }
 836
 837
 838 vtkFloatingPointType
 839 SMESH_DeviceActor
 840 ::GetShrinkFactor()
 841 {
 842   return myShrinkFilter->GetShrinkFactor();
 843 }
 844
 845 void
 846 SMESH_DeviceActor
 847 ::SetShrinkFactor(vtkFloatingPointType theValue)
 848 {
 849   theValue = theValue > 0.1? theValue: 0.8;
 850   myShrinkFilter->SetShrinkFactor(theValue);
 851   Modified();
 852 }
 853
 854
 855 void
 856 SMESH_DeviceActor
 857 ::SetHighlited(bool theIsHighlited)
 858 {
 859   if ( myIsHighlited == theIsHighlited )
 860     return;
 861   myIsHighlited = theIsHighlited;
 862   Modified();
 863 }
 864
 865 void
 866 SMESH_DeviceActor
 867 ::Render(vtkRenderer *ren, vtkMapper* m)
 868 {
 869   int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
 870   vtkFloatingPointType aStoredFactor, aStoredUnit;
 871   vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
 872
 873   vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
 874   vtkFloatingPointType aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
 875   if(myIsHighlited){
 876     static vtkFloatingPointType EPS = .01;
 877     aUnits *= (1.0-EPS);
 878   }
 879   vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits);
 880   vtkLODActor::Render(ren,m);
 881
 882   vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
 883   vtkMapper::SetResolveCoincidentTopology(aResolveCoincidentTopology);
 884 }
 885
 886
 887 void
 888 SMESH_DeviceActor
 889 ::SetPolygonOffsetParameters(vtkFloatingPointType factor,
 890                              vtkFloatingPointType units)
 891 {
 892   myPolygonOffsetFactor = factor;
 893   myPolygonOffsetUnits = units;
 894 }
 895
 896 /*!
 897  * On/Off representation 2D quadratic element as arked polygon
 898  */
 899 void SMESH_DeviceActor::SetQuadraticArcMode(bool theFlag){
 900   myGeomFilter->SetQuadraticArcMode(theFlag);
 901 }
 902
 903 /*!
 904  * Return true if 2D quadratic element displayed as arked polygon
 905  */
 906 bool SMESH_DeviceActor::GetQuadraticArcMode(){
 907   return myGeomFilter->GetQuadraticArcMode();
 908 }
 909 /*!
 910  * Set Max angle for representation 2D quadratic element as arked polygon
 911  */
 912 void SMESH_DeviceActor::SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle){
 913   myGeomFilter->SetQuadraticArcAngle(theMaxAngle);
 914 }
 915
 916 /*!
 917  * Return Max angle of the representation 2D quadratic element as arked polygon
 918  */
 919 vtkFloatingPointType SMESH_DeviceActor::GetQuadraticArcAngle(){
 920   return myGeomFilter->GetQuadraticArcAngle();
 921 }
 922
 923 /*!
 924  * Set point marker enabled
 925  * \param theMarkerEnabled flag to enable/disable point marker
 926  */
 927 void SMESH_DeviceActor::SetMarkerEnabled( bool theMarkerEnabled )
 928 {
 929   myMapper->SetMarkerEnabled( theMarkerEnabled );
 930 }
 931
 932 /*!
 933  * Set standard point marker
 934  * \param theMarkerType type of the marker
 935  */
 936 void SMESH_DeviceActor::SetMarkerStd( VTK::MarkerType theMarkerType, VTK::MarkerScale theMarkerScale )
 937 {
 938   myMapper->SetMarkerStd( theMarkerType, theMarkerScale );
 939 }
 940
 941 /*!
 942  * Set custom point marker
 943  * \param theMarkerId id of the marker texture
 944  * \param theMarkerTexture marker texture
 945  */
 946 void SMESH_DeviceActor::SetMarkerTexture( int theMarkerId, VTK::MarkerTexture theMarkerTexture )
 947 {
 948   myMapper->SetMarkerTexture( theMarkerId, theMarkerTexture );
 949 }
 950
 951 /*!
 952  * Get type of the point marker
 953  * \return type of the point marker
 954  */
 955 VTK::MarkerType SMESH_DeviceActor::GetMarkerType()
 956 {
 957   return myMapper->GetMarkerType();
 958 }
 959
 960 /*!
 961   Get scale of the point marker
 962   \return scale of the point marker
 963 */
 964 VTK::MarkerScale SMESH_DeviceActor::GetMarkerScale()
 965 {
 966   return myMapper->GetMarkerScale();
 967 }
 968
 969 /*!
 970  * Get texture identifier of the point marker
 971  * \return texture identifier of the point marker
 972  */
 973 int SMESH_DeviceActor::GetMarkerTexture()
 974 {
 975   return myMapper->GetMarkerTexture();
 976 }