src/OBJECT/SMESH_ScalarBarActor.cxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//  File   : SMESH_ScalarBarActor.cxx
//  Author : Roman NIKOLAEV
//  Module : SMESH
//

#include "SMESH_ScalarBarActor.h"

#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkObjectFactory.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkScalarsToColors.h>
#include <vtkTextMapper.h>
#include <vtkTextProperty.h>
#include <vtkViewport.h>
#include <vtkWindow.h>
#include <vtkLookupTable.h>
#include <vtkProperty2D.h>

#define SHRINK_COEF 0.08;

vtkStandardNewMacro(SMESH_ScalarBarActor);

vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty);

//----------------------------------------------------------------------------
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
// format, no title, and vertical orientation. The initial scalar bar
// size is (0.05 x 0.8) of the viewport size.
SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
  this->LookupTable = NULL;
  this->Position2Coordinate->SetValue(0.17, 0.8);
  
  this->PositionCoordinate->SetCoordinateSystemToNormalizedViewport();
  this->PositionCoordinate->SetValue(0.82,0.1);
  
  this->MaximumNumberOfColors = 64;
  this->NumberOfLabels = 5;
  this->NumberOfLabelsBuilt = 0;
  this->Orientation = VTK_ORIENT_VERTICAL;
  this->Title = NULL;

  this->LabelTextProperty = vtkTextProperty::New();
  this->LabelTextProperty->SetFontSize(12);
  this->LabelTextProperty->SetBold(1);
  this->LabelTextProperty->SetItalic(1);
  this->LabelTextProperty->SetShadow(1);
  this->LabelTextProperty->SetFontFamilyToArial();

  this->TitleTextProperty = vtkTextProperty::New();
  this->TitleTextProperty->ShallowCopy(this->LabelTextProperty);

  this->LabelFormat = new char[8]; 
  sprintf(this->LabelFormat,"%s","%-#6.3g");

  this->TitleMapper = vtkTextMapper::New();
  this->TitleActor = vtkActor2D::New();
  this->TitleActor->SetMapper(this->TitleMapper);
  this->TitleActor->GetPositionCoordinate()->
    SetReferenceCoordinate(this->PositionCoordinate);
  
  this->TextMappers = NULL;
  this->TextActors = NULL;

  this->ScalarBar = vtkPolyData::New();
  this->ScalarBarMapper = vtkPolyDataMapper2D::New();
  this->ScalarBarMapper->SetInput(this->ScalarBar);
  this->ScalarBarActor = vtkActor2D::New();
  this->ScalarBarActor->SetMapper(this->ScalarBarMapper);
  this->ScalarBarActor->GetPositionCoordinate()->
    SetReferenceCoordinate(this->PositionCoordinate);
  this->LastOrigin[0] = 0;
  this->LastOrigin[1] = 0;
  this->LastSize[0] = 0;
  this->LastSize[1] = 0;


  // rnv begin
  // Customization of the vtkScalarBarActor to show distribution histogram.
  myDistribution = vtkPolyData::New();
  myDistributionMapper = vtkPolyDataMapper2D::New();
  myDistributionMapper->SetInput(this->myDistribution);
  
  myDistributionActor = vtkActor2D::New();
  myDistributionActor->SetMapper(this->myDistributionMapper);
  myDistributionActor->GetPositionCoordinate()->
    SetReferenceCoordinate(this->PositionCoordinate);

  // By default distribution histogram is invisible
  myDistributionActor->SetVisibility(0);

  // By default monocolor
  myDistributionColoringType = SMESH_MONOCOLOR_TYPE;
  // rnv end
}

//----------------------------------------------------------------------------
// Release any graphics resources that are being consumed by this actor.
// The parameter window could be used to determine which graphic
// resources to release.
void SMESH_ScalarBarActor::ReleaseGraphicsResources(vtkWindow *win)
{
  this->TitleActor->ReleaseGraphicsResources(win);
  if (this->TextMappers != NULL )
    {
    for (int i=0; i < this->NumberOfLabelsBuilt; i++)
      {
      this->TextActors[i]->ReleaseGraphicsResources(win);
      }
    }
  this->ScalarBarActor->ReleaseGraphicsResources(win);
  // rnv begin
  // Customization of the vtkScalarBarActor to show distribution histogram.
  myDistributionActor->ReleaseGraphicsResources(win);
}


