src/SVTK/SVTK_DeviceActor.cxx

   1 // Copyright (C) 2007-2015  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, or (at your option) any later version.
  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 //  SVTK OBJECT : interactive object for SVTK visualization
  24 //  File   : SVTK_DeviceActor.cxx
  25 //  Author :
  26
  27 #include "SVTK_DeviceActor.h"
  28
  29 #include "VTKViewer_Transform.h"
  30 #include "VTKViewer_TransformFilter.h"
  31 #include "VTKViewer_GeometryFilter.h"
  32
  33 // VTK Includes
  34 #include <vtkObjectFactory.h>
  35 #include <vtkShrinkFilter.h>
  36 #include <vtkFeatureEdges.h>
  37
  38 #include <vtkPolyData.h>
  39 #include <vtkUnstructuredGrid.h>
  40
  41 #include <VTKViewer_PolyDataMapper.h>
  42 #include <VTKViewer_DataSetMapper.h>
  43
  44 #include <vtkPassThroughFilter.h>
  45
  46 vtkStandardNewMacro(SVTK_DeviceActor);
  47
  48 /*!
  49   Constructor
  50 */
  51 SVTK_DeviceActor
  52 ::SVTK_DeviceActor()
  53 {
  54   myIsShrunk = false;
  55   myIsShrinkable = true;
  56
  57   myIsFeatureEdgesAllowed = false;
  58   myIsFeatureEdgesEnabled = false;
  59
  60   myIsShaded = true;
  61   myProperty = vtkProperty::New();
  62   myRepresentation = VTKViewer::Representation::Surface;
  63
  64   myIsResolveCoincidentTopology = true;
  65   vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(myPolygonOffsetFactor,
  66                                                                  myPolygonOffsetUnits);
  67
  68   myMapper = VTKViewer_DataSetMapper::New();
  69
  70   myShrinkFilter = vtkShrinkFilter::New();
  71
  72   myFeatureEdges = vtkFeatureEdges::New();
  73
  74   myGeomFilter = VTKViewer_GeometryFilter::New();
  75
  76   myTransformFilter = VTKViewer_TransformFilter::New();
  77
  78   for(int i = 0; i < 6; i++)
  79     myPassFilter.push_back(vtkPassThroughFilter::New());
  80 }
  81
  82 /*!
  83   Destructor
  84 */
  85 SVTK_DeviceActor
  86 ::~SVTK_DeviceActor()
  87 {
  88   myMapper->Delete();
  89
  90   myProperty->Delete();
  91
  92   myGeomFilter->Delete();
  93
  94   myTransformFilter->Delete();
  95
  96   myShrinkFilter->Delete();
  97
  98   myFeatureEdges->Delete();
  99
 100   for(int i = 0, iEnd = myPassFilter.size(); i < iEnd; i++)
 101     myPassFilter[i]->Delete();
 102 }
 103
 104 /*!
 105   To insert some additional filters and then sets the given vtkMapper
 106 */
 107 void
 108 SVTK_DeviceActor
 109 ::SetMapper(vtkMapper* theMapper)
 110 {
 111   InitPipeLine(theMapper);
 112 }
 113
 114 /*!
 115   To initialize internal pipeline
 116 */
 117 void
 118 SVTK_DeviceActor
 119 ::InitPipeLine(vtkMapper* theMapper)
 120 {
 121   if(theMapper){
 122     int anId = 0;
 123     myPassFilter[ anId ]->SetInputConnection( theMapper->GetInputConnection( 0, 0 ) );
 124     myPassFilter[ anId + 1]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 125
 126     anId++; // 1
 127     myGeomFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 128
 129     anId++; // 2
 130     myPassFilter[ anId ]->SetInputConnection( myGeomFilter->GetOutputPort() );
 131     myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 132
 133     anId++; // 3
 134     myTransformFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 135
 136     anId++; // 4
 137     myPassFilter[ anId ]->SetInputConnection( myTransformFilter->GetOutputPort() );
 138     myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 139
 140     anId++; // 5
 141     theMapper->SetInputConnection(myPassFilter[anId]->GetOutputPort());
 142   }
 143   Superclass::SetMapper(theMapper);
 144 }
 145
 146 /*!
 147   Allows to get initial vtkDataSet
 148 */
 149 vtkDataSet*
 150 SVTK_DeviceActor
 151 ::GetInput()
 152 {
 153   return myPassFilter.front()->GetOutput();
 154 }
 155
 156 /*!
 157   Allows to set initial vtkDataSet
 158 */
 159 void
 160 SVTK_DeviceActor
 161 ::SetInputData(vtkDataSet* theDataSet)
 162 {
 163   myMapper->SetInputData(theDataSet);
 164   InitPipeLine(myMapper);
 165 }
 166
 167 /*!
 168   Allows to set initial vtkDataSet
 169 */
 170 void
 171 SVTK_DeviceActor
 172 ::SetInputConnection(vtkAlgorithmOutput* theAlgorithmOutput)
 173 {
 174   myMapper->SetInputConnection(theAlgorithmOutput);
 175   InitPipeLine(myMapper);
 176 }
 177
 178 /*!
 179   To provide VTK to Object and backward mapping
 180 */
 181 void
 182 SVTK_DeviceActor::
 183 SetStoreMapping(bool theStoreMapping)
 184 {
 185   myGeomFilter->SetStoreMapping(theStoreMapping);
 186 }
 187
 188
 189 /*!
 190   \return time of modification
 191 */
 192 unsigned long int
 193 SVTK_DeviceActor
 194 ::GetMTime()
 195 {
 196   unsigned long mTime = this->Superclass::GetMTime();
 197
 198   mTime = std::max(mTime,myGeomFilter->GetMTime());
 199
 200   mTime = std::max(mTime,myTransformFilter->GetMTime());
 201
 202   if(myIsShrunk)
 203     mTime = std::max(mTime,myShrinkFilter->GetMTime());
 204
 205   if(myIsFeatureEdgesEnabled)
 206     mTime = std::max(mTime,myFeatureEdges->GetMTime());
 207
 208   for(int i = 0, iEnd = myPassFilter.size(); i < iEnd; i++)
 209     std::max(mTime,myPassFilter[i]->GetMTime());
 210
 211   return mTime;
 212 }
 213
 214 /*!
 215   Apply a view transformation
 216   \param theTransform - transformation
 217 */
 218 void
 219 SVTK_DeviceActor
 220 ::SetTransform(VTKViewer_Transform* theTransform)
 221 {
 222   myTransformFilter->SetTransform(theTransform);
 223 }
 224
 225 /*!
 226   \return true if actor is shrinkable
 227 */
 228 bool
 229 SVTK_DeviceActor
 230 ::IsShrunkable()
 231 {
 232   return myIsShrinkable;
 233 }
 234
 235 /*!
 236   Changes shrinkable state of actor
 237   theIsShrinkable - new shrinkable state
 238 */
 239 void
 240 SVTK_DeviceActor
 241 ::SetShrinkable(bool theIsShrinkable)
 242 {
 243   myIsShrinkable = theIsShrinkable;
 244 }
 245
 246 /*!
 247   \return true if actor is shrunkable
 248 */
 249 bool
 250 SVTK_DeviceActor
 251 ::IsShrunk()
 252 {
 253   return myIsShrunk;
 254 }
 255
 256 /*!
 257   Insert shrink filter into pipeline
 258 */
 259 void
 260 SVTK_DeviceActor
 261 ::SetShrink()
 262 {
 263   if ( !myIsShrinkable )
 264     return;
 265
 266   if ( vtkAlgorithmOutput* anOutput = myPassFilter[ 0 ]->GetOutputPort() )
 267   {
 268     myPassFilter[ 0 ]->Update();
 269     if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
 270     {
 271       int numCells=aDataSet->GetNumberOfCells();
 272       int numPts = aDataSet->GetNumberOfPoints();
 273       //It's impossible to use to apply "shrink" for "empty" dataset
 274       if (numCells < 1 || numPts < 1)
 275         return;
 276     }
 277     myShrinkFilter->SetInputConnection( anOutput );
 278     myPassFilter[ 1 ]->SetInputConnection( myShrinkFilter->GetOutputPort() );
 279     myIsShrunk = true;
 280   }
 281 }
 282
 283 /*!
 284   Remove shrink filter from pipeline
 285 */
 286 void
 287 SVTK_DeviceActor
 288 ::UnShrink()
 289 {
 290   if ( !myIsShrunk ) return;
 291   if ( vtkAlgorithmOutput* anOutput = myPassFilter[ 0 ]->GetOutputPort() )
 292   {
 293     myPassFilter[ 1 ]->SetInputConnection( anOutput );
 294     myIsShrunk = false;
 295   }
 296 }
 297
 298 /*!
 299   \return shrink factor
 300 */
 301 double
 302 SVTK_DeviceActor
 303 ::GetShrinkFactor()
 304 {
 305   return myShrinkFilter->GetShrinkFactor();
 306 }
 307
 308 /*!
 309   Changes shrink factor
 310   \param theValue - new shrink factor
 311 */
 312 void
 313 SVTK_DeviceActor
 314 ::SetShrinkFactor(double theValue)
 315 {
 316   myShrinkFilter->SetShrinkFactor(theValue);
 317 }
 318
 319 /*!
 320   \return true if feature edges are allowed for this actor
 321 */
 322 bool
 323 SVTK_DeviceActor
 324 ::IsFeatureEdgesAllowed()
 325 {
 326   return myIsFeatureEdgesAllowed;
 327 }
 328
 329 /*!
 330   Allows feature edges for this actor on or off
 331   \param theIsFeatureEdgesAllowed - flag which allows feature edges for this actor on or off
 332 */
 333 void
 334 SVTK_DeviceActor
 335 ::SetFeatureEdgesAllowed(bool theIsFeatureEdgesAllowed)
 336 {
 337   myIsFeatureEdgesAllowed = theIsFeatureEdgesAllowed;
 338 }
 339
 340 /*!
 341   \return true if feature edges are enabled
 342 */
 343 bool
 344 SVTK_DeviceActor
 345 ::IsFeatureEdgesEnabled()
 346 {
 347   return myIsFeatureEdgesEnabled;
 348 }
 349
 350 /*!
 351   Enables feature edges on or off
 352   \param theIsFeatureEdgesEnabled - flag which enables feature edges on or off
 353 */
 354 void
 355 SVTK_DeviceActor
 356 ::SetFeatureEdgesEnabled(bool theIsFeatureEdgesEnabled)
 357 {
 358   if ( !myIsFeatureEdgesAllowed || myIsFeatureEdgesEnabled == theIsFeatureEdgesEnabled )
 359     return;
 360
 361   if ( vtkAlgorithmOutput* aPolyData = myPassFilter[ 2 ]->GetOutputPort() )
 362   {
 363     if( theIsFeatureEdgesEnabled )
 364     {
 365       myPassFilter[ 2 ]->Update();
 366       myFeatureEdges->SetInputConnection( aPolyData );
 367       myPassFilter[ 3 ]->SetInputConnection( myFeatureEdges->GetOutputPort() );
 368       myIsFeatureEdgesEnabled = true;
 369     }
 370     else
 371     {
 372       myPassFilter[3]->SetInputConnection( aPolyData );
 373       myIsFeatureEdgesEnabled = false;
 374     }
 375     myIsFeatureEdgesEnabled = theIsFeatureEdgesEnabled;
 376   }
 377 }
 378
 379 /*!
 380   \return angle of feature edges' filter
 381 */
 382 double
 383 SVTK_DeviceActor
 384 ::GetFeatureEdgesAngle()
 385 {
 386   return myFeatureEdges->GetFeatureAngle();
 387 }
 388
 389 /*!
 390   Sets angle of feature edges' filter
 391   \param theAngle angle of feature edges' filter
 392 */
 393 void
 394 SVTK_DeviceActor
 395 ::SetFeatureEdgesAngle(double theAngle)
 396 {
 397   myFeatureEdges->SetFeatureAngle(theAngle);
 398 }
 399
 400 /*!
 401   Gets information about kinds of edges which are displayed by feature edges' filter
 402   \param theIsFeatureEdges flag which shows whether feature edges are displayed
 403   \param theIsBoundaryEdges flag which shows whether boundary edges are displayed
 404   \param theIsManifoldEdges flag which shows whether manifold edges are displayed
 405   \param theIsNonManifoldEdges flag which shows whether non-manifold edges are displayed
 406 */
 407 void
 408 SVTK_DeviceActor
 409 ::GetFeatureEdgesFlags(bool& theIsFeatureEdges,
 410                        bool& theIsBoundaryEdges,
 411                        bool& theIsManifoldEdges,
 412                        bool& theIsNonManifoldEdges)
 413 {
 414   theIsFeatureEdges = myFeatureEdges->GetFeatureEdges();
 415   theIsBoundaryEdges = myFeatureEdges->GetBoundaryEdges();
 416   theIsManifoldEdges = myFeatureEdges->GetManifoldEdges();
 417   theIsNonManifoldEdges = myFeatureEdges->GetNonManifoldEdges();
 418 }
 419
 420 /*!
 421   Sets different kinds of edges to be displayed by feature edges' filter
 422   \param theIsFeatureEdges flag which displays feature edges
 423   \param theIsBoundaryEdges flag which displays boundary edges
 424   \param theIsManifoldEdges flag which displays manifold edges
 425   \param theIsNonManifoldEdges flag which displays non-manifold edges
 426 */
 427 void
 428 SVTK_DeviceActor
 429 ::SetFeatureEdgesFlags(bool theIsFeatureEdges,
 430                        bool theIsBoundaryEdges,
 431                        bool theIsManifoldEdges,
 432                        bool theIsNonManifoldEdges)
 433 {
 434   myFeatureEdges->SetFeatureEdges(theIsFeatureEdges);
 435   myFeatureEdges->SetBoundaryEdges(theIsBoundaryEdges);
 436   myFeatureEdges->SetManifoldEdges(theIsManifoldEdges);
 437   myFeatureEdges->SetNonManifoldEdges(theIsNonManifoldEdges);
 438 }
 439
 440 /*!
 441   \return feature edges' coloring flag
 442 */
 443 bool
 444 SVTK_DeviceActor
 445 ::GetFeatureEdgesColoring()
 446 {
 447   return myFeatureEdges->GetColoring();
 448 }
 449
 450 /*!
 451   Sets feature edges' coloring flag
 452   \param theIsColoring feature edges' coloring flag
 453 */
 454 void
 455 SVTK_DeviceActor
 456 ::SetFeatureEdgesColoring(bool theIsColoring)
 457 {
 458   myFeatureEdges->SetColoring(theIsColoring);
 459 }
 460
 461 /*!
 462   Set representation (VTK_SURFACE, VTK_POINTS, VTK_WIREFRAME and so on)
 463   param theMode - new mode
 464 */
 465 void
 466 SVTK_DeviceActor
 467 ::SetRepresentation(VTKViewer::Representation::Type theMode)
 468 {
 469   using namespace VTKViewer::Representation;
 470   if(IsShaded()){
 471     switch(myRepresentation){
 472     case Points :
 473     case Surface :
 474     case SurfaceWithEdges :
 475       myProperty->SetAmbient(GetProperty()->GetAmbient());
 476       myProperty->SetDiffuse(GetProperty()->GetDiffuse());
 477       myProperty->SetSpecular(GetProperty()->GetSpecular());
 478     }
 479
 480     switch(theMode){
 481     case Points :
 482     case Surface :
 483     case SurfaceWithEdges :
 484       GetProperty()->SetAmbient(myProperty->GetAmbient());
 485       GetProperty()->SetDiffuse(myProperty->GetDiffuse());
 486       GetProperty()->SetSpecular(myProperty->GetSpecular());
 487       break;
 488     default:
 489       GetProperty()->SetAmbient(1.0);
 490       GetProperty()->SetDiffuse(0.0);
 491       GetProperty()->SetSpecular(0.0);
 492     }
 493   }
 494
 495   switch(theMode){
 496   case Insideframe :
 497     myGeomFilter->SetInside(true);
 498     myGeomFilter->SetWireframeMode(true);
 499     GetProperty()->SetRepresentation(VTK_WIREFRAME);
 500     break;
 501   case Points :
 502     GetProperty()->SetPointSize(GetDefaultPointSize());
 503     GetProperty()->SetRepresentation(VTK_POINTS);
 504     myGeomFilter->SetWireframeMode(false);
 505     myGeomFilter->SetInside(false);
 506     break;
 507   case Wireframe :
 508     GetProperty()->SetRepresentation(VTK_WIREFRAME);
 509     myGeomFilter->SetWireframeMode(true);
 510     myGeomFilter->SetInside(false);
 511     break;
 512   case Surface :
 513   case SurfaceWithEdges :
 514     GetProperty()->SetRepresentation(VTK_SURFACE);
 515     myGeomFilter->SetWireframeMode(false);
 516     myGeomFilter->SetInside(false);
 517     break;
 518   }
 519
 520   SetMarkerEnabled( theMode == Points );
 521
 522   myRepresentation = theMode;
 523 }
 524
 525 /*!
 526   \return current representation mode
 527 */
 528 VTKViewer::Representation::Type
 529 SVTK_DeviceActor
 530 ::GetRepresentation()
 531 {
 532   return myRepresentation;
 533 }
 534
 535 /*!
 536   \return default point size
 537 */
 538 double
 539 SVTK_DeviceActor
 540 ::GetDefaultPointSize()
 541 {
 542   return 5;
 543 }
 544
 545 /*!
 546   \return default line width
 547 */
 548 double
 549 SVTK_DeviceActor
 550 ::GetDefaultLineWidth()
 551 {
 552   return 3;
 553 }
 554
 555 /*!
 556   \return true if actor is shaded
 557 */
 558 bool
 559 SVTK_DeviceActor
 560 ::IsShaded()
 561 {
 562   return myIsShaded;
 563 }
 564
 565 /*!
 566   Sets shaded state of actor
 567   \param theShaded - new shaded state
 568 */
 569 void
 570 SVTK_DeviceActor
 571 ::SetShaded(bool theShaded)
 572 {
 573   myIsShaded = theShaded;
 574 }
 575
 576 /*!
 577   Maps VTK index of a node to corresponding object index
 578 */
 579 int
 580 SVTK_DeviceActor
 581 ::GetNodeObjId(int theVtkID)
 582 {
 583   return theVtkID;
 584 }
 585
 586 /*!
 587   Get coordinates of a node for given object index
 588 */
 589 double*
 590 SVTK_DeviceActor
 591 ::GetNodeCoord(int theObjID)
 592 {
 593   return GetInput()->GetPoint(theObjID);
 594 }
 595
 596
 597 /*!
 598   Get corresponding #vtkCell for given object index
 599 */
 600 vtkCell*
 601 SVTK_DeviceActor
 602 ::GetElemCell(int theObjID)
 603 {
 604   return GetInput()->GetCell(theObjID);
 605 }
 606
 607 /*!
 608   Maps VTK index of a cell to corresponding object index
 609 */
 610 int
 611 SVTK_DeviceActor
 612 ::GetElemObjId(int theVtkID)
 613 {
 614   return theVtkID;
 615 }
 616
 617 /*!
 618   Renders actor
 619 */
 620 void
 621 SVTK_DeviceActor
 622 ::Render(vtkRenderer *ren, vtkMapper* m)
 623 {
 624   int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
 625   double aFactor, aUnit;
 626   vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnit);
 627
 628   double aNewFactor = myPolygonOffsetFactor, aNewUnit = myPolygonOffsetUnits;
 629   if(!myIsResolveCoincidentTopology){
 630     static double EPS = .01;
 631     aNewFactor *= (1.0-EPS);
 632     aNewUnit *= (1.0-EPS);
 633   }
 634
 635   vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
 636   vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aNewFactor,
 637                                                                  aNewUnit);
 638   Superclass::Render(ren,m);
 639
 640   vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnit);
 641   vtkMapper::SetResolveCoincidentTopology(aResolveCoincidentTopology);
 642 }
 643
 644 /*!
 645   Set polygon offset parameters
 646   \param factor, units  - Opengl polygon offset parameters
 647 */
 648 void
 649 SVTK_DeviceActor
 650 ::SetPolygonOffsetParameters(double factor,
 651                              double units)
 652 {
 653   myPolygonOffsetFactor = factor;
 654   myPolygonOffsetUnits = units;
 655 }
 656
 657 /*!
 658   Get polygon offset parameters
 659   \param factor, units  - Opengl polygon offset parameters
 660 */
 661 void
 662 SVTK_DeviceActor
 663 ::GetPolygonOffsetParameters(double& factor,
 664                              double& units)
 665 {
 666   factor = myPolygonOffsetFactor;
 667   units = myPolygonOffsetUnits;
 668 }
 669
 670 VTKViewer_DataSetMapper* SVTK_DeviceActor::GetDataSetMapper()
 671 {
 672   return myMapper;
 673 }
 674
 675 /*!
 676  * On/Off representation 2D quadratic element as arked polygon
 677  */
 678 void SVTK_DeviceActor::SetQuadraticArcMode(bool theFlag){
 679   myGeomFilter->SetQuadraticArcMode(theFlag);
 680 }
 681
 682 /*!
 683  * Return true if 2D quadratic element displayed as arked polygon
 684  */
 685 bool SVTK_DeviceActor::GetQuadraticArcMode(){
 686   return myGeomFilter->GetQuadraticArcMode();
 687 }
 688 /*!
 689  * Set Max angle for representation 2D quadratic element as arked polygon
 690  */
 691 void SVTK_DeviceActor::SetQuadraticArcAngle(double theMaxAngle){
 692   myGeomFilter->SetQuadraticArcAngle(theMaxAngle);
 693 }
 694
 695 /*!
 696  * Return Max angle of the representation 2D quadratic element as arked polygon
 697  */
 698 double SVTK_DeviceActor::GetQuadraticArcAngle(){
 699   return myGeomFilter->GetQuadraticArcAngle();
 700 }
 701
 702 /*!
 703  * Set ball drawing enabled
 704  * \param theBallEnabled flag to enable/disable balls
 705  */
 706 void SVTK_DeviceActor::SetBallEnabled( bool theBallEnabled ) {
 707   myMapper->SetBallEnabled( theBallEnabled );
 708 }
 709
 710 /*!
 711  * Set point marker enabled
 712  * \param theMarkerEnabled flag to enable/disable point marker
 713  */
 714 void SVTK_DeviceActor::SetMarkerEnabled( bool theMarkerEnabled )
 715 {
 716   myMapper->SetMarkerEnabled( theMarkerEnabled );
 717 }
 718
 719 /*!
 720  * Set standard point marker
 721  * \param theMarkerType type of the marker
 722  * \param theMarkerScale scale of the marker
 723  */
 724 void SVTK_DeviceActor::SetMarkerStd( VTK::MarkerType theMarkerType, VTK::MarkerScale theMarkerScale )
 725 {
 726   myMapper->SetMarkerStd( theMarkerType, theMarkerScale );
 727 }
 728
 729 /*!
 730  * Set custom point marker
 731  * \param theMarkerId id of the marker texture
 732  * \param theMarkerTexture marker texture
 733  */
 734 void SVTK_DeviceActor::SetMarkerTexture( int theMarkerId, VTK::MarkerTexture theMarkerTexture )
 735 {
 736   myMapper->SetMarkerTexture( theMarkerId, theMarkerTexture );
 737 }
 738
 739 /*!
 740  * Get type of the point marker
 741  * \return type of the point marker
 742  */
 743 VTK::MarkerType SVTK_DeviceActor::GetMarkerType()
 744 {
 745   return myMapper->GetMarkerType();
 746 }
 747
 748 /*!
 749   Get scale of the point marker
 750   \return scale of the point marker
 751 */
 752 VTK::MarkerScale SVTK_DeviceActor::GetMarkerScale()
 753 {
 754   return myMapper->GetMarkerScale();
 755 }
 756
 757 /*!
 758  * Get texture identifier of the point marker
 759  * \return texture identifier of the point marker
 760  */
 761 int SVTK_DeviceActor::GetMarkerTexture()
 762 {
 763   return myMapper->GetMarkerTexture();
 764 }
 765
 766 void SVTK_DeviceActor::SetCoincident3DAllowed(bool theFlag) {
 767   myGeomFilter->SetAppendCoincident3D(theFlag);
 768 }
 769
 770 bool SVTK_DeviceActor::IsCoincident3DAllowed() const {
 771   return myGeomFilter->GetAppendCoincident3D();
 772 }
 773
 774 void
 775 SVTK_DeviceActor
 776 ::SetResolveCoincidentTopology(bool theIsResolve)
 777 {
 778   myIsResolveCoincidentTopology = theIsResolve;
 779 }