src/OBJECT/SMESH_ScalarBarActor.cxx

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