/*--------------------------------------------------------------------------*/
SMESH_ScalarBarActor::~SMESH_ScalarBarActor() {
  if (this->LabelFormat) 
    {
    delete [] this->LabelFormat;
    this->LabelFormat = NULL;
    }

  this->TitleMapper->Delete();
  this->TitleActor->Delete();

  if (this->TextMappers != NULL )
    {
    for (int i=0; i < this->NumberOfLabelsBuilt; i++)
      {
      this->TextMappers[i]->Delete();
      this->TextActors[i]->Delete();
      }
    delete [] this->TextMappers;
    delete [] this->TextActors;
    }

  this->ScalarBar->Delete();
  this->ScalarBarMapper->Delete();
  this->ScalarBarActor->Delete();

  if (this->Title)
    {
    delete [] this->Title;
    this->Title = NULL;
    }
  
  this->SetLookupTable(NULL);
  this->SetLabelTextProperty(NULL);
  this->SetTitleTextProperty(NULL);
  
  // rnv begin
  // Customization of the vtkScalarBarActor to show distribution histogram:
  myDistribution->Delete();
  myDistributionMapper->Delete();
  myDistributionActor->Delete();
  // rnv end
}

//----------------------------------------------------------------------------
int SMESH_ScalarBarActor::RenderOverlay(vtkViewport *viewport)
{
  int renderedSomething = 0;
  int i;
  
  // Everything is built, just have to render
  if (this->Title != NULL)
    {
    renderedSomething += this->TitleActor->RenderOverlay(viewport);
    }
  this->ScalarBarActor->RenderOverlay(viewport);
  this->myDistributionActor->RenderOverlay(viewport);
  if( this->TextActors == NULL)
    {
     vtkWarningMacro(<<"Need a mapper to render a scalar bar");
     return renderedSomething;
    }
  
  for (i=0; i<this->NumberOfLabels; i++)
    {
    renderedSomething += this->TextActors[i]->RenderOverlay(viewport);
    }

  renderedSomething = (renderedSomething > 0)?(1):(0);

  return renderedSomething;
}


