1 // SMESH OBJECT : interactive object for SMESH visualization
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : SMESH_Actor.cxx
25 // Author : Nicolas REJNERI
30 #include "SMESH_Actor.h"
31 #include "SMESH_DeviceActor.h"
32 #include "SALOME_ExtractUnstructuredGrid.h"
34 #include "QAD_Config.h"
35 #include "utilities.h"
36 #include <qstringlist.h>
38 #include <vtkObjectFactory.h>
39 #include <vtkShrinkPolyData.h>
40 #include <vtkMergeFilter.h>
42 #include <vtkActor2D.h>
43 #include <vtkPolyData.h>
44 #include <vtkMaskPoints.h>
45 #include <vtkCellCenters.h>
46 #include <vtkTextProperty.h>
47 #include <vtkLabeledDataMapper.h>
48 #include <vtkSelectVisiblePoints.h>
50 #include <vtkScalarBarActor.h>
51 #include <vtkLookupTable.h>
52 #include <vtkDoubleArray.h>
55 static int MYDEBUG = 1;
56 static int MYDEBUGWITHFILES = 0;
58 static int MYDEBUG = 0;
59 static int MYDEBUGWITHFILES = 0;
65 inline float GetFloat(const QString& theValue, float theDefault = 0){
66 if(theValue.isEmpty()) return theDefault;
67 QString aValue = QAD_CONFIG->getSetting(theValue);
68 if(aValue.isEmpty()) return theDefault;
69 return aValue.toFloat();
73 SMESH_Actor* SMESH_Actor::New(){
74 return new SMESH_Actor();
78 SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj,
79 SMESH::FilterManager_ptr theFilterMgr,
84 SMESH_Actor* anActor = SMESH_Actor::New();
85 anActor->Init(theVisualObj,theFilterMgr,theEntry,theName,theIsClear);
90 SMESH_Actor::SMESH_Actor(){
91 if(MYDEBUG) MESSAGE("SMESH_Actor");
93 myIsPointsVisible = false;
95 myIsShrinkable = false;
98 float aPointSize = GetFloat("SMESH:SettingsNodesSize",3);
99 float aLineWidth = GetFloat("SMESH:SettingsWidth",1);
101 vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
102 SALOME_ExtractUnstructuredGrid* aFilter = NULL;
104 //Definition 2D and 3D divices of the actor
105 //-----------------------------------------
106 float anRGB[3] = {1,1,1};
107 mySurfaceProp = vtkProperty::New();
108 anRGB[0] = GetFloat("SMESH:SettingsFillColorRed", 0)/255.;
109 anRGB[1] = GetFloat("SMESH:SettingsFillColorGreen", 170)/255.;
110 anRGB[2] = GetFloat("SMESH:SettingsFillColorBlue", 255)/255.;
111 mySurfaceProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
113 myBackSurfaceProp = vtkProperty::New();
114 anRGB[0] = GetFloat("SMESH:SettingsBackFaceColorRed", 0)/255.;
115 anRGB[1] = GetFloat("SMESH:SettingsBackFaceColorGreen", 0)/255.;
116 anRGB[2] = GetFloat("SMESH:SettingsBackFaceColorBlue", 255)/255.;
117 myBackSurfaceProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
119 my2DActor = SMESH_DeviceActor::New();
120 my2DActor->SetUserMatrix(aMatrix);
121 my2DActor->SetStoreMapping(true);
122 my2DActor->PickableOff();
123 my2DActor->SetProperty(mySurfaceProp);
124 my2DActor->SetBackfaceProperty(myBackSurfaceProp);
125 my2DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
126 aFilter = my2DActor->GetExtractUnstructuredGrid();
127 aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding);
128 aFilter->RegisterCellsWithType(VTK_TRIANGLE);
129 aFilter->RegisterCellsWithType(VTK_POLYGON);
130 aFilter->RegisterCellsWithType(VTK_QUAD);
132 my3DActor = SMESH_DeviceActor::New();
133 my3DActor->SetUserMatrix(aMatrix);
134 my3DActor->SetStoreMapping(true);
135 my3DActor->PickableOff();
136 my3DActor->SetProperty(mySurfaceProp);
137 my3DActor->SetBackfaceProperty(myBackSurfaceProp);
138 my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
139 aFilter = my3DActor->GetExtractUnstructuredGrid();
140 aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding);
141 aFilter->RegisterCellsWithType(VTK_TETRA);
142 aFilter->RegisterCellsWithType(VTK_VOXEL);
143 aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
144 aFilter->RegisterCellsWithType(VTK_WEDGE);
145 aFilter->RegisterCellsWithType(VTK_PYRAMID);
148 //Definition 1D divice of the actor
149 //---------------------------------
150 myEdgeProp = vtkProperty::New();
151 myEdgeProp->SetAmbient(1.0);
152 myEdgeProp->SetDiffuse(0.0);
153 myEdgeProp->SetSpecular(0.0);
154 anRGB[0] = GetFloat("SMESH:SettingsOutlineColorRed", 0)/255.;
155 anRGB[1] = GetFloat("SMESH:SettingsOutlineColorGreen", 170)/255.;
156 anRGB[2] = GetFloat("SMESH:SettingsOutlineColorBlue", 255)/255.;
157 myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
158 myEdgeProp->SetLineWidth(aLineWidth);
160 my1DActor = SMESH_DeviceActor::New();
161 my1DActor->SetUserMatrix(aMatrix);
162 my1DActor->SetStoreMapping(true);
163 my1DActor->PickableOff();
164 my1DActor->SetProperty(myEdgeProp);
165 my1DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
166 aFilter = my1DActor->GetExtractUnstructuredGrid();
167 aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding);
168 aFilter->RegisterCellsWithType(VTK_LINE);
170 my1DProp = vtkProperty::New();
171 my1DProp->DeepCopy(myEdgeProp);
172 static int aCotnrolLineWidth = 3;
173 my1DProp->SetLineWidth(aCotnrolLineWidth);
174 my1DProp->SetPointSize(aPointSize);
176 my1DExtProp = vtkProperty::New();
177 my1DExtProp->DeepCopy(myEdgeProp);
178 anRGB[0] = 1 - anRGB[0];
179 anRGB[1] = 1 - anRGB[1];
180 anRGB[2] = 1 - anRGB[2];
181 my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
182 my1DExtProp->SetLineWidth(aCotnrolLineWidth);
184 my1DExtActor = SMESH_DeviceActor::New();
185 my1DExtActor->SetUserMatrix(aMatrix);
186 my1DExtActor->SetStoreMapping(true);
187 my1DExtActor->PickableOff();
188 my1DExtActor->SetVisibility(false);
189 my1DExtActor->SetProperty(my1DExtProp);
190 my1DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
191 aFilter = my1DExtActor->GetExtractUnstructuredGrid();
192 aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding);
193 aFilter->RegisterCellsWithType(VTK_LINE);
196 //Definition 0D divice of the actor
197 //---------------------------------
198 myNodeProp = vtkProperty::New();
199 anRGB[0] = GetFloat("SMESH:SettingsNodeColorRed",255)/255.;
200 anRGB[1] = GetFloat("SMESH:SettingsNodeColorGreen",0)/255.;
201 anRGB[2] = GetFloat("SMESH:SettingsNodeColorBlue",0)/255.;
202 myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
203 myNodeProp->SetPointSize(aPointSize);
205 myNodeActor = SMESH_DeviceActor::New();
206 myNodeActor->SetUserMatrix(aMatrix);
207 myNodeActor->SetStoreMapping(true);
208 myNodeActor->PickableOff();
209 myNodeActor->SetVisibility(false);
210 myNodeActor->SetProperty(myNodeProp);
211 myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
212 aFilter = myNodeActor->GetExtractUnstructuredGrid();
213 aFilter->SetModeOfExtraction(SALOME_ExtractUnstructuredGrid::ePoints);
216 //Definition of Pickable and Highlitable engines
217 //----------------------------------------------
219 myBaseActor = SMESH_DeviceActor::New();
220 myBaseActor->SetUserMatrix(aMatrix);
221 myBaseActor->SetStoreMapping(true);
222 myBaseActor->GetProperty()->SetOpacity(0.0);
224 myPickableActor = myBaseActor;
226 myHighlightProp = vtkProperty::New();
227 myHighlightProp->SetAmbient(1.0);
228 myHighlightProp->SetDiffuse(0.0);
229 myHighlightProp->SetSpecular(0.0);
230 anRGB[0] = GetFloat("SMESH:SettingsSelectColorRed", 255)/255.; // 1;
231 anRGB[1] = GetFloat("SMESH:SettingsSelectColorGreen", 255)/255.; // 1;
232 anRGB[2] = GetFloat("SMESH:SettingsSelectColorBlue", 255)/255.; // 1;
233 myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
234 myHighlightProp->SetPointSize(aPointSize);
235 myHighlightProp->SetRepresentation(1);
237 myPreselectProp = vtkProperty::New();
238 myPreselectProp->SetAmbient(1.0);
239 myPreselectProp->SetDiffuse(0.0);
240 myPreselectProp->SetSpecular(0.0);
241 anRGB[0] = GetFloat("SMESH:SettingsPreSelectColorRed", 0)/255.; // 0;
242 anRGB[1] = GetFloat("SMESH:SettingsPreSelectColorGreen", 255)/255.; // 1;
243 anRGB[2] = GetFloat("SMESH:SettingsPreSelectColorBlue", 255)/255.; // 1;
244 myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
245 myPreselectProp->SetPointSize(aPointSize);
246 myPreselectProp->SetRepresentation(1);
248 myHighlitableActor = SMESH_DeviceActor::New();
249 myHighlitableActor->SetUserMatrix(aMatrix);
250 myHighlitableActor->SetStoreMapping(false);
251 myHighlitableActor->PickableOff();
252 myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
255 SetShrinkFactor(GetFloat("SMESH:SettingsShrinkCoeff", 75)/100.);
261 ishighlighted = false;
262 ispreselected = false;
265 my1DColorMode = e1DNone;
266 myControlActor = my2DActor;
268 //Definition of myScalarBarActor
269 //------------------------------
270 myLookupTable = vtkLookupTable::New();
271 //Fix for Bug PAL5195 - SMESH764:
272 //Controls - Aspect Ratio: incorrect colors of the best and worst values
273 myLookupTable->SetHueRange(0.667,0.0);
275 myScalarBarActor = vtkScalarBarActor::New();
276 myScalarBarActor->SetVisibility(false);
277 myScalarBarActor->SetLookupTable(myLookupTable);
279 vtkTextProperty* aScalarBarTitleProp = vtkTextProperty::New();
281 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarTitleColor" ) ) {
282 QStringList aTColor = QStringList::split( ":", QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleColor" ), false );
283 aScalarBarTitleProp->SetColor( ( aTColor.count() > 0 ? aTColor[0].toInt()/255. : 1.0 ),
284 ( aTColor.count() > 1 ? aTColor[1].toInt()/255. : 1.0 ),
285 ( aTColor.count() > 2 ? aTColor[2].toInt()/255. : 1.0 ) );
288 aScalarBarTitleProp->SetColor( 1.0, 1.0, 1.0 );
290 aScalarBarTitleProp->SetFontFamilyToArial();
291 if( QAD_CONFIG->hasSetting( "SMESH:ScalarBarTitleFont" ) ){
292 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleFont" ) == "Arial" )
293 aScalarBarTitleProp->SetFontFamilyToArial();
294 else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleFont" ) == "Courier" )
295 aScalarBarTitleProp->SetFontFamilyToCourier();
296 else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleFont" ) == "Times" )
297 aScalarBarTitleProp->SetFontFamilyToTimes();
300 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleBold" ) == "true" )
301 aScalarBarTitleProp->BoldOn();
303 aScalarBarTitleProp->BoldOff();
305 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleItalic" ) == "true" )
306 aScalarBarTitleProp->ItalicOn();
308 aScalarBarTitleProp->ItalicOff();
310 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleShadow" ) == "true" )
311 aScalarBarTitleProp->ShadowOn();
313 aScalarBarTitleProp->ShadowOff();
315 myScalarBarActor->SetTitleTextProperty( aScalarBarTitleProp );
316 aScalarBarTitleProp->Delete();
318 vtkTextProperty* aScalarBarLabelProp = vtkTextProperty::New();
320 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarLabelColor" ) ) {
321 QStringList aTColor = QStringList::split( ":", QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelColor" ), false );
322 aScalarBarLabelProp->SetColor( ( aTColor.count() > 0 ? aTColor[0].toInt()/255. : 1.0 ),
323 ( aTColor.count() > 1 ? aTColor[1].toInt()/255. : 1.0 ),
324 ( aTColor.count() > 2 ? aTColor[2].toInt()/255. : 1.0 ) );
327 aScalarBarLabelProp->SetColor( 1.0, 1.0, 1.0 );
329 aScalarBarLabelProp->SetFontFamilyToArial();
330 if( QAD_CONFIG->hasSetting( "SMESH:ScalarBarLabelFont" ) ){
331 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelFont" ) == "Arial" )
332 aScalarBarLabelProp->SetFontFamilyToArial();
333 else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelFont" ) == "Courier" )
334 aScalarBarLabelProp->SetFontFamilyToCourier();
335 else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelFont" ) == "Times" )
336 aScalarBarLabelProp->SetFontFamilyToTimes();
339 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelBold" ) == "true" )
340 aScalarBarLabelProp->BoldOn();
342 aScalarBarLabelProp->BoldOff();
344 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelItalic" ) == "true" )
345 aScalarBarLabelProp->ItalicOn();
347 aScalarBarLabelProp->ItalicOff();
349 if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelShadow" ) == "true" )
350 aScalarBarLabelProp->ShadowOn();
352 aScalarBarLabelProp->ShadowOff();
354 myScalarBarActor->SetLabelTextProperty( aScalarBarLabelProp );
355 aScalarBarLabelProp->Delete();
357 if ( QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" )
358 myScalarBarActor->SetOrientationToHorizontal();
360 myScalarBarActor->SetOrientationToVertical();
362 float aXVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.20 : 0.01;
363 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarXPosition" ) )
364 aXVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarXPosition" ).toFloat();
365 float aYVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.01 : 0.1;
366 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarYPosition" ) )
367 aYVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarYPosition" ).toFloat();
368 myScalarBarActor->SetPosition( aXVal, aYVal );
370 float aWVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.60 : 0.10;
371 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarWidth" ) )
372 aWVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarWidth" ).toFloat();
373 myScalarBarActor->SetWidth( aWVal );
375 float aHVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.12 : 0.80;
376 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarHeight" ) )
377 aHVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarHeight" ).toFloat();
378 myScalarBarActor->SetHeight( aHVal );
381 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarNbOfLabels" ) )
382 anIntVal = QAD_CONFIG->getSetting("SMESH:ScalarBarNbOfLabels").toInt();
383 myScalarBarActor->SetNumberOfLabels(anIntVal == 0? 5: anIntVal);
386 if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarNbOfColors" ) )
387 anIntVal = QAD_CONFIG->getSetting("SMESH:ScalarBarNbOfColors").toInt();
388 myScalarBarActor->SetMaximumNumberOfColors(anIntVal == 0? 64: anIntVal);
391 //Definition of points numbering pipeline
392 //---------------------------------------
393 myPointsNumDataSet = vtkUnstructuredGrid::New();
395 myPtsMaskPoints = vtkMaskPoints::New();
396 myPtsMaskPoints->SetInput(myPointsNumDataSet);
397 myPtsMaskPoints->SetOnRatio(1);
399 myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
400 myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput());
401 myPtsSelectVisiblePoints->SelectInvisibleOff();
402 myPtsSelectVisiblePoints->SetTolerance(0.1);
404 myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
405 myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
406 myPtsLabeledDataMapper->SetLabelFormat("%g");
407 myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
409 vtkTextProperty* aPtsTextProp = vtkTextProperty::New();
410 aPtsTextProp->SetFontFamilyToTimes();
411 static int aPointsFontSize = 10;
412 aPtsTextProp->SetFontSize(aPointsFontSize);
413 aPtsTextProp->SetBold(1);
414 aPtsTextProp->SetItalic(0);
415 aPtsTextProp->SetShadow(0);
416 myPtsLabeledDataMapper->SetLabelTextProperty(aPtsTextProp);
417 aPtsTextProp->Delete();
419 myIsPointsLabeled = false;
421 myPointLabels = vtkActor2D::New();
422 myPointLabels->SetMapper(myPtsLabeledDataMapper);
423 myPointLabels->GetProperty()->SetColor(1,1,1);
424 myPointLabels->SetVisibility(myIsPointsLabeled);
427 //Definition of cells numbering pipeline
428 //---------------------------------------
429 myCellsNumDataSet = vtkUnstructuredGrid::New();
431 myCellCenters = vtkCellCenters::New();
432 myCellCenters->SetInput(myCellsNumDataSet);
434 myClsMaskPoints = vtkMaskPoints::New();
435 myClsMaskPoints->SetInput(myCellCenters->GetOutput());
436 myClsMaskPoints->SetOnRatio(1);
438 myClsSelectVisiblePoints = vtkSelectVisiblePoints::New();
439 myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput());
440 myClsSelectVisiblePoints->SelectInvisibleOff();
441 myClsSelectVisiblePoints->SetTolerance(0.1);
443 myClsLabeledDataMapper = vtkLabeledDataMapper::New();
444 myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
445 myClsLabeledDataMapper->SetLabelFormat("%g");
446 myClsLabeledDataMapper->SetLabelModeToLabelScalars();
448 vtkTextProperty* aClsTextProp = vtkTextProperty::New();
449 aClsTextProp->SetFontFamilyToTimes();
450 static int aCellsFontSize = 12;
451 aClsTextProp->SetFontSize(aCellsFontSize);
452 aClsTextProp->SetBold(1);
453 aClsTextProp->SetItalic(0);
454 aClsTextProp->SetShadow(0);
455 myClsLabeledDataMapper->SetLabelTextProperty(aClsTextProp);
456 aClsTextProp->Delete();
458 myIsCellsLabeled = false;
460 myCellsLabels = vtkActor2D::New();
461 myCellsLabels->SetMapper(myClsLabeledDataMapper);
462 myCellsLabels->GetProperty()->SetColor(0,1,0);
463 myCellsLabels->SetVisibility(myIsCellsLabeled);
467 SMESH_Actor::~SMESH_Actor(){
468 if(MYDEBUG) MESSAGE("~SMESH_Actor");
470 myScalarBarActor->Delete();
471 myLookupTable->Delete();
473 mySurfaceProp->Delete();
474 myBackSurfaceProp->Delete();
476 myEdgeProp->Delete();
477 myHighlightProp->Delete();
478 myPreselectProp->Delete();
480 myNodeProp->Delete();
485 my1DExtProp->Delete();
486 my1DExtActor->Delete();
491 myNodeActor->Delete();
492 myBaseActor->Delete();
493 myHighlitableActor->Delete();
496 //Deleting of pints numbering pipeline
497 //---------------------------------------
498 myPointsNumDataSet->Delete();
500 myPtsLabeledDataMapper->RemoveAllInputs();
501 myPtsLabeledDataMapper->Delete();
503 myPtsSelectVisiblePoints->UnRegisterAllOutputs();
504 myPtsSelectVisiblePoints->Delete();
506 myPtsMaskPoints->UnRegisterAllOutputs();
507 myPtsMaskPoints->Delete();
509 myPointLabels->Delete();
512 //Deleting of cells numbering pipeline
513 //---------------------------------------
514 myCellsNumDataSet->Delete();
516 myClsLabeledDataMapper->RemoveAllInputs();
517 myClsLabeledDataMapper->Delete();
519 myClsSelectVisiblePoints->UnRegisterAllOutputs();
520 myClsSelectVisiblePoints->Delete();
522 myClsMaskPoints->UnRegisterAllOutputs();
523 myClsMaskPoints->Delete();
525 myCellCenters->UnRegisterAllOutputs();
526 myCellCenters->Delete();
528 myCellsLabels->Delete();
532 void SMESH_Actor::SetPointsLabeled( bool theIsPointsLabeled )
534 myIsPointsLabeled = theIsPointsLabeled;
536 if ( myIsPointsLabeled )
538 myPointsNumDataSet->ShallowCopy( GetUnstructuredGrid() );
539 vtkDataSet *aDataSet = myPointsNumDataSet;
541 int aNbElem = aDataSet->GetNumberOfPoints();
543 vtkIntArray *anArray = vtkIntArray::New();
544 anArray->SetNumberOfValues( aNbElem );
546 for ( int anId = 0; anId < aNbElem; anId++ )
548 int aSMDSId = myVisualObj->GetNodeObjId( anId );
549 anArray->SetValue( anId, aSMDSId );
552 aDataSet->GetPointData()->SetScalars( anArray );
554 myPtsMaskPoints->SetInput( aDataSet );
555 myPointLabels->SetVisibility( GetVisibility() );
559 myPointLabels->SetVisibility( false );
562 SetRepresentation( GetRepresentation() );
566 void SMESH_Actor::SetCellsLabeled(bool theIsCellsLabeled){
567 myIsCellsLabeled = theIsCellsLabeled;
568 if(myIsCellsLabeled){
569 myCellsNumDataSet->ShallowCopy(GetUnstructuredGrid());
570 vtkDataSet *aDataSet = myCellsNumDataSet;
571 int aNbElem = aDataSet->GetNumberOfCells();
572 vtkIntArray *anArray = vtkIntArray::New();
573 anArray->SetNumberOfValues(aNbElem);
574 for(int anId = 0; anId < aNbElem; anId++){
575 int aSMDSId = myVisualObj->GetElemObjId(anId);
576 anArray->SetValue(anId,aSMDSId);
578 aDataSet->GetCellData()->SetScalars(anArray);
579 myCellCenters->SetInput(aDataSet);
580 myCellsLabels->SetVisibility(GetVisibility());
582 myCellsLabels->SetVisibility(false);
587 void SMESH_Actor::SetControlMode(eControl theMode){
589 my1DColorMode = e1DNone;
591 my1DActor->GetMapper()->SetScalarVisibility(false);
592 my2DActor->GetMapper()->SetScalarVisibility(false);
593 my3DActor->GetMapper()->SetScalarVisibility(false);
594 myScalarBarActor->SetVisibility(false);
596 bool anIsScalarVisible = theMode > eNone;
598 if(anIsScalarVisible){
599 SMESH::NumericalFunctor_var aFunctor;
600 SMESH::Predicate_var aPredicate;
604 aFunctor = myFilterMgr->CreateLength();
605 myControlActor = my1DActor;
608 aPredicate = myFilterMgr->CreateFreeBorders();
609 myControlActor = my1DActor;
611 case eMultiConnection:
612 aFunctor = myFilterMgr->CreateMultiConnection();
613 myControlActor = my1DActor;
616 aFunctor = myFilterMgr->CreateArea();
617 myControlActor = my2DActor;
620 aFunctor = myFilterMgr->CreateTaper();
621 myControlActor = my2DActor;
624 aFunctor = myFilterMgr->CreateAspectRatio();
625 myControlActor = my2DActor;
628 aFunctor = myFilterMgr->CreateMinimumAngle();
629 myControlActor = my2DActor;
632 aFunctor = myFilterMgr->CreateWarping();
633 myControlActor = my2DActor;
636 aFunctor = myFilterMgr->CreateSkew();
637 myControlActor = my2DActor;
643 vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid();
644 vtkIdType aNbCells = aGrid->GetNumberOfCells();
646 if(theMode == eFreeBorders){
647 if(!aPredicate->_is_nil()){
648 myVisualObj->UpdateFunctor(aPredicate);
649 SALOME_ExtractUnstructuredGrid* aFilter =
650 my1DExtActor->GetExtractUnstructuredGrid();
651 aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding);
652 aFilter->ClearRegisteredCells();
653 for( vtkIdType i = 0; i < aNbCells; i++ ){
654 vtkIdType anObjId = myControlActor->GetElemObjId( i );
655 CORBA::Boolean aValue = aPredicate->IsSatisfy(anObjId);
657 aFilter->RegisterCell(i);
659 if(!aFilter->IsCellsRegistered())
660 aFilter->RegisterCell(-1);
661 aPredicate->Destroy();
663 myColorMode = theMode;
664 my1DColorMode = e1DHighlited;
666 myColorMode = theMode;
667 if(myControlActor == my1DActor)
668 my1DColorMode = e1DColored;
670 vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New();
671 aDataSet->ShallowCopy(aGrid);
672 myScalarBarActor->SetVisibility(true);
673 myControlActor->GetMapper()->SetScalarVisibility(true);
675 vtkDoubleArray *aScalars = vtkDoubleArray::New();
676 aScalars->SetNumberOfComponents( 1 );
677 aScalars->SetNumberOfTuples(aNbCells);
679 if(!aFunctor->_is_nil()){
680 myVisualObj->UpdateFunctor(aFunctor);
681 for( vtkIdType i = 0; i < aNbCells; i++ ){
682 vtkIdType anObjId = myControlActor->GetElemObjId( i );
683 CORBA::Double aValue = aFunctor->GetValue(anObjId);
684 aScalars->SetValue( i, aValue );
687 }else if(!aPredicate->_is_nil()){
688 myVisualObj->UpdateFunctor(aPredicate);
689 for( vtkIdType i = 0; i < aNbCells; i++ ){
690 vtkIdType anObjId = myControlActor->GetElemObjId( i );
691 CORBA::Boolean aValue = aPredicate->IsSatisfy(anObjId);
692 aScalars->SetValue( i, aValue );
694 aPredicate->Destroy();
696 aDataSet->GetCellData()->SetScalars(aScalars);
700 aScalars->GetRange(aRange);
701 myLookupTable->SetRange(aRange);
702 myLookupTable->Build();
704 myControlActor->GetMergeFilter()->SetScalars(aDataSet);
707 WriteUnstructuredGrid(aDataSet,"/tmp/SetControlMode.vtk");
711 SetRepresentation(GetRepresentation());
717 void SMESH_Actor::AddToRender(vtkRenderer* theRenderer){
718 SALOME_Actor::AddToRender(theRenderer);
720 theRenderer->AddActor(myNodeActor);
721 theRenderer->AddActor(myBaseActor);
723 theRenderer->AddActor(my3DActor);
724 theRenderer->AddActor(my2DActor);
726 theRenderer->AddActor(my1DActor);
727 theRenderer->AddActor(my1DExtActor);
729 theRenderer->AddActor(myHighlitableActor);
731 theRenderer->AddActor2D(myScalarBarActor);
733 myPtsSelectVisiblePoints->SetRenderer(theRenderer);
734 myClsSelectVisiblePoints->SetRenderer(theRenderer);
736 theRenderer->AddActor2D(myPointLabels);
737 theRenderer->AddActor2D(myCellsLabels);
740 void SMESH_Actor::RemoveFromRender(vtkRenderer* theRenderer){
741 SALOME_Actor::RemoveFromRender(theRenderer);
743 theRenderer->RemoveActor(myNodeActor);
744 theRenderer->RemoveActor(myBaseActor);
745 theRenderer->RemoveActor(myHighlitableActor);
747 theRenderer->RemoveActor(my1DActor);
748 theRenderer->RemoveActor(my1DExtActor);
750 theRenderer->RemoveActor(my2DActor);
751 theRenderer->RemoveActor(my3DActor);
753 theRenderer->RemoveActor(myScalarBarActor);
754 theRenderer->RemoveActor(myPointLabels);
755 theRenderer->RemoveActor(myCellsLabels);
759 void SMESH_Actor::Init(TVisualObjPtr theVisualObj,
760 SMESH::FilterManager_ptr theFilterMgr,
761 const char* theEntry,
765 Handle(SALOME_InteractiveObject) anIO =
766 new SALOME_InteractiveObject(strdup(theEntry),strdup("MESH"),strdup(theName));
768 setName(strdup(theName));
770 myVisualObj = theVisualObj;
771 myNodeActor->myVisualObj = myVisualObj;
772 myBaseActor->myVisualObj = myVisualObj;
773 myHighlitableActor->myVisualObj = myVisualObj;
775 my1DActor->myVisualObj = myVisualObj;
776 my1DExtActor->myVisualObj = myVisualObj;
778 my2DActor->myVisualObj = myVisualObj;
779 my3DActor->myVisualObj = myVisualObj;
781 myVisualObj->Update(theIsClear);
782 SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
784 myFilterMgr = SMESH::FilterManager::_duplicate(theFilterMgr);
786 QString aMode = QAD_CONFIG->getSetting("SMESH:DisplayMode");
787 SetRepresentation(-1);
788 if(aMode.compare("Wireframe") == 0){
789 SetRepresentation(eEdge);
790 }else if(aMode.compare("Shading") == 0){
791 SetRepresentation(eSurface);
792 }else if(aMode.compare("Nodes") == 0){
793 SetRepresentation(ePoint);
796 aMode = QAD_CONFIG->getSetting("SMESH:Shrink");
805 vtkPolyData* SMESH_Actor::GetPolyDataInput(){
806 return myPickableActor->GetPolyDataInput();
810 void SMESH_Actor::SetTransform(SALOME_Transform* theTransform){
811 myNodeActor->SetTransform(theTransform);
812 myBaseActor->SetTransform(theTransform);
813 myHighlitableActor->SetTransform(theTransform);
815 my1DActor->SetTransform(theTransform);
816 my1DExtActor->SetTransform(theTransform);
818 my2DActor->SetTransform(theTransform);
819 my3DActor->SetTransform(theTransform);
825 void SMESH_Actor::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid){
827 myNodeActor->SetUnstructuredGrid(theGrid);
828 myBaseActor->SetUnstructuredGrid(theGrid);
829 myHighlitableActor->SetUnstructuredGrid(theGrid);
831 my1DActor->SetUnstructuredGrid(theGrid);
832 my1DExtActor->SetUnstructuredGrid(theGrid);
834 my2DActor->SetUnstructuredGrid(theGrid);
835 my3DActor->SetUnstructuredGrid(theGrid);
837 my1DActor->GetMapper()->SetLookupTable(myLookupTable);
838 my2DActor->GetMapper()->SetLookupTable(myLookupTable);
839 my3DActor->GetMapper()->SetLookupTable(myLookupTable);
841 float aFactor, aUnits;
842 my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
843 my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
845 //SetIsShrunkable(theGrid->GetNumberOfCells() > 10);
846 SetIsShrunkable(true);
853 void SMESH_Actor::SetMapper(vtkMapper* theMapper){
854 vtkLODActor::SetMapper(theMapper);
858 void SMESH_Actor::ShallowCopy(vtkProp *prop){
859 SALOME_Actor::ShallowCopy(prop);
863 vtkMapper* SMESH_Actor::GetMapper(){
864 return myPickableActor->GetMapper();
868 vtkUnstructuredGrid* SMESH_Actor::GetUnstructuredGrid(){
869 return myVisualObj->GetUnstructuredGrid();
873 bool SMESH_Actor::IsInfinitive(){
874 vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
876 myIsInfinite = aDataSet->GetNumberOfCells() == 0;
877 return SALOME_Actor::IsInfinitive();
881 void SMESH_Actor::SetIsShrunkable(bool theShrunkable){
882 myIsShrinkable = theShrunkable;
886 float SMESH_Actor::GetShrinkFactor(){
887 return myBaseActor->GetShrinkFactor();
890 void SMESH_Actor::SetShrinkFactor(float theValue){
891 myBaseActor->SetShrinkFactor(theValue);
893 my1DActor->SetShrinkFactor(theValue);
894 my1DExtActor->SetShrinkFactor(theValue);
896 my2DActor->SetShrinkFactor(theValue);
897 my3DActor->SetShrinkFactor(theValue);
902 void SMESH_Actor::SetShrink(){
903 if(!myIsShrinkable) return;
905 myBaseActor->SetShrink();
907 my1DActor->SetShrink();
908 my1DExtActor->SetShrink();
910 my2DActor->SetShrink();
911 my3DActor->SetShrink();
917 void SMESH_Actor::UnShrink(){
918 if(!myIsShrunk) return;
920 myBaseActor->UnShrink();
922 my1DActor->UnShrink();
923 my1DExtActor->UnShrink();
925 my2DActor->UnShrink();
926 my3DActor->UnShrink();
933 int SMESH_Actor::GetObjId(int theVtkID){
934 if (GetRepresentation() == 0){
935 return GetNodeObjId(theVtkID);
937 return GetElemObjId(theVtkID);
941 SALOME_Actor::TVectorId SMESH_Actor::GetVtkId(int theObjID){
942 if (GetRepresentation() == 0){
943 return GetNodeVtkId(theObjID);
945 return GetElemVtkId(theObjID);
950 int SMESH_Actor::GetNodeObjId(int theVtkID){
951 return myPickableActor->GetNodeObjId(theVtkID);
954 SALOME_Actor::TVectorId SMESH_Actor::GetNodeVtkId(int theObjID){
955 return myPickableActor->GetNodeVtkId(theObjID);
959 int SMESH_Actor::GetElemObjId(int theVtkID){
960 return myPickableActor->GetElemObjId(theVtkID);
963 SALOME_Actor::TVectorId SMESH_Actor::GetElemVtkId(int theObjID){
964 return myPickableActor->GetElemVtkId(theObjID);
968 void SMESH_Actor::SetVisibility(int theMode){
969 SALOME_Actor::SetVisibility(theMode);
971 SetRepresentation(GetRepresentation());
973 if(myColorMode != eNone){
974 if(my1DColorMode == e1DHighlited)
975 my1DExtActor->VisibilityOn();
976 else if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
977 myScalarBarActor->VisibilityOn();
980 if(myRepresentation != ePoint)
981 myPickableActor->VisibilityOn();
983 my1DActor->VisibilityOn();
985 my2DActor->VisibilityOn();
986 my3DActor->VisibilityOn();
988 if(myIsPointsLabeled) myPointLabels->VisibilityOn();
989 if(myIsCellsLabeled) myCellsLabels->VisibilityOn();
991 myNodeActor->VisibilityOff();
992 myBaseActor->VisibilityOff();
994 my1DActor->VisibilityOff();
995 my1DExtActor->VisibilityOff();
997 my2DActor->VisibilityOff();
998 my3DActor->VisibilityOff();
1000 myScalarBarActor->VisibilityOff();
1001 myPointLabels->VisibilityOff();
1002 myCellsLabels->VisibilityOff();
1008 void SMESH_Actor::SetRepresentation(int theMode){
1009 int aNbEdges = myVisualObj->GetNbEntities(SMESH::EDGE);
1010 int aNbFaces = myVisualObj->GetNbEntities(SMESH::FACE);
1011 int aNbVolumes = myVisualObj->GetNbEntities(SMESH::VOLUME);
1013 myRepresentation = eSurface;
1014 if(!aNbFaces && !aNbVolumes && aNbEdges){
1015 myRepresentation = eEdge;
1016 }else if(!aNbFaces && !aNbVolumes && !aNbEdges){
1017 myRepresentation = ePoint;
1022 if(!aNbFaces && !aNbVolumes && !aNbEdges) return;
1025 if(!aNbFaces && !aNbVolumes) return;
1028 myRepresentation = theMode;
1031 if(!GetUnstructuredGrid()->GetNumberOfCells())
1032 myRepresentation = ePoint;
1035 if(myRepresentation == ePoint){
1043 myPickableActor = myBaseActor;
1044 myNodeActor->SetVisibility(false);
1045 vtkProperty *aProp = NULL, *aBackProp = NULL;
1046 SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
1047 switch(myRepresentation){
1049 myPickableActor = myNodeActor;
1050 aProp = aBackProp = myNodeProp;
1051 aReperesent = SMESH_DeviceActor::ePoint;
1054 aProp = aBackProp = myEdgeProp;
1055 aReperesent = SMESH_DeviceActor::eInsideframe;
1058 aProp = mySurfaceProp;
1059 aBackProp = myBackSurfaceProp;
1060 aReperesent = SMESH_DeviceActor::eSurface;
1064 my2DActor->SetProperty(aProp);
1065 my2DActor->SetBackfaceProperty(aBackProp);
1066 my2DActor->SetRepresentation(aReperesent);
1068 my3DActor->SetProperty(aProp);
1069 my3DActor->SetBackfaceProperty(aBackProp);
1070 my3DActor->SetRepresentation(aReperesent);
1072 my1DExtActor->SetVisibility(false);
1073 switch(my1DColorMode){
1075 aProp = aBackProp = my1DProp;
1076 if(myRepresentation != ePoint)
1077 aReperesent = SMESH_DeviceActor::eInsideframe;
1080 my1DExtActor->SetVisibility(true);
1084 my1DActor->SetProperty(aProp);
1085 my1DActor->SetBackfaceProperty(aBackProp);
1086 my1DActor->SetRepresentation(aReperesent);
1088 if ( GetPointRepresentation() || !GetUnstructuredGrid()->GetNumberOfCells() || myIsPointsLabeled )
1090 myPickableActor = myNodeActor;
1091 myNodeActor->SetVisibility(true);
1094 SetMapper(myPickableActor->GetMapper());
1100 void SMESH_Actor::SetPointRepresentation(int theIsPointsVisible){
1101 myIsPointsVisible = theIsPointsVisible;
1102 SetRepresentation(GetRepresentation());
1106 void SMESH_Actor::UpdateHighlight(){
1107 myHighlitableActor->SetVisibility(false);
1108 myNodeActor->SetProperty(myNodeProp);
1109 if(myPickableActor != myNodeActor)
1110 myNodeActor->SetVisibility(false);
1113 myHighlitableActor->SetProperty(myHighlightProp);
1114 }else if(ispreselected){
1115 myHighlitableActor->SetProperty(myPreselectProp);
1118 if(ishighlighted || ispreselected){
1119 if(!GetUnstructuredGrid()->GetNumberOfCells()){
1120 myNodeActor->SetProperty(myHighlitableActor->GetProperty());
1121 myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
1122 myNodeActor->SetVisibility(GetVisibility());
1124 myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
1125 myHighlitableActor->SetVisibility(GetVisibility());
1131 void SMESH_Actor::highlight(Standard_Boolean highlight){
1132 ishighlighted = highlight;
1137 void SMESH_Actor::SetPreSelected(Standard_Boolean presel){
1138 ispreselected = presel;
1144 int SMESH_Actor::RenderOpaqueGeometry(vtkViewport *vp)
1146 if (myPickableActor->GetIsOpaque())
1148 vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
1156 int SMESH_Actor::RenderTranslucentGeometry(vtkViewport *vp)
1158 if (!myPickableActor->GetIsOpaque())
1160 vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
1168 void SMESH_Actor::Render(vtkRenderer *ren){}
1171 void SMESH_Actor::ReleaseGraphicsResources(vtkWindow *renWin){
1172 SALOME_Actor::ReleaseGraphicsResources(renWin);
1174 myPickableActor->ReleaseGraphicsResources(renWin);
1178 static void GetColor(vtkProperty *theProperty, float& r,float& g,float& b){
1179 float* aColor = theProperty->GetColor();
1186 void SMESH_Actor::SetOpacity(float theValue){
1187 mySurfaceProp->SetOpacity(theValue);
1188 myBackSurfaceProp->SetOpacity(theValue);
1189 myEdgeProp->SetOpacity(theValue);
1190 myNodeProp->SetOpacity(theValue);
1192 my1DProp->SetOpacity(theValue);
1196 float SMESH_Actor::GetOpacity(){
1197 return mySurfaceProp->GetOpacity();
1201 void SMESH_Actor::SetSufaceColor(float r,float g,float b){
1202 mySurfaceProp->SetColor(r,g,b);
1206 void SMESH_Actor::GetSufaceColor(float& r,float& g,float& b){
1207 ::GetColor(mySurfaceProp,r,g,b);
1210 void SMESH_Actor::SetBackSufaceColor(float r,float g,float b){
1211 myBackSurfaceProp->SetColor(r,g,b);
1215 void SMESH_Actor::GetBackSufaceColor(float& r,float& g,float& b){
1216 ::GetColor(myBackSurfaceProp,r,g,b);
1219 void SMESH_Actor::SetEdgeColor(float r,float g,float b){
1220 myEdgeProp->SetColor(r,g,b);
1221 my1DProp->SetColor(r,g,b);
1222 my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
1226 void SMESH_Actor::GetEdgeColor(float& r,float& g,float& b){
1227 ::GetColor(myEdgeProp,r,g,b);
1230 void SMESH_Actor::SetNodeColor(float r,float g,float b){
1231 myNodeProp->SetColor(r,g,b);
1235 void SMESH_Actor::GetNodeColor(float& r,float& g,float& b){
1236 ::GetColor(myNodeProp,r,g,b);
1239 void SMESH_Actor::SetHighlightColor(float r,float g,float b){
1240 myHighlightProp->SetColor(r,g,b);
1244 void SMESH_Actor::GetHighlightColor(float& r,float& g,float& b){
1245 ::GetColor(myHighlightProp,r,g,b);
1248 void SMESH_Actor::SetPreHighlightColor(float r,float g,float b){
1249 myPreselectProp->SetColor(r,g,b);
1253 void SMESH_Actor::GetPreHighlightColor(float& r,float& g,float& b){
1254 ::GetColor(myPreselectProp,r,g,b);
1258 float SMESH_Actor::GetLineWidth(){
1259 return myEdgeProp->GetLineWidth();
1263 void SMESH_Actor::SetLineWidth(float theVal){
1264 myEdgeProp->SetLineWidth(theVal);
1269 void SMESH_Actor::SetNodeSize(float theSize){
1270 myNodeProp->SetPointSize(theSize);
1271 myHighlightProp->SetPointSize(theSize);
1272 myPreselectProp->SetPointSize(theSize);
1274 my1DExtProp->SetPointSize(theSize);
1275 my1DProp->SetPointSize(theSize);
1280 float SMESH_Actor::GetNodeSize(){
1281 return myNodeProp->GetPointSize();
1284 int SMESH_Actor::GetObjDimension( const int theObjId )
1286 return myVisualObj->GetElemDimension( theObjId );