src/OBJECT/GEOM_Actor.cxx

   1 // Copyright (C) 2007-2013  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 //  GEOM OBJECT : interactive object for Geometry entities visualization
  24 //  File   : GEOM_Actor.cxx
  25 //  Author : Christophe ATTANASIO
  26 //  Module : GEOM
  27 //
  28 /*!
  29   \class GEOM_Actor GEOM_Actor.h
  30   \brief This class allows to display an OpenCASCADE CAD model in a VTK viewer.
  31 */
  32 #include "GEOM_Actor.h"
  33
  34 #include "GEOM_DeviceActor.h"
  35 #include "GEOM_VertexSource.h"
  36 #include "GEOM_EdgeSource.h"
  37 #include "GEOM_WireframeFace.h"
  38 #include "GEOM_ShadingFace.h"
  39 #include "GEOM_PainterPolyDataMapper.h"
  40 #include "SVTK_Actor.h"
  41
  42 #include <OCC2VTK_Tools.h>
  43
  44 #include <vtkObjectFactory.h>
  45 #include <vtkRenderer.h>
  46 #include <vtkProperty.h>
  47 #include <vtkPointPicker.h>
  48 #include <vtkCellPicker.h>
  49
  50 #include <TopAbs_ShapeEnum.hxx>
  51 #include <TopExp_Explorer.hxx>
  52 #include <TopoDS.hxx>
  53 #include <BRep_Tool.hxx>
  54 #include <TopExp.hxx>
  55
  56 #include <vtkPolyDataWriter.h>
  57
  58 #include <vtkAppendPolyData.h>
  59 #include <vtkPolyDataMapper.h>
  60 #include <vtkPolyData.h>
  61 #include <vtkTransform.h>
  62 #include <vtkMatrix4x4.h>
  63 #include <vtkMath.h>
  64 #include <vtkCamera.h>
  65
  66 #include "utilities.h"
  67
  68 #include "SALOME_InteractiveObject.hxx"
  69
  70 //vtkStandardNewMacro(GEOM_Actor);
  71
  72 #ifndef MYDEBUG
  73 //#define MYDEBUG
  74 #endif
  75
  76 GEOM_Actor::GEOM_Actor():
  77   isOnlyVertex(false),
  78
  79   myDeflection(-1),
  80   myIsForced(false),
  81
  82   //  myDisplayMode(eWireframe),
  83   myIsSelected(false),
  84   myVectorMode(false),
  85
  86   myVertexActor(GEOM_DeviceActor::New(),true),
  87   myVertexSource(GEOM_VertexSource::New(),true),
  88
  89   myIsolatedEdgeActor(GEOM_DeviceActor::New(),true),
  90   myIsolatedEdgeSource(GEOM_EdgeSource::New(),true),
  91
  92   myOneFaceEdgeActor(GEOM_DeviceActor::New(),true),
  93   myOneFaceEdgeSource(GEOM_EdgeSource::New(),true),
  94
  95   mySharedEdgeActor(GEOM_DeviceActor::New(),true),
  96   mySharedEdgeSource(GEOM_EdgeSource::New(),true),
  97
  98   myWireframeFaceActor(GEOM_DeviceActor::New(),true),
  99   myWireframeFaceSource(GEOM_WireframeFace::New(),true),
 100
 101   myShadingFaceActor(GEOM_DeviceActor::New(),true),
 102   myShadingFaceSource(GEOM_ShadingFace::New(),true),
 103
 104   myHighlightActor(GEOM_DeviceActor::New(),true),
 105   myAppendFilter(vtkAppendPolyData::New(),true),
 106   // Use mapper as an instance of GEOM_PainterPolyDataMapper class
 107   // to prevent drawing of mappers' content (due to an empty definition
 108   // of GEOM_PainterPolyDataMapper::RenderPiece(...)).
 109   // !!! Presentation of GEOM_Actor is drawing only with help of actors
 110   // defined in this class !!!
 111   myPolyDataMapper(GEOM_PainterPolyDataMapper::New(),true),
 112
 113   myHighlightProp(vtkProperty::New()),
 114   myPreHighlightProp(vtkProperty::New()),
 115   myShadingFaceProp(vtkProperty::New()),
 116   myShadingBackFaceProp(vtkProperty::New())
 117 {
 118 #ifdef MYDEBUG
 119   MESSAGE (this<< " GEOM_Actor::GEOM_Actor");
 120 #endif
 121
 122   myPolyDataMapper->SetInputConnection(myAppendFilter->GetOutputPort());
 123   vtkProperty* aProperty;
 124
 125   myHighlightProp->SetAmbient(0.5);
 126   myHighlightProp->SetDiffuse(0.3);
 127   myHighlightProp->SetSpecular(0.2);
 128   myHighlightProp->SetRepresentationToSurface();
 129   myHighlightProp->SetAmbientColor(1, 1, 1);
 130   myHighlightProp->SetDiffuseColor(1, 1, 1);
 131   myHighlightProp->SetSpecularColor(0.5, 0.5, 0.5);
 132   myHighlightProp->SetPointSize(SALOME_POINT_SIZE);
 133   myHighlightActor->SetProperty(myHighlightProp.GetPointer());
 134
 135   this->myHighlightActor->SetInput(myAppendFilter->GetOutputPort(),false);
 136
 137   myPreHighlightProp->SetColor(0,1,1);
 138   myPreHighlightProp->SetPointSize(SALOME_POINT_SIZE+2);
 139   myPreHighlightProp->SetLineWidth(SALOME_LINE_WIDTH+1);
 140   myPreHighlightProp->SetRepresentationToWireframe();
 141
 142   myAppendFilter->AddInputConnection(myVertexSource->GetOutputPort());
 143   myVertexActor->SetInput(myVertexSource->GetOutputPort(),false);
 144   aProperty = myVertexActor->GetProperty();
 145   aProperty->SetRepresentation(VTK_POINTS);
 146   aProperty->SetPointSize(3);
 147   aProperty->SetColor(1, 1, 0);
 148
 149   myAppendFilter->AddInputConnection(myIsolatedEdgeSource->GetOutputPort());
 150   myIsolatedEdgeActor->SetInput(myIsolatedEdgeSource->GetOutputPort(),false);
 151   aProperty = myIsolatedEdgeActor->GetProperty();
 152   aProperty->SetRepresentation(VTK_WIREFRAME);
 153   myIsolatedEdgeColor[0] = 1; myIsolatedEdgeColor[1] = 0; myIsolatedEdgeColor[2] = 0;
 154   aProperty->SetColor(myIsolatedEdgeColor[0], myIsolatedEdgeColor[1], myIsolatedEdgeColor[2]);
 155
 156   myAppendFilter->AddInputConnection(myOneFaceEdgeSource->GetOutputPort());
 157   myOneFaceEdgeActor->SetInput(myOneFaceEdgeSource->GetOutputPort(),false);
 158   aProperty = myOneFaceEdgeActor->GetProperty();
 159   aProperty->SetRepresentation(VTK_WIREFRAME);
 160   myOneFaceEdgeColor[0] = 0; myOneFaceEdgeColor[1] = 1; myOneFaceEdgeColor[2] = 0;
 161   aProperty->SetColor(myOneFaceEdgeColor[0], myOneFaceEdgeColor[1], myOneFaceEdgeColor[2]);
 162
 163   myAppendFilter->AddInputConnection(mySharedEdgeSource->GetOutputPort());
 164   mySharedEdgeActor->SetInput(mySharedEdgeSource->GetOutputPort(),false);
 165   aProperty = mySharedEdgeActor->GetProperty();
 166   aProperty->SetRepresentation(VTK_WIREFRAME);
 167   mySharedEdgeColor[0] = 1; mySharedEdgeColor[1] = 1; mySharedEdgeColor[2] = 0;
 168   aProperty->SetColor(mySharedEdgeColor[0], mySharedEdgeColor[1], mySharedEdgeColor[2]);
 169
 170   myAppendFilter->AddInputConnection(myWireframeFaceSource->GetOutputPort());
 171   myWireframeFaceActor->SetInput(myWireframeFaceSource->GetOutputPort(),false);
 172   aProperty = myWireframeFaceActor->GetProperty();
 173   aProperty->SetRepresentation(VTK_WIREFRAME);
 174   aProperty->SetColor(0.5, 0.5, 0.5);
 175
 176   myShadingFaceActor->SetInput(myShadingFaceSource->GetOutputPort(),true);
 177
 178   myShadingFaceProp->SetRepresentation(VTKViewer::Representation::Surface);
 179   myShadingFaceProp->SetInterpolationToGouraud();
 180   myShadingFaceProp->SetAmbient(1.0);
 181   myShadingFaceProp->SetDiffuse(1.0);
 182   myShadingFaceProp->SetSpecular(0.4);
 183   myShadingFaceProp->SetAmbientColor(0.329412, 0.223529, 0.027451);
 184   myShadingFaceProp->SetDiffuseColor(0.780392, 0.568627, 0.113725);
 185   myShadingFaceProp->SetSpecularColor(0.992157, 0.941176, 0.807843);
 186
 187   myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer());
 188
 189   myNbIsos[0] = -1;
 190   myNbIsos[1] = -1;
 191
 192   // Toggle display mode
 193   setDisplayMode(0); // WIRE FRAME
 194   SetVectorMode(0);  //
 195 }
 196
 197
 198 GEOM_Actor::~GEOM_Actor()
 199 {
 200 #ifdef MYDEBUG
 201   MESSAGE (this<< " ~GEOM_Actor::GEOM_Actor");
 202 #endif
 203   myHighlightProp->Delete();
 204   myPreHighlightProp->Delete();
 205   myShadingFaceProp->Delete();
 206   myShadingBackFaceProp->Delete();
 207 }
 208
 209 GEOM_Actor*
 210 GEOM_Actor::
 211 New()
 212 {
 213   GEOM_Actor* anObject = new GEOM_Actor();
 214   anObject->SetMapper(anObject->myPolyDataMapper.Get());
 215   return anObject;
 216 }
 217
 218
 219 void Write(vtkPolyData* theDataSet, const char* theFileName){
 220   vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New();
 221   MESSAGE ("Write - "<<theFileName<<"' : "<<theDataSet->GetNumberOfPoints()<<"; "<<theDataSet->GetNumberOfCells());
 222   aWriter->SetInputData(theDataSet);
 223   aWriter->SetFileName(theFileName);
 224   //aWriter->Write();
 225   aWriter->Delete();
 226 }
 227
 228 void
 229 GEOM_Actor::
 230 SetModified()
 231 {
 232   this->myVertexSource->Modified();
 233   this->myIsolatedEdgeSource->Modified();
 234   this->myOneFaceEdgeSource->Modified();
 235   this->mySharedEdgeSource->Modified();
 236   this->myWireframeFaceSource->Modified();
 237   this->myShadingFaceSource->Modified();
 238 }
 239
 240 void
 241 GEOM_Actor::
 242 SetMapper(vtkMapper* theMapper)
 243 {
 244   SALOME_Actor::SetMapper(theMapper);
 245 }
 246
 247 void
 248 GEOM_Actor::
 249 AddToRender(vtkRenderer* theRenderer)
 250 {
 251   //SALOME_Actor::AddToRender(theRenderer);
 252
 253   theRenderer->AddActor(this);
 254
 255   this->myHighlightActor->AddToRender(theRenderer);
 256
 257
 258   myShadingFaceActor->AddToRender(theRenderer);
 259   myWireframeFaceActor->AddToRender(theRenderer);
 260
 261   mySharedEdgeActor->AddToRender(theRenderer);
 262   myOneFaceEdgeActor->AddToRender(theRenderer);
 263   myIsolatedEdgeActor->AddToRender(theRenderer);
 264
 265   myVertexActor->AddToRender(theRenderer);
 266 }
 267
 268 void
 269 GEOM_Actor::
 270 RemoveFromRender(vtkRenderer* theRenderer)
 271 {
 272   //SALOME_Actor::RemoveFromRender(theRenderer);
 273
 274
 275   theRenderer->RemoveActor(this);
 276
 277   myHighlightActor->RemoveFromRender(theRenderer);
 278   myShadingFaceActor->RemoveFromRender(theRenderer);
 279   myWireframeFaceActor->RemoveFromRender(theRenderer);
 280
 281   mySharedEdgeActor->RemoveFromRender(theRenderer);
 282   myOneFaceEdgeActor->RemoveFromRender(theRenderer);
 283   myIsolatedEdgeActor->RemoveFromRender(theRenderer);
 284
 285   myVertexActor->RemoveFromRender(theRenderer);
 286
 287
 288   SetSelected(false);
 289   SetVisibility(false);
 290 }
 291
 292 void
 293 GEOM_Actor::
 294 setDisplayMode(int theMode)
 295 {
 296 #ifdef MYDEBUG
 297   MESSAGE ( "GEOM_Actor::setDisplayMode = "<<theMode );
 298 #endif
 299
 300   if ( theMode == (int)eShading || theMode == (int)eShadingWithEdges ) {
 301     // Temporary store number of iso lines in order to recover its later
 302     // when display mode is changed to 'Wirefame'
 303     // Iso lines are not displayed in 'Shading' and 'Shading with edges' modes.
 304     StoreIsoNumbers();
 305
 306     // Reset number of iso lines to 0
 307     ResetIsoNumbers();
 308   }
 309
 310   if ( theMode == (int)eShadingWithEdges ) {
 311     // Coloring edges
 312     myIsolatedEdgeActor->GetProperty()->SetColor(myEdgesInShadingColor[0],
 313                                                  myEdgesInShadingColor[1],
 314                                                  myEdgesInShadingColor[2]);
 315     myOneFaceEdgeActor->GetProperty()->SetColor(myEdgesInShadingColor[0],
 316                                                 myEdgesInShadingColor[1],
 317                                                 myEdgesInShadingColor[2]);
 318     mySharedEdgeActor->GetProperty()->SetColor(myEdgesInShadingColor[0],
 319                                                myEdgesInShadingColor[1],
 320                                                myEdgesInShadingColor[2]);
 321   }
 322   else {
 323     // Restore number of iso-lines
 324     RestoreIsoNumbers();
 325
 326     // Coloring edges
 327     myIsolatedEdgeActor->GetProperty()->SetColor(myIsolatedEdgeColor[0],
 328                                                  myIsolatedEdgeColor[1],
 329                                                  myIsolatedEdgeColor[2]);
 330     mySharedEdgeActor->GetProperty()->SetColor(myIsolatedEdgeColor[0],
 331                                                myIsolatedEdgeColor[1],
 332                                                myIsolatedEdgeColor[2]);
 333     myOneFaceEdgeActor->GetProperty()->SetColor(myOneFaceEdgeColor[0],
 334                                                myOneFaceEdgeColor[1],
 335                                                myOneFaceEdgeColor[2]);
 336   }
 337
 338   VTKViewer_Actor::setDisplayMode(theMode);
 339   SetVisibility(GetVisibility());
 340 }
 341
 342 void
 343 GEOM_Actor::
 344 SetSelected(bool theIsSelected)
 345 {
 346 #ifdef MYDEBUG
 347   MESSAGE ( "GEOM_Actor::SetSelected = "<<theIsSelected  );
 348 #endif
 349
 350   myIsSelected = theIsSelected;
 351   SetVisibility(GetVisibility());
 352 }
 353
 354 void
 355 GEOM_Actor::
 356 SetVisibility(int theVisibility)
 357 {
 358 #ifdef MYDEBUG
 359   MESSAGE ( "GEOM_Actor::SetVisibility = "<<theVisibility <<"  myIsSelected="<< myIsSelected
 360             << " theVisibility="<<theVisibility<<" myIsPreselected="<<myIsPreselected );
 361 #endif
 362
 363   SALOME_Actor::SetVisibility(theVisibility);
 364
 365   this->myHighlightActor->SetVisibility(theVisibility && (myIsSelected || myIsPreselected));
 366
 367   myShadingFaceActor->SetVisibility(theVisibility && (myDisplayMode == (int)eShading || myDisplayMode == (int)eShadingWithEdges) && (!myIsSelected || !myIsPreselected));
 368   myWireframeFaceActor->SetVisibility(theVisibility && (myDisplayMode == (int)eWireframe) && !myIsSelected);
 369
 370   mySharedEdgeActor->SetVisibility(theVisibility && (myDisplayMode == (int)eWireframe || myDisplayMode == (int)eShadingWithEdges) && !myIsSelected);
 371   myOneFaceEdgeActor->SetVisibility(theVisibility && (myDisplayMode == (int)eWireframe || myDisplayMode == (int)eShadingWithEdges) && !myIsSelected);
 372   myIsolatedEdgeActor->SetVisibility(theVisibility && !myIsSelected);
 373
 374   myVertexActor->SetVisibility(theVisibility && myDisplayMode == (int)eWireframe && !myIsSelected);// must be added new mode points
 375 }
 376
 377
 378 void
 379 GEOM_Actor
 380 ::SetNbIsos(const int theNb[2])
 381 {
 382   myWireframeFaceSource->SetNbIso(theNb);
 383 }
 384
 385 void
 386 GEOM_Actor
 387 ::GetNbIsos(int &theNbU,int &theNbV)
 388 {
 389   myWireframeFaceSource->GetNbIso(theNbU, theNbV);
 390 }
 391
 392 void
 393 GEOM_Actor
 394 ::SetVectorMode(bool theMode)
 395 {
 396   myVectorMode = theMode;
 397   myIsolatedEdgeSource->SetVectorMode(theMode);
 398   myOneFaceEdgeSource->SetVectorMode(theMode);
 399   mySharedEdgeSource->SetVectorMode(theMode);
 400   SetModified();
 401 }
 402
 403 bool
 404 GEOM_Actor
 405 ::GetVectorMode()
 406 {
 407   return myVectorMode;
 408 }
 409
 410 void
 411 GEOM_Actor::
 412 SetDeflection(float theDeflection)
 413 {
 414   if( myDeflection == theDeflection )
 415     return;
 416
 417   myDeflection = theDeflection;
 418
 419   GEOM::MeshShape(myShape,myDeflection);
 420
 421   SetModified();
 422 }
 423
 424 void GEOM_Actor::SetShape (const TopoDS_Shape& theShape,
 425                            float theDeflection,
 426                            bool theIsVector)
 427 {
 428   myShape = theShape;
 429
 430   myVertexSource->Clear();
 431   myIsolatedEdgeSource->Clear();
 432   myOneFaceEdgeSource->Clear();
 433   mySharedEdgeSource->Clear();
 434   myWireframeFaceSource->Clear();
 435   myShadingFaceSource->Clear();
 436
 437   TopExp_Explorer aVertexExp (theShape,TopAbs_VERTEX);
 438   for (; aVertexExp.More(); aVertexExp.Next())
 439   {
 440      const TopoDS_Vertex& aVertex = TopoDS::Vertex(aVertexExp.Current());
 441      myVertexSource->AddVertex(aVertex);
 442   }
 443
 444   SetDeflection(theDeflection);
 445
 446   // look if edges are free or shared
 447   TopTools_IndexedDataMapOfShapeListOfShape anEdgeMap;
 448   TopExp::MapShapesAndAncestors(theShape,TopAbs_EDGE,TopAbs_FACE,anEdgeMap);
 449
 450   GEOM::SetShape(theShape,anEdgeMap,theIsVector,
 451                  myIsolatedEdgeSource.Get(),
 452                  myOneFaceEdgeSource.Get(),
 453                  mySharedEdgeSource.Get(),
 454                  myWireframeFaceSource.Get(),
 455                  myShadingFaceSource.Get());
 456   isOnlyVertex =
 457     myIsolatedEdgeSource->IsEmpty() &&
 458     myOneFaceEdgeSource->IsEmpty() &&
 459     mySharedEdgeSource->IsEmpty() &&
 460     myWireframeFaceSource->IsEmpty() &&
 461     myShadingFaceSource->IsEmpty();
 462
 463
 464   if((bool)myShape.Infinite() || isOnlyVertex ){
 465     myVertexActor->GetDeviceActor()->SetInfinitive(true);
 466     myHighlightActor->GetDeviceActor()->SetInfinitive(true);
 467   }
 468
 469   // 0051777: TC7.2.0: Element could not be selected in Hypothesis Construction
 470   myAppendFilter->Update();
 471 }
 472
 473 // OLD METHODS
 474 void GEOM_Actor::setDeflection(double adef) {
 475 #ifdef MYDEBUG
 476   MESSAGE ( "GEOM_Actor::setDeflection" );
 477 #endif
 478   SetDeflection((float)adef);
 479 }
 480
 481
 482 // warning! must be checked!
 483 // SetHighlightProperty
 484 // SetWireframeProperty
 485 // SetShadingProperty
 486
 487 void GEOM_Actor::SetHighlightProperty(vtkProperty* Prop)
 488 {
 489 #ifdef MYDEBUG
 490   MESSAGE ( "GEOM_Actor::SetHighlightProperty" );
 491 #endif
 492   this->myHighlightActor->GetProperty()->DeepCopy(Prop);
 493
 494 }
 495
 496 void GEOM_Actor::SetWireframeProperty(vtkProperty* Prop)
 497 {
 498 #ifdef MYDEBUG
 499   MESSAGE ( this << " GEOM_Actor::SetWireframeProperty" );
 500 #endif
 501   // must be filled
 502   myWireframeFaceActor->SetProperty(Prop);
 503 }
 504
 505
 506 vtkProperty* GEOM_Actor::GetWireframeProperty()
 507 {
 508   return myWireframeFaceActor->GetProperty();
 509 }
 510
 511 vtkProperty* GEOM_Actor::GetIsolatedEdgeProperty()
 512 {
 513   return myIsolatedEdgeActor->GetProperty();
 514 }
 515
 516 vtkProperty* GEOM_Actor::GetVertexProperty()
 517 {
 518   return myVertexActor->GetProperty();
 519 }
 520
 521 vtkProperty* GEOM_Actor::GetSharedEdgeProperty()
 522 {
 523   return mySharedEdgeActor->GetProperty();
 524 }
 525
 526 vtkProperty* GEOM_Actor::GetFaceEdgeProperty()
 527 {
 528   return myOneFaceEdgeActor->GetProperty();
 529 }
 530
 531 void GEOM_Actor::SetShadingProperty(vtkProperty* Prop)
 532 {
 533 #ifdef MYDEBUG
 534   MESSAGE ( "GEOM_Actor::SetShadingProperty" );
 535 #endif
 536   myShadingFaceProp->DeepCopy(Prop);
 537 }
 538
 539
 540 vtkProperty* GEOM_Actor::GetShadingProperty()
 541 {
 542   return myShadingFaceProp;
 543 }
 544
 545
 546 void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *theMapper)
 547 {
 548 #ifdef MYDEBUG
 549   MESSAGE ( "GEOM_Actor::Render" );
 550 #endif
 551
 552   if(!GetVisibility())
 553     return;
 554
 555   /* render the property */
 556   if (!this->Property) {
 557     // force creation of a property
 558     this->GetProperty();
 559     this->Property->SetInterpolation(1);
 560     this->Property->SetRepresentationToSurface();
 561     this->Property->SetAmbient(0.3);
 562     this->Property->SetAmbientColor(0.88,0.86,0.2);
 563     this->Property->SetDiffuseColor(0.99,0.7,0.21);
 564     this->Property->SetSpecularColor(0.99,0.98,0.83);
 565   }
 566
 567   switch(myDisplayMode){
 568   case eWireframe://wireframe
 569     myPreHighlightProp->SetRepresentationToWireframe();
 570     myHighlightProp->SetRepresentationToWireframe();
 571     break;
 572   case eShading://shading
 573   case eShadingWithEdges://shading with edges
 574     myPreHighlightProp->SetRepresentationToSurface();
 575     myHighlightProp->SetRepresentationToSurface();
 576     myShadingFaceProp->SetRepresentationToSurface();
 577     myShadingBackFaceProp->SetRepresentationToSurface();
 578     break;
 579   }
 580
 581   if(!myIsSelected){
 582     if(myIsPreselected){
 583       this->myHighlightActor->SetProperty(myPreHighlightProp.GetPointer());
 584       myShadingFaceActor->SetProperty(myPreHighlightProp.GetPointer());
 585       myShadingFaceActor->SetBackfaceProperty(myPreHighlightProp.GetPointer());
 586     } else {
 587       this->myHighlightActor->SetProperty(myShadingFaceProp.GetPointer());
 588       myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer());
 589       myShadingFaceActor->SetBackfaceProperty(myShadingBackFaceProp.GetPointer());
 590     }
 591   }
 592   else{
 593     this->myHighlightActor->SetProperty(myHighlightProp.GetPointer());
 594     myShadingFaceActor->SetProperty(myHighlightProp.GetPointer());
 595     myShadingFaceActor->SetBackfaceProperty(myHighlightProp.GetPointer());
 596   }
 597
 598   this->Property->Render(this, ren);
 599   if (this->BackfaceProperty) {
 600     this->BackfaceProperty->BackfaceRender(this, ren);
 601     this->Device->SetBackfaceProperty(this->BackfaceProperty);
 602   }
 603   this->Device->SetProperty(this->Property);
 604   /*  if(myShape.ShapeType() == TopAbs_VERTEX) {
 605     if(ren){
 606       //The parameter determine size of vertex actor relate to diagonal of RendererWindow
 607       static double delta = 0.01;
 608       double X1 = -1, Y1 = -1, Z1 = 0;
 609       ren->ViewToWorld(X1,Y1,Z1);
 610       double X2 = +1, Y2 = +1, Z2 = 0;
 611       ren->ViewToWorld(X2,Y2,Z2);
 612       Z2 = sqrt((X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1));
 613       this->SetScale(Z2*delta);
 614     }
 615     vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
 616     this->GetMatrix(ren->GetActiveCamera(), aMatrix);
 617     this->Device->SetUserMatrix(aMatrix);
 618     this->Device->Render(ren,theMapper);
 619     aMatrix->Delete();
 620     } else*/
 621     this->Device->Render(ren, theMapper);
 622 }
 623
 624 void GEOM_Actor::ReleaseGraphicsResources(vtkWindow *)
 625 {
 626 #ifdef MYDEBUG
 627   MESSAGE ( "GEOM_Actor::ReleaseGraphicsResources" );
 628 #endif
 629 }
 630
 631
 632
 633 void GEOM_Actor::ShallowCopy(vtkProp *prop)
 634 {
 635 #ifdef MYDEBUG
 636   MESSAGE ( "GEOM_Actor::ShallowCopy" );
 637 #endif
 638   GEOM_Actor *f = GEOM_Actor::SafeDownCast(prop);
 639   if ( f != NULL )
 640     {
 641       this->SetShape(f->getTopo(),f->GetDeflection());
 642     }
 643
 644   // Now do superclass
 645   this->SALOME_Actor::ShallowCopy(prop);
 646 }
 647
 648 const TopoDS_Shape& GEOM_Actor::getTopo() {
 649 #ifdef MYDEBUG
 650   MESSAGE ( "GEOM_Actor::getTopo" );
 651 #endif
 652   return myShape;
 653 }
 654
 655 void GEOM_Actor::setInputShape(const TopoDS_Shape& ashape, double adef1,
 656                                int imode, bool isVector)
 657 {
 658 #ifdef MYDEBUG
 659   MESSAGE ( "GEOM_Actor::setInputShape" );
 660 #endif
 661 }
 662
 663 double GEOM_Actor::getDeflection()
 664 {
 665 #ifdef MYDEBUG
 666   MESSAGE ( "GEOM_Actor::getDeflection" );
 667 #endif
 668   return (double) GetDeflection();
 669 }
 670
 671
 672 double GEOM_Actor::isVector()
 673 {
 674 #ifdef MYDEBUG
 675   MESSAGE ( "GEOM_Actor::isVector" );
 676 #endif
 677   return 0;
 678 }
 679
 680 void GEOM_Actor::SubShapeOn()
 681 {
 682 #ifdef MYDEBUG
 683   MESSAGE ( "GEOM_Actor::SubShapeOn" );
 684 #endif
 685 }
 686
 687 void GEOM_Actor::SubShapeOff()
 688 {
 689 #ifdef MYDEBUG
 690   MESSAGE ( "GEOM_Actor::SubShapeOff" );
 691 #endif
 692 }
 693
 694 void GEOM_Actor::highlight(bool highlight)
 695 {
 696 #ifdef MYDEBUG
 697   MESSAGE ( this << " GEOM_Actor::highlight highlight="<<highlight );
 698 #endif
 699   SALOME_Actor::highlight(highlight);
 700 }
 701
 702 void GEOM_Actor::SetOpacity(double opa)
 703 {
 704   // enk:tested OK
 705   myShadingFaceProp->SetOpacity(opa);
 706   myShadingBackFaceProp->SetOpacity(opa);
 707   myHighlightProp->SetOpacity(opa);
 708   myPreHighlightProp->SetOpacity(opa);
 709   myVertexActor->GetProperty()->SetOpacity(opa);
 710 }
 711
 712 double GEOM_Actor::GetOpacity()
 713 {
 714   // enk:tested OK
 715   return myShadingFaceProp->GetOpacity();
 716 }
 717
 718 void GEOM_Actor::SetColor(double r,double g,double b)
 719 {
 720   // set the same color to all sub-actors:
 721   // - points
 722   // - standalone edges
 723   // - shared edges
 724   // - free edges
 725   // - shading color (front and back faces)
 726   SetPointColor(r, g, b);
 727   SetIsolatedEdgeColor(r, g, b);
 728   SetSharedEdgeColor(r, g, b);
 729   SetFreeEdgeColor(r, g, b);
 730   myShadingFaceProp->SetColor(r,g,b);     // shading color
 731   myShadingBackFaceProp->SetColor(r,g,b); // back face shading color
 732 }
 733
 734 void GEOM_Actor::GetColor(double& r,double& g,double& b)
 735 {
 736   double aRGB[3];
 737   myShadingFaceProp->GetColor(aRGB);
 738   r = aRGB[0];
 739   g = aRGB[1];
 740   b = aRGB[2];
 741 }
 742
 743 /*!
 744   \brief Set color of points
 745   Points actor is shown in Wireframe mode only, see SetVisibility()
 746 */
 747 void GEOM_Actor::SetPointColor(double r,  double g,  double b)
 748 {
 749   myVertexActor->GetProperty()->SetColor(r, g, b);
 750 }
 751
 752 /*!
 753   \brief Set color of standalone edges, wires, vectors
 754   This actor is shown in all display mode, see SetVisibility()
 755   TODO: check - this color seems to be used not only for standalone edges
 756 */
 757 void GEOM_Actor::SetIsolatedEdgeColor(double r, double g,  double b)
 758 {
 759   myIsolatedEdgeColor[0] = r; myIsolatedEdgeColor[1] = g; myIsolatedEdgeColor[2] = b;
 760   if ( myDisplayMode != (int)eShadingWithEdges )
 761     myIsolatedEdgeActor->GetProperty()->SetColor(r, g, b);
 762 }
 763
 764 /*!
 765   \brief Set color of shared edges
 766   This actor is shown only in wireframe and shading+edges display modes, see SetVisibility()
 767   TODO: check - this seems to be not working currently
 768 */
 769 void GEOM_Actor::SetSharedEdgeColor(double r, double g, double b)
 770 {
 771   mySharedEdgeColor[0] = r; mySharedEdgeColor[1] = g; mySharedEdgeColor[2] = b;
 772   if ( myDisplayMode != (int)eShadingWithEdges )
 773     mySharedEdgeActor->GetProperty()->SetColor(r, g, b);
 774 }
 775
 776 /*!
 777   \brief Set color of edges for standalone faces
 778   This actor is shown only in wireframe and shading+edges display modes, see SetVisibility()
 779   TODO: this color should be used not only for faces
 780 */
 781 void GEOM_Actor::SetFreeEdgeColor(double r, double g, double b)
 782 {
 783   myOneFaceEdgeColor[0] = r; myOneFaceEdgeColor[1] = g; myOneFaceEdgeColor[2] = b;
 784   if ( myDisplayMode != (int)eShadingWithEdges )
 785     myOneFaceEdgeActor->GetProperty()->SetColor(r, g, b);
 786 }
 787
 788 /*!
 789   \brief Set color of iso-lines
 790   This actor is shown only in wireframe display mode, see SetVisibility()
 791 */
 792 void GEOM_Actor::SetIsosColor(double r, double g, double b)
 793 {
 794   myWireframeFaceActor->GetProperty()->SetColor(r, g, b);
 795 }
 796
 797 void GEOM_Actor::SetMaterial(std::vector<vtkProperty*> theProps)
 798 {
 799   // we set material properties as back and front material
 800   int aSize = theProps.size();
 801
 802   if ( aSize < 1 || aSize > 2)
 803     return;
 804
 805   // theProps[0] -- front material properties
 806   // theProps[1] -- back material properties (if exist)
 807
 808   double aCoefnt;
 809
 810   // Set reflection coefficients
 811   aCoefnt = theProps[0]->GetAmbient();
 812   myShadingFaceProp->SetAmbient(aCoefnt);
 813   myVertexActor->GetProperty()->SetAmbient(aCoefnt);
 814   if ( aSize == 2 )
 815     aCoefnt = theProps[1]->GetAmbient();
 816   myShadingBackFaceProp->SetAmbient(aCoefnt);
 817
 818   // Set diffuse coefficients
 819   aCoefnt = theProps[0]->GetDiffuse();
 820   myShadingFaceProp->SetDiffuse(aCoefnt);
 821   myVertexActor->GetProperty()->SetDiffuse(aCoefnt);
 822   if ( aSize == 2 )
 823     aCoefnt = theProps[1]->GetDiffuse();
 824   myShadingBackFaceProp->SetDiffuse(aCoefnt);
 825
 826   // Set specular coefficients
 827   aCoefnt = theProps[0]->GetSpecular();
 828   myShadingFaceProp->SetSpecular(aCoefnt);
 829   myVertexActor->GetProperty()->SetSpecular(aCoefnt);
 830   if ( aSize == 2 )
 831     aCoefnt = theProps[1]->GetSpecular();
 832   myShadingBackFaceProp->SetSpecular(aCoefnt);
 833
 834
 835   double* aColor;
 836
 837   // Set reflection colors
 838   aColor = theProps[0]->GetAmbientColor();
 839   myShadingFaceProp->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
 840   myVertexActor->GetProperty()->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
 841   if ( aSize == 2 )
 842     aColor = theProps[1]->GetAmbientColor();
 843   myShadingBackFaceProp->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
 844
 845   // Set diffuse colors
 846   aColor = theProps[0]->GetDiffuseColor();
 847   myShadingFaceProp->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
 848   myVertexActor->GetProperty()->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
 849   if ( aSize == 2 )
 850     aColor = theProps[1]->GetDiffuseColor();
 851   myShadingBackFaceProp->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
 852
 853   // Set specular colors
 854   aColor = theProps[0]->GetSpecularColor();
 855   myShadingFaceProp->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
 856   myVertexActor->GetProperty()->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
 857   if ( aSize == 2 )
 858     aColor = theProps[1]->GetSpecularColor();
 859   myShadingBackFaceProp->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
 860
 861   // Set shininess
 862   aCoefnt = theProps[0]->GetSpecularPower();
 863   myShadingFaceProp->SetSpecularPower(aCoefnt);
 864   myVertexActor->GetProperty()->SetSpecularPower(aCoefnt);
 865   if ( aSize == 2 )
 866     aCoefnt = theProps[1]->GetSpecularPower();
 867   myShadingBackFaceProp->SetSpecularPower(aCoefnt);
 868
 869   // Set back face material property
 870   myShadingFaceActor->SetBackfaceProperty(myShadingBackFaceProp.GetPointer());
 871 }
 872
 873 vtkProperty* GEOM_Actor::GetFrontMaterial()
 874 {
 875   return myShadingFaceProp;
 876 }
 877
 878 vtkProperty* GEOM_Actor::GetBackMaterial()
 879 {
 880   return myShadingBackFaceProp;
 881 }
 882
 883 bool GEOM_Actor::IsInfinitive()
 884 {
 885   return ((bool)myShape.Infinite() || isOnlyVertex);
 886 }
 887
 888 /*!
 889   To map current selection to VTK representation
 890 */
 891 void
 892 GEOM_Actor
 893 ::Highlight(bool theIsHighlight)
 894 {
 895   myIsSelected = theIsHighlight;
 896 #ifdef MYDEBUG
 897   MESSAGE ( this << " GEOM_Actor::Highlight myIsSelected="<<myIsSelected );
 898 #endif
 899
 900   if ( myDisplayMode == (int)eShading || myDisplayMode == (int)eShadingWithEdges ) {
 901     if ( theIsHighlight )
 902       RestoreIsoNumbers();
 903     else
 904       // Reset number of iso lines to 0
 905       ResetIsoNumbers();
 906   }
 907
 908   SALOME_Actor::Highlight(theIsHighlight); // this method call ::highlight(theIsHighlight) in the end
 909   SetVisibility(GetVisibility());
 910 }
 911
 912 /*!
 913   To process prehighlight (called from SVTK_InteractorStyle)
 914 */
 915 bool
 916 GEOM_Actor
 917 ::PreHighlight(vtkInteractorStyle *theInteractorStyle,
 918                SVTK_SelectionEvent* theSelectionEvent,
 919                bool theIsHighlight)
 920 {
 921 #ifdef MYDEBUG
 922   MESSAGE ( this<<" GEOM_Actor::PreHighlight (3) theIsHighlight="<<theIsHighlight );
 923 #endif
 924
 925   if ( !GetPickable() )
 926     return false;
 927
 928   if ( myDisplayMode == (int)eShading || myDisplayMode == (int)eShadingWithEdges ) {
 929     if ( theIsHighlight )
 930       RestoreIsoNumbers();
 931     else
 932       // Reset number of iso lines to 0
 933       ResetIsoNumbers();
 934   }
 935
 936   myPreHighlightActor->SetVisibility( false );
 937   bool anIsPreselected = myIsPreselected;
 938
 939   Selection_Mode aSelectionMode = theSelectionEvent->mySelectionMode;
 940   bool anIsChanged = (mySelectionMode != aSelectionMode);
 941
 942   if( !theIsHighlight ) {
 943     SetPreSelected( false );
 944   }else{
 945     switch(aSelectionMode){
 946     case ActorSelection :
 947     {
 948 //       cout << "=============== " << myIO->getEntry() << endl;
 949 //       int nbio = mySelector->IObjectCount();
 950 //       cout << " nbio = " << nbio << endl;
 951
 952       if( !mySelector->IsSelected( myIO ) ) {
 953         //      printf ("!!!!!!!!!!!!!!!!\n");
 954         SetPreSelected( true );
 955       }
 956     }
 957     default:
 958       break;
 959     }
 960   }
 961
 962   mySelectionMode = aSelectionMode;
 963   anIsChanged |= (anIsPreselected != myIsPreselected);
 964
 965   SetVisibility(GetVisibility());
 966   return anIsChanged;
 967 }
 968
 969 /*!
 970   To process highlight (called from SVTK_InteractorStyle)
 971 */
 972 bool
 973 GEOM_Actor
 974 ::Highlight(vtkInteractorStyle *theInteractorStyle,
 975             SVTK_SelectionEvent* theSelectionEvent,
 976             bool theIsHighlight)
 977 {
 978   // define the selection of object
 979 #ifdef MYDEBUG
 980   MESSAGE ( std::endl << this << " GEOM_Actor::Highlight (3) myIsSelected="<<myIsSelected );
 981 #endif
 982   bool aRet = SALOME_Actor::Highlight(theInteractorStyle,theSelectionEvent,theIsHighlight);
 983   SetSelected(theIsHighlight);
 984   if(theIsHighlight)
 985     SetPreSelected(false);
 986
 987
 988   return aRet;
 989 }
 990
 991 // Copy the follower's composite 4x4 matrix into the matrix provided.
 992 void GEOM_Actor::GetMatrix(vtkCamera* theCam, vtkMatrix4x4 *result)
 993 {
 994   double *pos, *vup;
 995   double Rx[3], Ry[3], Rz[3], p1[3];
 996   vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
 997   int i;
 998   double distance;
 999
1000   this->GetOrientation();
1001   this->Transform->Push();
1002   this->Transform->PostMultiply();
1003   this->Transform->Identity();
1004
1005   // apply user defined matrix last if there is one
1006   if (this->UserMatrix)
1007     {
1008     this->Transform->Concatenate(this->UserMatrix);
1009     }
1010
1011   this->Transform->Translate(-this->Origin[0],
1012                              -this->Origin[1],
1013                              -this->Origin[2]);
1014   // scale
1015   this->Transform->Scale(this->Scale[0],
1016                          this->Scale[1],
1017                          this->Scale[2]);
1018
1019   // rotate
1020   this->Transform->RotateY(this->Orientation[1]);
1021   this->Transform->RotateX(this->Orientation[0]);
1022   this->Transform->RotateZ(this->Orientation[2]);
1023
1024   if (theCam)
1025     {
1026     // do the rotation
1027     // first rotate y
1028     pos = theCam->GetPosition();
1029     vup = theCam->GetViewUp();
1030
1031     if (theCam->GetParallelProjection())
1032       {
1033       theCam->GetDirectionOfProjection(Rz);
1034       }
1035     else
1036       {
1037       distance = sqrt(
1038         (pos[0] - this->Position[0])*(pos[0] - this->Position[0]) +
1039         (pos[1] - this->Position[1])*(pos[1] - this->Position[1]) +
1040         (pos[2] - this->Position[2])*(pos[2] - this->Position[2]));
1041       for (i = 0; i < 3; i++)
1042         {
1043         Rz[i] = (pos[i] - this->Position[i])/distance;
1044         }
1045       }
1046
1047     vtkMath::Cross(vup,Rz,Rx);
1048     vtkMath::Normalize(Rx);
1049     vtkMath::Cross(Rz,Rx,Ry);
1050
1051     matrix->Element[0][0] = Rx[0];
1052     matrix->Element[1][0] = Rx[1];
1053     matrix->Element[2][0] = Rx[2];
1054     matrix->Element[0][1] = Ry[0];
1055     matrix->Element[1][1] = Ry[1];
1056     matrix->Element[2][1] = Ry[2];
1057     matrix->Element[0][2] = Rz[0];
1058     matrix->Element[1][2] = Rz[1];
1059     matrix->Element[2][2] = Rz[2];
1060
1061     this->Transform->Concatenate(matrix);
1062     }
1063
1064   // translate to projection reference point PRP
1065   // this is the camera's position blasted through
1066   // the current matrix
1067   p1[0] = this->Origin[0] + this->Position[0];
1068   p1[1] = this->Origin[1] + this->Position[1];
1069   p1[2] = this->Origin[2] + this->Position[2];
1070
1071   this->Transform->Translate(p1[0],p1[1],p1[2]);
1072   this->Transform->GetMatrix(result);
1073
1074   matrix->Delete();
1075   this->Transform->Pop();
1076 }
1077
1078 void GEOM_Actor::SetEdgesInShadingColor(double r,double g,double b)
1079 {
1080   myEdgesInShadingColor[0] = r;
1081   myEdgesInShadingColor[1] = g;
1082   myEdgesInShadingColor[2] = b;
1083 }
1084
1085 void GEOM_Actor::StoreIsoNumbers()
1086 {
1087   myWireframeFaceSource->GetNbIso(myNbIsos[0], myNbIsos[1]);
1088 }
1089
1090 void GEOM_Actor::SetIsosWidth(const int width) {
1091   myWireframeFaceActor->GetProperty()->SetLineWidth(width);
1092 }
1093
1094 int GEOM_Actor::GetIsosWidth() const {
1095   return (int)myWireframeFaceActor->GetProperty()->GetLineWidth();
1096 }
1097
1098 void GEOM_Actor::SetWidth(const int width) {
1099   myIsolatedEdgeActor->GetProperty()->SetLineWidth(width);
1100   myOneFaceEdgeActor->GetProperty()->SetLineWidth(width);
1101   mySharedEdgeActor->GetProperty()->SetLineWidth(width);
1102   myHighlightProp->SetLineWidth(width);
1103   myPreHighlightProp->SetLineWidth(width+1);
1104
1105 }
1106
1107 int GEOM_Actor::GetWidth() const {
1108   return (int)myIsolatedEdgeActor->GetProperty()->GetLineWidth();
1109 }
1110
1111 void GEOM_Actor::RestoreIsoNumbers()
1112 {
1113   if ( myNbIsos[0] > 0 || myNbIsos[1] > 0 )
1114     // Restore number of U and (or) V iso lines
1115     myWireframeFaceSource->SetNbIso(myNbIsos);
1116 }
1117
1118 void GEOM_Actor::ResetIsoNumbers()
1119 {
1120   int aNb[2] = {0, 0};
1121   myWireframeFaceSource->SetNbIso(aNb);
1122 }