//----------------------------------------------------------------------------
int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
{
  int renderedSomething = 0;
  int i;
  int size[2];
  
  if (!this->LookupTable)
    {
    vtkWarningMacro(<<"Need a mapper to render a scalar bar");
    return 0;
    }

  if (!this->TitleTextProperty)
    {
    vtkErrorMacro(<<"Need title text property to render a scalar bar");
    return 0;
    }

  if (!this->LabelTextProperty)
    {
    vtkErrorMacro(<<"Need label text property to render a scalar bar");
    return 0;
    }

  // Check to see whether we have to rebuild everything
  int positionsHaveChanged = 0;
  if (viewport->GetMTime() > this->BuildTime || 
      (viewport->GetVTKWindow() && 
       viewport->GetVTKWindow()->GetMTime() > this->BuildTime))
    {
    // if the viewport has changed we may - or may not need
    // to rebuild, it depends on if the projected coords chage
    int *barOrigin;
    barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport);
    size[0] = 
      this->Position2Coordinate->GetComputedViewportValue(viewport)[0] -
      barOrigin[0];
    size[1] = 
      this->Position2Coordinate->GetComputedViewportValue(viewport)[1] -
      barOrigin[1];
    if (this->LastSize[0] != size[0] || 
        this->LastSize[1] != size[1] ||
        this->LastOrigin[0] != barOrigin[0] || 
        this->LastOrigin[1] != barOrigin[1])
      {
      positionsHaveChanged = 1;
      }
    }
  
  // Check to see whether we have to rebuild everything
  if (positionsHaveChanged ||
      this->GetMTime() > this->BuildTime || 
      this->LookupTable->GetMTime() > this->BuildTime ||
      this->LabelTextProperty->GetMTime() > this->BuildTime ||
      this->TitleTextProperty->GetMTime() > this->BuildTime)
    {
    vtkDebugMacro(<<"Rebuilding subobjects");

    // Delete previously constructed objects
    //
    if (this->TextMappers != NULL )
      {
      for (i=0; i < this->NumberOfLabelsBuilt; i++)
        {
        this->TextMappers[i]->Delete();
        this->TextActors[i]->Delete();
        }
      delete [] this->TextMappers;
      delete [] this->TextActors;
      }

    // Build scalar bar object; determine its type
    //
    // is this a vtkLookupTable or a subclass of vtkLookupTable 
    // with its scale set to log
    // NOTE: it's possible we could to without the 'lut' variable
    // later in the code, but if the vtkLookupTableSafeDownCast operation
    // fails for some reason, this code will break in new ways. So, the 'LUT'
    // variable is used for this operation only
    vtkLookupTable *LUT = vtkLookupTable::SafeDownCast( this->LookupTable );
    int isLogTable = 0;
    if ( LUT )
      {
      if ( LUT->GetScale() == VTK_SCALE_LOG10 )
        {
        isLogTable = 1; 
        }
      }
    
    // we hard code how many steps to display
    vtkScalarsToColors *lut = this->LookupTable;
    int numColors = this->MaximumNumberOfColors;
    double *range = lut->GetRange();

    int numPts = 2*(numColors + 1);
    vtkPoints *pts = vtkPoints::New();
    pts->SetNumberOfPoints(numPts);
    vtkCellArray *polys = vtkCellArray::New();
    polys->Allocate(polys->EstimateSize(numColors,4));
    vtkUnsignedCharArray *colors = vtkUnsignedCharArray::New();
    colors->SetNumberOfComponents(3);
    colors->SetNumberOfTuples(numColors);


    // rnv begin
    // Customization of the vtkScalarBarActor to show distribution histogram.
    bool distrVisibility =  (numColors == this->myNbValues.size());
    vtkPoints *distrPts;
    vtkCellArray *distrPolys;
    vtkUnsignedCharArray *distColors = 0;
    int numDistrPts = 0, numPositiveVal=0, maxValue=0;
    if(!distrVisibility)
      vtkDebugMacro(<<" Distribution invisible, because numColors == this->myNbValues.size()");

    if (distrVisibility && GetDistributionVisibility()) {
      for( i=0 ;i<myNbValues.size();i++ ) {
        if(myNbValues[i]) {
          numPositiveVal++;
          maxValue = std::max(maxValue,myNbValues[i]);
        } 
      }
      numDistrPts = 4*(numPositiveVal);
      distrPts = vtkPoints::New();
      distrPolys = vtkCellArray::New();
      distrPts->SetNumberOfPoints(numDistrPts);
      distrPolys->Allocate(distrPolys->EstimateSize(numPositiveVal,4));
      this->myDistribution->Initialize();
      this->myDistribution->SetPoints(distrPts);
      this->myDistribution->SetPolys(distrPolys);
      distrPts->Delete();
      distrPolys->Delete();
      if ( myDistributionColoringType == SMESH_MULTICOLOR_TYPE ) {
        distColors = vtkUnsignedCharArray::New();
        distColors->SetNumberOfComponents(3);
        distColors->SetNumberOfTuples(numPositiveVal);
        this->myDistribution->GetCellData()->SetScalars(distColors);
        distColors->Delete();
      } else if( myDistributionColoringType == SMESH_MONOCOLOR_TYPE ){
        this->myDistribution->GetCellData()->SetScalars(NULL);
      }
    } else {
      myDistribution->Reset();
    }
    // rnv end

    this->ScalarBarActor->SetProperty(this->GetProperty());
    this->ScalarBar->Initialize();
    this->ScalarBar->SetPoints(pts);
    this->ScalarBar->SetPolys(polys);
    this->ScalarBar->GetCellData()->SetScalars(colors);
    pts->Delete(); polys->Delete(); colors->Delete();

    // get the viewport size in display coordinates
    int *barOrigin, barWidth, barHeight, distrHeight;
    barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport);
    size[0] = 
      this->Position2Coordinate->GetComputedViewportValue(viewport)[0] -
      barOrigin[0];
    size[1] = 
      this->Position2Coordinate->GetComputedViewportValue(viewport)[1] -
      barOrigin[1];
    this->LastOrigin[0] = barOrigin[0];
    this->LastOrigin[1] = barOrigin[1];
    this->LastSize[0] = size[0];
    this->LastSize[1] = size[1];
    
    // Update all the composing objects
    this->TitleActor->SetProperty(this->GetProperty());
    this->TitleMapper->SetInput(this->Title);
    if (this->TitleTextProperty->GetMTime() > this->BuildTime)
      {
      // Shallow copy here so that the size of the title prop is not affected
      // by the automatic adjustment of its text mapper's size (i.e. its
      // mapper's text property is identical except for the font size
      // which will be modified later). This allows text actors to
      // share the same text property, and in that case specifically allows
      // the title and label text prop to be the same.
      this->TitleMapper->GetTextProperty()->ShallowCopy(this->TitleTextProperty);
      this->TitleMapper->GetTextProperty()->SetJustificationToCentered();
      }
    
    // find the best size for the title font
    int titleSize[2];
    this->SizeTitle(titleSize, size, viewport);
    
    // find the best size for the ticks
    int labelSize[2];
    this->AllocateAndSizeLabels(labelSize, size, viewport,range);
    this->NumberOfLabelsBuilt = this->NumberOfLabels;
    
    // generate points
    double x[3]; x[2] = 0.0;
    double delta, itemH, shrink;
    if ( this->Orientation == VTK_ORIENT_VERTICAL ) {
      // rnv begin
      // Customization of the vtkScalarBarActor to show distribution histogram.
      double delimeter=0.0;
      if(GetDistributionVisibility() && distrVisibility) {
        delimeter=0.01*size[0]; //1 % from horizontal size of the full presentation size.
        barWidth = size[0] - 4 - labelSize[0];
        distrHeight = barWidth/2;
      } else {
        barWidth = size[0] - 4 - labelSize[0];
        distrHeight = 0;
      }

      barHeight = (int)(0.86*size[1]);
      delta=(double)barHeight/numColors;
      
      for ( i=0; i<numPts/2; i++ ) {
        x[0] = distrHeight+delimeter/2.0;
        x[1] = i*delta;
        pts->SetPoint(2*i,x);
        x[0] = barWidth;
        pts->SetPoint(2*i+1,x);
      }

      if(GetDistributionVisibility() && distrVisibility) {
        // Distribution points 
        shrink = delta*SHRINK_COEF;
        vtkIdType distPtsId=0;
        vtkIdType distPtsIds[4];
        for(i=0; i<numColors; i++) {
          if(myNbValues[i]) {
            itemH = distrHeight*((double)myNbValues[i]/maxValue);
            
            if(distrHeight == itemH) 
              itemH = itemH - delimeter/2;

            x[1] = i*delta+shrink;

            // first point of polygon (quadrangle)
            x[0] = 0; 
            distPtsIds[0] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);

            // second point of polygon (quadrangle)
            x[0] = itemH;
            distPtsIds[1] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);

            x[1] = i*delta+delta-shrink;

            // third point of polygon (quadrangle)
            x[0] = 0; 
            distPtsIds[3] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);

            // fourth point of polygon (quadrangle)
            x[0] = itemH;
            distPtsIds[2] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);

            //Inser Quadrangle
            distrPolys->InsertNextCell(4,distPtsIds);
          }
        }
      }    
    }
    // rnv end
    else {
      barWidth = size[0];
      
      // rnv begin
      // Customization of the vtkScalarBarActor to show distribution histogram.
      double coef1, delimeter=0.0;
      if(GetDistributionVisibility() && distrVisibility) {
        coef1=0.62;
        distrHeight = (int)((coef1/2)*size[1]);
        //delimeter between distribution diagram and scalar bar 
        delimeter=0.02*size[1];
      }
      else {
        coef1=0.4;
        barHeight = (int)(coef1*size[1]);
        distrHeight = 0;
      }
      
      barHeight = (int)(coef1*size[1]);
      
      delta=(double)barWidth/numColors;
      for (i=0; i<numPts/2; i++) {
        x[0] = i*delta;
        x[1] = barHeight;
        pts->SetPoint(2*i,x);                        
        x[1] = distrHeight + delimeter;
        pts->SetPoint(2*i+1,x);
      }
      
      if(GetDistributionVisibility() && distrVisibility) {
        // Distribution points 
        shrink = delta*SHRINK_COEF;
        vtkIdType distPtsId=0;
        vtkIdType distPtsIds[4];
        for(i=0; i<numColors; i++) {
          if(myNbValues[i]) {
            itemH = distrHeight*((double)myNbValues[i]/maxValue);
            
            // first point of polygon (quadrangle)
            x[0] = i*delta+shrink; 
            x[1] = 0;
            distPtsIds[0] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);
            
            // second point of polygon (quadrangle)
            x[0] = i*delta+shrink; 
            x[1] = itemH;
            distPtsIds[3] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);
            
            // third point of polygon (quadrangle)
            x[0] = i*delta+delta-shrink; 
            x[1] = 0;
            distPtsIds[1] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);
            
            // fourth point of polygon (quadrangle)
            x[0] = i*delta+delta-shrink; 
            x[1] = itemH;
            distPtsIds[2] = distPtsId;
            distrPts->SetPoint(distPtsId++,x);
            
            // Add polygon into poly data
            distrPolys->InsertNextCell(4,distPtsIds);
          }
        } 
      }
      // rnv end
    }
    
    //polygons & cell colors
    unsigned char *rgba, *rgb;
    vtkIdType ptIds[4], dcCount=0;
    for (i=0; i<numColors; i++)
      {
      ptIds[0] = 2*i;
      ptIds[1] = ptIds[0] + 1;
      ptIds[2] = ptIds[1] + 2;
      ptIds[3] = ptIds[0] + 2;
      polys->InsertNextCell(4,ptIds);

      if ( isLogTable )
        {
        double rgbval = log10(range[0]) + 
          i*(log10(range[1])-log10(range[0]))/(numColors -1);
        rgba = lut->MapValue(pow(10.0,rgbval));
        }
      else
        {
        rgba = lut->MapValue(range[0] + (range[1] - range[0])*
                             ((double)i /(numColors-1.0)));
        }

      rgb = colors->GetPointer(3*i); //write into array directly
      rgb[0] = rgba[0];
      rgb[1] = rgba[1];
      rgb[2] = rgba[2];
      
      // rnv begin
      // Customization of the vtkScalarBarActor to show distribution histogram.
      if(myNbValues[i] && myDistributionColoringType == SMESH_MULTICOLOR_TYPE && GetDistributionVisibility() && distrVisibility)
        {
          rgb = distColors->GetPointer(3*dcCount); //write into array directly
          rgb[0] = rgba[0];
          rgb[1] = rgba[1];
          rgb[2] = rgba[2];
          dcCount++;
        }
      }

    // Now position everything properly
    //
    double val;
    if (this->Orientation == VTK_ORIENT_VERTICAL)
      {
      int sizeTextData[2];
      
      // center the title
      this->TitleActor->SetPosition(size[0]/2, 0.9*size[1]);
      
      for (i=0; i < this->NumberOfLabels; i++)
        {
        if (this->NumberOfLabels > 1)
          {
          val = (double)i/(this->NumberOfLabels-1) *barHeight;
          }
        else 
          {
          val = 0.5*barHeight;
          }
        this->TextMappers[i]->GetSize(viewport,sizeTextData);
        this->TextMappers[i]->GetTextProperty()->SetJustificationToLeft();
        this->TextActors[i]->SetPosition(barWidth+3,
                                         val - sizeTextData[1]/2);
        }
      }
    else
      {
      this->TitleActor->SetPosition(size[0]/2, 
                                    barHeight + labelSize[1] + 0.1*size[1]);
      for (i=0; i < this->NumberOfLabels; i++)
        {
        this->TextMappers[i]->GetTextProperty()->SetJustificationToCentered();
        if (this->NumberOfLabels > 1)
          {
          val = (double)i/(this->NumberOfLabels-1) * barWidth;
          }
        else
          {
          val = 0.5*barWidth;
          }
        this->TextActors[i]->SetPosition(val, barHeight + 0.05*size[1]);
        }
      }

    this->BuildTime.Modified();
    }

  // Everything is built, just have to render
  if (this->Title != NULL)
    {
    renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport);
    }
  this->ScalarBarActor->RenderOpaqueGeometry(viewport);
  this->myDistributionActor->RenderOpaqueGeometry(viewport);
  for (i=0; i<this->NumberOfLabels; i++)
    {
    renderedSomething += this->TextActors[i]->RenderOpaqueGeometry(viewport);
    }

  renderedSomething = (renderedSomething > 0)?(1):(0);

  return renderedSomething;
}

