]> SALOME platform Git repositories - modules/smesh.git/blob - src/OBJECT/SMESH_ScalarBarActor.cxx
Salome HOME
0022400: EDF SMESH: ExportCGNS is not available anymore in V7_main
[modules/smesh.git] / src / OBJECT / SMESH_ScalarBarActor.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 //  File   : SMESH_ScalarBarActor.cxx
23 //  Author : Roman NIKOLAEV
24 //  Module : SMESH
25 //
26
27 #include "SMESH_ScalarBarActor.h"
28
29 #include <vtkCellArray.h>
30 #include <vtkCellData.h>
31 #include <vtkObjectFactory.h>
32 #include <vtkPolyData.h>
33 #include <vtkPolyDataMapper2D.h>
34 #include <vtkScalarsToColors.h>
35 #include <vtkTextMapper.h>
36 #include <vtkTextProperty.h>
37 #include <vtkViewport.h>
38 #include <vtkWindow.h>
39 #include <vtkLookupTable.h>
40 #include <vtkProperty2D.h>
41
42 #define SHRINK_COEF 0.08;
43
44 vtkStandardNewMacro(SMESH_ScalarBarActor);
45
46 vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
47 vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);
48 vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty);
49
50 //----------------------------------------------------------------------------
51 // Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
52 // format, no title, and vertical orientation. The initial scalar bar
53 // size is (0.05 x 0.8) of the viewport size.
54 SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
55   this->LookupTable = NULL;
56   this->Position2Coordinate->SetValue(0.17, 0.8);
57   
58   this->PositionCoordinate->SetCoordinateSystemToNormalizedViewport();
59   this->PositionCoordinate->SetValue(0.82,0.1);
60   
61   this->MaximumNumberOfColors = 64;
62   this->NumberOfLabels = 5;
63   this->NumberOfLabelsBuilt = 0;
64   this->Orientation = VTK_ORIENT_VERTICAL;
65   this->Title = NULL;
66
67   this->LabelTextProperty = vtkTextProperty::New();
68   this->LabelTextProperty->SetFontSize(12);
69   this->LabelTextProperty->SetBold(1);
70   this->LabelTextProperty->SetItalic(1);
71   this->LabelTextProperty->SetShadow(1);
72   this->LabelTextProperty->SetFontFamilyToArial();
73
74   this->TitleTextProperty = vtkTextProperty::New();
75   this->TitleTextProperty->ShallowCopy(this->LabelTextProperty);
76
77   this->LabelFormat = new char[8]; 
78   sprintf(this->LabelFormat,"%s","%-#6.3g");
79
80   this->TitleMapper = vtkTextMapper::New();
81   this->TitleActor = vtkActor2D::New();
82   this->TitleActor->SetMapper(this->TitleMapper);
83   this->TitleActor->GetPositionCoordinate()->
84     SetReferenceCoordinate(this->PositionCoordinate);
85   
86   this->TextMappers = NULL;
87   this->TextActors = NULL;
88
89   this->ScalarBar = vtkPolyData::New();
90   this->ScalarBarMapper = vtkPolyDataMapper2D::New();
91   this->ScalarBarMapper->SetInputData(this->ScalarBar);
92   this->ScalarBarActor = vtkActor2D::New();
93   this->ScalarBarActor->SetMapper(this->ScalarBarMapper);
94   this->ScalarBarActor->GetPositionCoordinate()->
95     SetReferenceCoordinate(this->PositionCoordinate);
96   this->LastOrigin[0] = 0;
97   this->LastOrigin[1] = 0;
98   this->LastSize[0] = 0;
99   this->LastSize[1] = 0;
100
101
102   // rnv begin
103   // Customization of the vtkScalarBarActor to show distribution histogram.
104   myDistribution = vtkPolyData::New();
105   myDistributionMapper = vtkPolyDataMapper2D::New();
106   myDistributionMapper->SetInputData(this->myDistribution);
107   
108   myDistributionActor = vtkActor2D::New();
109   myDistributionActor->SetMapper(this->myDistributionMapper);
110   myDistributionActor->GetPositionCoordinate()->
111     SetReferenceCoordinate(this->PositionCoordinate);
112
113   // By default distribution histogram is invisible
114   myDistributionActor->SetVisibility(0);
115
116   // By default monocolor
117   myDistributionColoringType = SMESH_MONOCOLOR_TYPE;
118   // rnv end
119 }
120
121 //----------------------------------------------------------------------------
122 // Release any graphics resources that are being consumed by this actor.
123 // The parameter window could be used to determine which graphic
124 // resources to release.
125 void SMESH_ScalarBarActor::ReleaseGraphicsResources(vtkWindow *win)
126 {
127   this->TitleActor->ReleaseGraphicsResources(win);
128   if (this->TextMappers != NULL )
129     {
130     for (int i=0; i < this->NumberOfLabelsBuilt; i++)
131       {
132       this->TextActors[i]->ReleaseGraphicsResources(win);
133       }
134     }
135   this->ScalarBarActor->ReleaseGraphicsResources(win);
136   // rnv begin
137   // Customization of the vtkScalarBarActor to show distribution histogram.
138   myDistributionActor->ReleaseGraphicsResources(win);
139 }
140
141
142 /*--------------------------------------------------------------------------*/
143 SMESH_ScalarBarActor::~SMESH_ScalarBarActor() {
144   if (this->LabelFormat) 
145     {
146     delete [] this->LabelFormat;
147     this->LabelFormat = NULL;
148     }
149
150   this->TitleMapper->Delete();
151   this->TitleActor->Delete();
152
153   if (this->TextMappers != NULL )
154     {
155     for (int i=0; i < this->NumberOfLabelsBuilt; i++)
156       {
157       this->TextMappers[i]->Delete();
158       this->TextActors[i]->Delete();
159       }
160     delete [] this->TextMappers;
161     delete [] this->TextActors;
162     }
163
164   this->ScalarBar->Delete();
165   this->ScalarBarMapper->Delete();
166   this->ScalarBarActor->Delete();
167
168   if (this->Title)
169     {
170     delete [] this->Title;
171     this->Title = NULL;
172     }
173   
174   this->SetLookupTable(NULL);
175   this->SetLabelTextProperty(NULL);
176   this->SetTitleTextProperty(NULL);
177   
178   // rnv begin
179   // Customization of the vtkScalarBarActor to show distribution histogram:
180   myDistribution->Delete();
181   myDistributionMapper->Delete();
182   myDistributionActor->Delete();
183   // rnv end
184 }
185
186 //----------------------------------------------------------------------------
187 int SMESH_ScalarBarActor::RenderOverlay(vtkViewport *viewport)
188 {
189   int renderedSomething = 0;
190   int i;
191   
192   // Everything is built, just have to render
193   if (this->Title != NULL)
194     {
195     renderedSomething += this->TitleActor->RenderOverlay(viewport);
196     }
197   this->ScalarBarActor->RenderOverlay(viewport);
198   this->myDistributionActor->RenderOverlay(viewport);
199   if( this->TextActors == NULL)
200     {
201      vtkWarningMacro(<<"Need a mapper to render a scalar bar");
202      return renderedSomething;
203     }
204   
205   for (i=0; i<this->NumberOfLabels; i++)
206     {
207     renderedSomething += this->TextActors[i]->RenderOverlay(viewport);
208     }
209
210   renderedSomething = (renderedSomething > 0)?(1):(0);
211
212   return renderedSomething;
213 }
214
215
216 //----------------------------------------------------------------------------
217 int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
218 {
219   int renderedSomething = 0;
220   int i;
221   int size[2];
222   
223   if (!this->LookupTable)
224     {
225     vtkWarningMacro(<<"Need a mapper to render a scalar bar");
226     return 0;
227     }
228
229   if (!this->TitleTextProperty)
230     {
231     vtkErrorMacro(<<"Need title text property to render a scalar bar");
232     return 0;
233     }
234
235   if (!this->LabelTextProperty)
236     {
237     vtkErrorMacro(<<"Need label text property to render a scalar bar");
238     return 0;
239     }
240
241   // Check to see whether we have to rebuild everything
242   int positionsHaveChanged = 0;
243   if (viewport->GetMTime() > this->BuildTime || 
244       (viewport->GetVTKWindow() && 
245        viewport->GetVTKWindow()->GetMTime() > this->BuildTime))
246     {
247     // if the viewport has changed we may - or may not need
248     // to rebuild, it depends on if the projected coords chage
249     int *barOrigin;
250     barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport);
251     size[0] = 
252       this->Position2Coordinate->GetComputedViewportValue(viewport)[0] -
253       barOrigin[0];
254     size[1] = 
255       this->Position2Coordinate->GetComputedViewportValue(viewport)[1] -
256       barOrigin[1];
257     if (this->LastSize[0] != size[0] || 
258         this->LastSize[1] != size[1] ||
259         this->LastOrigin[0] != barOrigin[0] || 
260         this->LastOrigin[1] != barOrigin[1])
261       {
262       positionsHaveChanged = 1;
263       }
264     }
265   
266   // Check to see whether we have to rebuild everything
267   if (positionsHaveChanged ||
268       this->GetMTime() > this->BuildTime || 
269       this->LookupTable->GetMTime() > this->BuildTime ||
270       this->LabelTextProperty->GetMTime() > this->BuildTime ||
271       this->TitleTextProperty->GetMTime() > this->BuildTime)
272     {
273     vtkDebugMacro(<<"Rebuilding subobjects");
274
275     // Delete previously constructed objects
276     //
277     if (this->TextMappers != NULL )
278       {
279       for (i=0; i < this->NumberOfLabelsBuilt; i++)
280         {
281         this->TextMappers[i]->Delete();
282         this->TextActors[i]->Delete();
283         }
284       delete [] this->TextMappers;
285       delete [] this->TextActors;
286       }
287
288     // Build scalar bar object; determine its type
289     //
290     // is this a vtkLookupTable or a subclass of vtkLookupTable 
291     // with its scale set to log
292     // NOTE: it's possible we could to without the 'lut' variable
293     // later in the code, but if the vtkLookupTableSafeDownCast operation
294     // fails for some reason, this code will break in new ways. So, the 'LUT'
295     // variable is used for this operation only
296     vtkLookupTable *LUT = vtkLookupTable::SafeDownCast( this->LookupTable );
297     int isLogTable = 0;
298     if ( LUT )
299       {
300       if ( LUT->GetScale() == VTK_SCALE_LOG10 )
301         {
302         isLogTable = 1; 
303         }
304       }
305     
306     // we hard code how many steps to display
307     vtkScalarsToColors *lut = this->LookupTable;
308     int numColors = this->MaximumNumberOfColors;
309     double *range = lut->GetRange();
310
311     int numPts = 2*(numColors + 1);
312     vtkPoints *pts = vtkPoints::New();
313     pts->SetNumberOfPoints(numPts);
314     vtkCellArray *polys = vtkCellArray::New();
315     polys->Allocate(polys->EstimateSize(numColors,4));
316     vtkUnsignedCharArray *colors = vtkUnsignedCharArray::New();
317     colors->SetNumberOfComponents(3);
318     colors->SetNumberOfTuples(numColors);
319
320
321     // rnv begin
322     // Customization of the vtkScalarBarActor to show distribution histogram.
323     bool distrVisibility =  (numColors == this->myNbValues.size());
324     vtkPoints *distrPts;
325     vtkCellArray *distrPolys;
326     vtkUnsignedCharArray *distColors = 0;
327     int numDistrPts = 0, numPositiveVal=0, maxValue=0;
328     if(!distrVisibility)
329       vtkDebugMacro(<<" Distribution invisible, because numColors == this->myNbValues.size()");
330
331     if (distrVisibility && GetDistributionVisibility()) {
332       for( i=0 ;i<myNbValues.size();i++ ) {
333         if(myNbValues[i]) {
334           numPositiveVal++;
335           maxValue = std::max(maxValue,myNbValues[i]);
336         } 
337       }
338       numDistrPts = 4*(numPositiveVal);
339       distrPts = vtkPoints::New();
340       distrPolys = vtkCellArray::New();
341       distrPts->SetNumberOfPoints(numDistrPts);
342       distrPolys->Allocate(distrPolys->EstimateSize(numPositiveVal,4));
343       this->myDistribution->Initialize();
344       this->myDistribution->SetPoints(distrPts);
345       this->myDistribution->SetPolys(distrPolys);
346       distrPts->Delete();
347       distrPolys->Delete();
348       if ( myDistributionColoringType == SMESH_MULTICOLOR_TYPE ) {
349         distColors = vtkUnsignedCharArray::New();
350         distColors->SetNumberOfComponents(3);
351         distColors->SetNumberOfTuples(numPositiveVal);
352         this->myDistribution->GetCellData()->SetScalars(distColors);
353         distColors->Delete();
354       } else if( myDistributionColoringType == SMESH_MONOCOLOR_TYPE ){
355         this->myDistribution->GetCellData()->SetScalars(NULL);
356       }
357     } else {
358       myDistribution->Reset();
359     }
360     // rnv end
361
362     this->ScalarBarActor->SetProperty(this->GetProperty());
363     this->ScalarBar->Initialize();
364     this->ScalarBar->SetPoints(pts);
365     this->ScalarBar->SetPolys(polys);
366     this->ScalarBar->GetCellData()->SetScalars(colors);
367     pts->Delete(); polys->Delete(); colors->Delete();
368
369     // get the viewport size in display coordinates
370     int *barOrigin, barWidth, barHeight, distrHeight;
371     barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport);
372     size[0] = 
373       this->Position2Coordinate->GetComputedViewportValue(viewport)[0] -
374       barOrigin[0];
375     size[1] = 
376       this->Position2Coordinate->GetComputedViewportValue(viewport)[1] -
377       barOrigin[1];
378     this->LastOrigin[0] = barOrigin[0];
379     this->LastOrigin[1] = barOrigin[1];
380     this->LastSize[0] = size[0];
381     this->LastSize[1] = size[1];
382     
383     // Update all the composing objects
384     this->TitleActor->SetProperty(this->GetProperty());
385     this->TitleMapper->SetInput(this->Title);
386     if (this->TitleTextProperty->GetMTime() > this->BuildTime)
387       {
388       // Shallow copy here so that the size of the title prop is not affected
389       // by the automatic adjustment of its text mapper's size (i.e. its
390       // mapper's text property is identical except for the font size
391       // which will be modified later). This allows text actors to
392       // share the same text property, and in that case specifically allows
393       // the title and label text prop to be the same.
394       this->TitleMapper->GetTextProperty()->ShallowCopy(this->TitleTextProperty);
395       this->TitleMapper->GetTextProperty()->SetJustificationToCentered();
396       }
397     
398     // find the best size for the title font
399     int titleSize[2];
400     this->SizeTitle(titleSize, size, viewport);
401     
402     // find the best size for the ticks
403     int labelSize[2];
404     this->AllocateAndSizeLabels(labelSize, size, viewport,range);
405     this->NumberOfLabelsBuilt = this->NumberOfLabels;
406     
407     // generate points
408     double x[3]; x[2] = 0.0;
409     double delta, itemH, shrink;
410     if ( this->Orientation == VTK_ORIENT_VERTICAL ) {
411       // rnv begin
412       // Customization of the vtkScalarBarActor to show distribution histogram.
413       double delimeter=0.0;
414       if(GetDistributionVisibility() && distrVisibility) {
415         delimeter=0.01*size[0]; //1 % from horizontal size of the full presentation size.
416         barWidth = size[0] - 4 - labelSize[0];
417         distrHeight = barWidth/2;
418       } else {
419         barWidth = size[0] - 4 - labelSize[0];
420         distrHeight = 0;
421       }
422
423       barHeight = (int)(0.86*size[1]);
424       delta=(double)barHeight/numColors;
425       
426       for ( i=0; i<numPts/2; i++ ) {
427         x[0] = distrHeight+delimeter/2.0;
428         x[1] = i*delta;
429         pts->SetPoint(2*i,x);
430         x[0] = barWidth;
431         pts->SetPoint(2*i+1,x);
432       }
433
434       if(GetDistributionVisibility() && distrVisibility) {
435         // Distribution points 
436         shrink = delta*SHRINK_COEF;
437         vtkIdType distPtsId=0;
438         vtkIdType distPtsIds[4];
439         for(i=0; i<numColors; i++) {
440           if(myNbValues[i]) {
441             itemH = distrHeight*((double)myNbValues[i]/maxValue);
442             
443             if(distrHeight == itemH) 
444               itemH = itemH - delimeter/2;
445
446             x[1] = i*delta+shrink;
447
448             // first point of polygon (quadrangle)
449             x[0] = 0; 
450             distPtsIds[0] = distPtsId;
451             distrPts->SetPoint(distPtsId++,x);
452
453             // second point of polygon (quadrangle)
454             x[0] = itemH;
455             distPtsIds[1] = distPtsId;
456             distrPts->SetPoint(distPtsId++,x);
457
458             x[1] = i*delta+delta-shrink;
459
460             // third point of polygon (quadrangle)
461             x[0] = 0; 
462             distPtsIds[3] = distPtsId;
463             distrPts->SetPoint(distPtsId++,x);
464
465             // fourth point of polygon (quadrangle)
466             x[0] = itemH;
467             distPtsIds[2] = distPtsId;
468             distrPts->SetPoint(distPtsId++,x);
469
470             //Inser Quadrangle
471             distrPolys->InsertNextCell(4,distPtsIds);
472           }
473         }
474       }    
475     }
476     // rnv end
477     else {
478       barWidth = size[0];
479       
480       // rnv begin
481       // Customization of the vtkScalarBarActor to show distribution histogram.
482       double coef1, delimeter=0.0;
483       if(GetDistributionVisibility() && distrVisibility) {
484         coef1=0.62;
485         distrHeight = (int)((coef1/2)*size[1]);
486         //delimeter between distribution diagram and scalar bar 
487         delimeter=0.02*size[1];
488       }
489       else {
490         coef1=0.4;
491         barHeight = (int)(coef1*size[1]);
492         distrHeight = 0;
493       }
494       
495       barHeight = (int)(coef1*size[1]);
496       
497       delta=(double)barWidth/numColors;
498       for (i=0; i<numPts/2; i++) {
499         x[0] = i*delta;
500         x[1] = barHeight;
501         pts->SetPoint(2*i,x);                        
502         x[1] = distrHeight + delimeter;
503         pts->SetPoint(2*i+1,x);
504       }
505       
506       if(GetDistributionVisibility() && distrVisibility) {
507         // Distribution points 
508         shrink = delta*SHRINK_COEF;
509         vtkIdType distPtsId=0;
510         vtkIdType distPtsIds[4];
511         for(i=0; i<numColors; i++) {
512           if(myNbValues[i]) {
513             itemH = distrHeight*((double)myNbValues[i]/maxValue);
514             
515             // first point of polygon (quadrangle)
516             x[0] = i*delta+shrink; 
517             x[1] = 0;
518             distPtsIds[0] = distPtsId;
519             distrPts->SetPoint(distPtsId++,x);
520             
521             // second point of polygon (quadrangle)
522             x[0] = i*delta+shrink; 
523             x[1] = itemH;
524             distPtsIds[3] = distPtsId;
525             distrPts->SetPoint(distPtsId++,x);
526             
527             // third point of polygon (quadrangle)
528             x[0] = i*delta+delta-shrink; 
529             x[1] = 0;
530             distPtsIds[1] = distPtsId;
531             distrPts->SetPoint(distPtsId++,x);
532             
533             // fourth point of polygon (quadrangle)
534             x[0] = i*delta+delta-shrink; 
535             x[1] = itemH;
536             distPtsIds[2] = distPtsId;
537             distrPts->SetPoint(distPtsId++,x);
538             
539             // Add polygon into poly data
540             distrPolys->InsertNextCell(4,distPtsIds);
541           }
542         } 
543       }
544       // rnv end
545     }
546     
547     //polygons & cell colors
548     unsigned char *rgba, *rgb;
549     vtkIdType ptIds[4], dcCount=0;
550     for (i=0; i<numColors; i++)
551       {
552       ptIds[0] = 2*i;
553       ptIds[1] = ptIds[0] + 1;
554       ptIds[2] = ptIds[1] + 2;
555       ptIds[3] = ptIds[0] + 2;
556       polys->InsertNextCell(4,ptIds);
557
558       if ( isLogTable )
559         {
560         double rgbval = log10(range[0]) + 
561           i*(log10(range[1])-log10(range[0]))/(numColors -1);
562         rgba = lut->MapValue(pow(10.0,rgbval));
563         }
564       else
565         {
566         rgba = lut->MapValue(range[0] + (range[1] - range[0])*
567                              ((double)i /(numColors-1.0)));
568         }
569
570       rgb = colors->GetPointer(3*i); //write into array directly
571       rgb[0] = rgba[0];
572       rgb[1] = rgba[1];
573       rgb[2] = rgba[2];
574       
575       // rnv begin
576       // Customization of the vtkScalarBarActor to show distribution histogram.
577       if(myNbValues[i] && myDistributionColoringType == SMESH_MULTICOLOR_TYPE && GetDistributionVisibility() && distrVisibility)
578         {
579           rgb = distColors->GetPointer(3*dcCount); //write into array directly
580           rgb[0] = rgba[0];
581           rgb[1] = rgba[1];
582           rgb[2] = rgba[2];
583           dcCount++;
584         }
585       }
586
587     // Now position everything properly
588     //
589     double val;
590     if (this->Orientation == VTK_ORIENT_VERTICAL)
591       {
592       int sizeTextData[2];
593       
594       // center the title
595       this->TitleActor->SetPosition(size[0]/2, 0.9*size[1]);
596       
597       for (i=0; i < this->NumberOfLabels; i++)
598         {
599         if (this->NumberOfLabels > 1)
600           {
601           val = (double)i/(this->NumberOfLabels-1) *barHeight;
602           }
603         else 
604           {
605           val = 0.5*barHeight;
606           }
607         this->TextMappers[i]->GetSize(viewport,sizeTextData);
608         this->TextMappers[i]->GetTextProperty()->SetJustificationToLeft();
609         this->TextActors[i]->SetPosition(barWidth+3,
610                                          val - sizeTextData[1]/2);
611         }
612       }
613     else
614       {
615       this->TitleActor->SetPosition(size[0]/2, 
616                                     barHeight + labelSize[1] + 0.1*size[1]);
617       for (i=0; i < this->NumberOfLabels; i++)
618         {
619         this->TextMappers[i]->GetTextProperty()->SetJustificationToCentered();
620         if (this->NumberOfLabels > 1)
621           {
622           val = (double)i/(this->NumberOfLabels-1) * barWidth;
623           }
624         else
625           {
626           val = 0.5*barWidth;
627           }
628         this->TextActors[i]->SetPosition(val, barHeight + 0.05*size[1]);
629         }
630       }
631
632     this->BuildTime.Modified();
633     }
634
635   // Everything is built, just have to render
636   if (this->Title != NULL)
637     {
638     renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport);
639     }
640   this->ScalarBarActor->RenderOpaqueGeometry(viewport);
641   this->myDistributionActor->RenderOpaqueGeometry(viewport);
642   for (i=0; i<this->NumberOfLabels; i++)
643     {
644     renderedSomething += this->TextActors[i]->RenderOpaqueGeometry(viewport);
645     }
646
647   renderedSomething = (renderedSomething > 0)?(1):(0);
648
649   return renderedSomething;
650 }
651
652 //----------------------------------------------------------------------------
653 void SMESH_ScalarBarActor::PrintSelf(ostream& os, vtkIndent indent)
654 {
655   this->Superclass::PrintSelf(os,indent);
656
657   if ( this->LookupTable )
658     {
659     os << indent << "Lookup Table:\n";
660     this->LookupTable->PrintSelf(os,indent.GetNextIndent());
661     }
662   else
663     {
664     os << indent << "Lookup Table: (none)\n";
665     }
666
667   if (this->TitleTextProperty)
668     {
669     os << indent << "Title Text Property:\n";
670     this->TitleTextProperty->PrintSelf(os,indent.GetNextIndent());
671     }
672   else
673     {
674     os << indent << "Title Text Property: (none)\n";
675     }
676
677   if (this->LabelTextProperty)
678     {
679     os << indent << "Label Text Property:\n";
680     this->LabelTextProperty->PrintSelf(os,indent.GetNextIndent());
681     }
682   else
683     {
684     os << indent << "Label Text Property: (none)\n";
685     }
686
687   os << indent << "Title: " << (this->Title ? this->Title : "(none)") << "\n";
688   os << indent << "Maximum Number Of Colors: " 
689      << this->MaximumNumberOfColors << "\n";
690   os << indent << "Number Of Labels: " << this->NumberOfLabels << "\n";
691   os << indent << "Number Of Labels Built: " << this->NumberOfLabelsBuilt << "\n";
692
693   os << indent << "Orientation: ";
694   if ( this->Orientation == VTK_ORIENT_HORIZONTAL )
695     {
696     os << "Horizontal\n";
697     }
698   else
699     {
700     os << "Vertical\n";
701     }
702
703   os << indent << "Label Format: " << this->LabelFormat << "\n";
704 }
705
706 //----------------------------------------------------------------------------
707 void SMESH_ScalarBarActor::ShallowCopy(vtkProp *prop)
708 {
709   SMESH_ScalarBarActor *a = SMESH_ScalarBarActor::SafeDownCast(prop);
710   if ( a != NULL )
711     {
712     this->SetPosition2(a->GetPosition2());
713     this->SetLookupTable(a->GetLookupTable());
714     this->SetMaximumNumberOfColors(a->GetMaximumNumberOfColors());
715     this->SetOrientation(a->GetOrientation());
716     this->SetLabelTextProperty(a->GetLabelTextProperty());
717     this->SetTitleTextProperty(a->GetTitleTextProperty());
718     this->SetLabelFormat(a->GetLabelFormat());
719     this->SetTitle(a->GetTitle());
720     this->GetPositionCoordinate()->SetCoordinateSystem(
721       a->GetPositionCoordinate()->GetCoordinateSystem());    
722     this->GetPositionCoordinate()->SetValue(
723       a->GetPositionCoordinate()->GetValue());
724     this->GetPosition2Coordinate()->SetCoordinateSystem(
725       a->GetPosition2Coordinate()->GetCoordinateSystem());    
726     this->GetPosition2Coordinate()->SetValue(
727       a->GetPosition2Coordinate()->GetValue());
728     }
729
730   // Now do superclass
731   this->vtkActor2D::ShallowCopy(prop);
732 }
733
734 //----------------------------------------------------------------------------
735 void SMESH_ScalarBarActor::AllocateAndSizeLabels(int *labelSize, 
736                                               int *size,
737                                               vtkViewport *viewport,
738                                               double *range)
739 {
740   labelSize[0] = labelSize[1] = 0;
741
742   this->TextMappers = new vtkTextMapper * [this->NumberOfLabels];
743   this->TextActors = new vtkActor2D * [this->NumberOfLabels];
744
745   char string[512];
746
747   double val;
748   int i;
749   
750   // TODO: this should be optimized, maybe by keeping a list of
751   // allocated mappers, in order to avoid creation/destruction of
752   // their underlying text properties (i.e. each time a mapper is
753   // created, text properties are created and shallow-assigned a font size
754   // which value might be "far" from the target font size).
755
756   // is this a vtkLookupTable or a subclass of vtkLookupTable 
757   // with its scale set to log
758   vtkLookupTable *LUT = vtkLookupTable::SafeDownCast( this->LookupTable );
759   int isLogTable = 0;
760   if ( LUT )
761     {
762     if ( LUT->GetScale() == VTK_SCALE_LOG10 )
763       {
764       isLogTable = 1; 
765       }
766     }
767
768   for (i=0; i < this->NumberOfLabels; i++)
769     {
770     this->TextMappers[i] = vtkTextMapper::New();
771
772     if ( isLogTable )
773       {
774       double lval;
775       if (this->NumberOfLabels > 1)
776         {
777         lval = log10(range[0]) + (double)i/(this->NumberOfLabels-1) *
778           (log10(range[1])-log10(range[0]));
779         }
780       else
781         {
782         lval = log10(range[0]) + 0.5*(log10(range[1])-log10(range[0]));
783         }
784       val = pow(10.0,lval);
785       }
786     else
787       {
788       if (this->NumberOfLabels > 1)
789         {
790         val = range[0] + 
791           (double)i/(this->NumberOfLabels-1) * (range[1]-range[0]);
792         }
793       else
794         {
795         val = range[0] + 0.5*(range[1]-range[0]);
796         }
797       }
798
799     sprintf(string, this->LabelFormat, val);
800     this->TextMappers[i]->SetInput(string);
801
802     // Shallow copy here so that the size of the label prop is not affected
803     // by the automatic adjustment of its text mapper's size (i.e. its
804     // mapper's text property is identical except for the font size
805     // which will be modified later). This allows text actors to
806     // share the same text property, and in that case specifically allows
807     // the title and label text prop to be the same.
808     this->TextMappers[i]->GetTextProperty()->ShallowCopy(
809       this->LabelTextProperty);
810
811     this->TextActors[i] = vtkActor2D::New();
812     this->TextActors[i]->SetMapper(this->TextMappers[i]);
813     this->TextActors[i]->SetProperty(this->GetProperty());
814     this->TextActors[i]->GetPositionCoordinate()->
815       SetReferenceCoordinate(this->PositionCoordinate);
816     }
817
818   if (this->NumberOfLabels)
819     {
820     int targetWidth, targetHeight;
821     // rnv begin
822     // Customization of the vtkScalarBarActor to show distribution histogram.
823     bool distrVisibility = this->MaximumNumberOfColors == this->myNbValues.size();
824     double coef;
825     if( GetDistributionVisibility() && distrVisibility )
826       if(this->Orientation == VTK_ORIENT_VERTICAL)
827         coef = 0.4;
828       else 
829         coef = 0.18;
830     else 
831       if(this->Orientation == VTK_ORIENT_VERTICAL)
832         coef = 0.6;
833       else 
834         coef=0.25;
835
836
837     if ( this->Orientation == VTK_ORIENT_VERTICAL )
838       {
839       targetWidth = (int)(coef*size[0]);
840       targetHeight = (int)(0.86*size[1]/this->NumberOfLabels);
841       }
842     else
843       {
844       targetWidth = (int)(size[0]*0.8/this->NumberOfLabels);
845       targetHeight = (int)(coef*size[1]);
846       }
847     // rnv end
848     
849     vtkTextMapper::SetMultipleConstrainedFontSize(viewport, 
850                                                   targetWidth, 
851                                                   targetHeight,
852                                                   this->TextMappers,
853                                                   this->NumberOfLabels,
854                                                   labelSize);
855     }
856 }
857
858 //----------------------------------------------------------------------------
859 void SMESH_ScalarBarActor::SizeTitle(int *titleSize, 
860                                   int *size, 
861                                   vtkViewport *viewport)
862 {
863   titleSize[0] = titleSize[1] = 0;
864
865   if (this->Title == NULL || !strlen(this->Title))
866     {
867     return;
868     }
869
870   int targetWidth, targetHeight;
871   
872   targetWidth = size[0];
873   // rnv begin
874   // Customization of the vtkScalarBarActor to show distribution histogram.
875   bool distrVisibility =  this->MaximumNumberOfColors == this->myNbValues.size();
876   double coef;
877   if( GetDistributionVisibility() && distrVisibility ) 
878     coef=0.18;
879   else 
880     coef=0.25;
881
882   if ( this->Orientation == VTK_ORIENT_VERTICAL )
883     {
884       targetHeight = (int)(0.1*size[1]);
885     }
886   else
887     {
888       targetHeight = (int)(coef*size[1]);
889     }
890
891   this->TitleMapper->SetConstrainedFontSize(
892     viewport, targetWidth, targetHeight);
893
894   this->TitleMapper->GetSize(viewport, titleSize);
895 }
896
897
898 /*--------------------------------------------------------------------------*/
899 void SMESH_ScalarBarActor::SetDistributionVisibility(int flag) {
900   myDistributionActor->SetVisibility(flag);
901   Modified();
902 }
903
904
905 /*--------------------------------------------------------------------------*/
906 int SMESH_ScalarBarActor::GetDistributionVisibility() {
907   return myDistributionActor->GetVisibility();
908 }
909
910
911 void SMESH_ScalarBarActor::SetDistribution(std::vector<int> theNbValues) {
912   myNbValues = theNbValues;
913
914
915
916 void SMESH_ScalarBarActor::SetDistributionColor (double rgb[3]) {
917   myDistributionActor->GetProperty()->SetColor(rgb);
918   Modified();
919 }
920
921 void SMESH_ScalarBarActor::GetDistributionColor (double rgb[3]) {
922   myDistributionActor->GetProperty()->GetColor(rgb);
923 }