//----------------------------------------------------------------------------
void SMESH_ScalarBarActor::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os,indent);

  if ( this->LookupTable )
    {
    os << indent << "Lookup Table:\n";
    this->LookupTable->PrintSelf(os,indent.GetNextIndent());
    }
  else
    {
    os << indent << "Lookup Table: (none)\n";
    }

  if (this->TitleTextProperty)
    {
    os << indent << "Title Text Property:\n";
    this->TitleTextProperty->PrintSelf(os,indent.GetNextIndent());
    }
  else
    {
    os << indent << "Title Text Property: (none)\n";
    }

  if (this->LabelTextProperty)
    {
    os << indent << "Label Text Property:\n";
    this->LabelTextProperty->PrintSelf(os,indent.GetNextIndent());
    }
  else
    {
    os << indent << "Label Text Property: (none)\n";
    }

  os << indent << "Title: " << (this->Title ? this->Title : "(none)") << "\n";
  os << indent << "Maximum Number Of Colors: " 
     << this->MaximumNumberOfColors << "\n";
  os << indent << "Number Of Labels: " << this->NumberOfLabels << "\n";
  os << indent << "Number Of Labels Built: " << this->NumberOfLabelsBuilt << "\n";

  os << indent << "Orientation: ";
  if ( this->Orientation == VTK_ORIENT_HORIZONTAL )
    {
    os << "Horizontal\n";
    }
  else
    {
    os << "Vertical\n";
    }

  os << indent << "Label Format: " << this->LabelFormat << "\n";
}

//----------------------------------------------------------------------------
void SMESH_ScalarBarActor::ShallowCopy(vtkProp *prop)
{
  SMESH_ScalarBarActor *a = SMESH_ScalarBarActor::SafeDownCast(prop);
  if ( a != NULL )
    {
    this->SetPosition2(a->GetPosition2());
    this->SetLookupTable(a->GetLookupTable());
    this->SetMaximumNumberOfColors(a->GetMaximumNumberOfColors());
    this->SetOrientation(a->GetOrientation());
    this->SetLabelTextProperty(a->GetLabelTextProperty());
    this->SetTitleTextProperty(a->GetTitleTextProperty());
    this->SetLabelFormat(a->GetLabelFormat());
    this->SetTitle(a->GetTitle());
    this->GetPositionCoordinate()->SetCoordinateSystem(
      a->GetPositionCoordinate()->GetCoordinateSystem());    
    this->GetPositionCoordinate()->SetValue(
      a->GetPositionCoordinate()->GetValue());
    this->GetPosition2Coordinate()->SetCoordinateSystem(
      a->GetPosition2Coordinate()->GetCoordinateSystem());    
    this->GetPosition2Coordinate()->SetValue(
      a->GetPosition2Coordinate()->GetValue());
    }

  // Now do superclass
  this->vtkActor2D::ShallowCopy(prop);
}

//----------------------------------------------------------------------------
void SMESH_ScalarBarActor::AllocateAndSizeLabels(int *labelSize, 
                                              int *size,
                                              vtkViewport *viewport,
                                              double *range)
{
  labelSize[0] = labelSize[1] = 0;

  this->TextMappers = new vtkTextMapper * [this->NumberOfLabels];
  this->TextActors = new vtkActor2D * [this->NumberOfLabels];

  char string[512];

  double val;
  int i;
  
  // TODO: this should be optimized, maybe by keeping a list of
  // allocated mappers, in order to avoid creation/destruction of
  // their underlying text properties (i.e. each time a mapper is
  // created, text properties are created and shallow-assigned a font size
  // which value might be "far" from the target font size).

  // is this a vtkLookupTable or a subclass of vtkLookupTable 
  // with its scale set to log
  vtkLookupTable *LUT = vtkLookupTable::SafeDownCast( this->LookupTable );
  int isLogTable = 0;
  if ( LUT )
    {
    if ( LUT->GetScale() == VTK_SCALE_LOG10 )
      {
      isLogTable = 1; 
      }
    }

  for (i=0; i < this->NumberOfLabels; i++)
    {
    this->TextMappers[i] = vtkTextMapper::New();

    if ( isLogTable )
      {
      double lval;
      if (this->NumberOfLabels > 1)
        {
        lval = log10(range[0]) + (double)i/(this->NumberOfLabels-1) *
          (log10(range[1])-log10(range[0]));
        }
      else
        {
        lval = log10(range[0]) + 0.5*(log10(range[1])-log10(range[0]));
        }
      val = pow(10.0,lval);
      }
    else
      {
      if (this->NumberOfLabels > 1)
        {
        val = range[0] + 
          (double)i/(this->NumberOfLabels-1) * (range[1]-range[0]);
        }
      else
        {
        val = range[0] + 0.5*(range[1]-range[0]);
        }
      }

    sprintf(string, this->LabelFormat, val);
    this->TextMappers[i]->SetInput(string);

    // Shallow copy here so that the size of the label prop is not affected
    // by the automatic adjustment of its text mapper's size (i.e. its
    // mapper's text property is identical except for the font size
    // which will be modified later). This allows text actors to
    // share the same text property, and in that case specifically allows
    // the title and label text prop to be the same.
    this->TextMappers[i]->GetTextProperty()->ShallowCopy(
      this->LabelTextProperty);

    this->TextActors[i] = vtkActor2D::New();
    this->TextActors[i]->SetMapper(this->TextMappers[i]);
    this->TextActors[i]->SetProperty(this->GetProperty());
    this->TextActors[i]->GetPositionCoordinate()->
      SetReferenceCoordinate(this->PositionCoordinate);
    }

  if (this->NumberOfLabels)
    {
    int targetWidth, targetHeight;
    // rnv begin
    // Customization of the vtkScalarBarActor to show distribution histogram.
    bool distrVisibility = this->MaximumNumberOfColors == this->myNbValues.size();
    double coef;
    if( GetDistributionVisibility() && distrVisibility )
      if(this->Orientation == VTK_ORIENT_VERTICAL)
        coef = 0.4;
      else 
        coef = 0.18;
    else 
      if(this->Orientation == VTK_ORIENT_VERTICAL)
        coef = 0.6;
      else 
        coef=0.25;


    if ( this->Orientation == VTK_ORIENT_VERTICAL )
      {
      targetWidth = (int)(coef*size[0]);
      targetHeight = (int)(0.86*size[1]/this->NumberOfLabels);
      }
    else
      {
      targetWidth = (int)(size[0]*0.8/this->NumberOfLabels);
      targetHeight = (int)(coef*size[1]);
      }
    // rnv end
    
    vtkTextMapper::SetMultipleConstrainedFontSize(viewport, 
                                                  targetWidth, 
                                                  targetHeight,
                                                  this->TextMappers,
                                                  this->NumberOfLabels,
                                                  labelSize);
    }
}

//----------------------------------------------------------------------------
void SMESH_ScalarBarActor::SizeTitle(int *titleSize, 
                                  int *size, 
                                  vtkViewport *viewport)
{
  titleSize[0] = titleSize[1] = 0;

  if (this->Title == NULL || !strlen(this->Title))
    {
    return;
    }

  int targetWidth, targetHeight;
  
  targetWidth = size[0];
  // rnv begin
  // Customization of the vtkScalarBarActor to show distribution histogram.
  bool distrVisibility =  this->MaximumNumberOfColors == this->myNbValues.size();
  double coef;
  if( GetDistributionVisibility() && distrVisibility ) 
    coef=0.18;
  else 
    coef=0.25;

  if ( this->Orientation == VTK_ORIENT_VERTICAL )
    {
      targetHeight = (int)(0.1*size[1]);
    }
  else
    {
      targetHeight = (int)(coef*size[1]);
    }

  this->TitleMapper->SetConstrainedFontSize(
    viewport, targetWidth, targetHeight);

  this->TitleMapper->GetSize(viewport, titleSize);
}


/*--------------------------------------------------------------------------*/
void SMESH_ScalarBarActor::SetDistributionVisibility(int flag) {
  myDistributionActor->SetVisibility(flag);
  Modified();
}


/*--------------------------------------------------------------------------*/
int SMESH_ScalarBarActor::GetDistributionVisibility() {
  return myDistributionActor->GetVisibility();
}


void SMESH_ScalarBarActor::SetDistribution(std::vector<int> theNbValues) {
  myNbValues = theNbValues;
} 


void SMESH_ScalarBarActor::SetDistributionColor (double rgb[3]) {
  myDistributionActor->GetProperty()->SetColor(rgb);
  Modified();
}

void SMESH_ScalarBarActor::GetDistributionColor (double rgb[3]) {
  myDistributionActor->GetProperty()->GetColor(rgb);
}