<parameter name="scalar_bar_vertical_width" value="0.08" />
<parameter name="scalar_bar_vertical_x" value="0.01" />
<parameter name="scalar_bar_vertical_y" value="0.1" />
+ <parameter name="distribution_visibility" value="false" />
+ <parameter name="distribution_coloring_type" value="0" />
+ <parameter name="distribution_color" value="255, 255, 255" />
<parameter name="DisplayMode" value="true" />
<parameter name="auto_update" value="true" />
<parameter name="display_mode" value="1" />
SMESH_DeviceActor.h \
SMESH_PreviewActorsCollection.h \
SMESH_ExtractGeometry.h \
- SMESH_FaceOrientationFilter.h
+ SMESH_FaceOrientationFilter.h \
+ SMESH_ScalarBarActor.h
+
# Libraries targets
SMESH_PreviewActorsCollection.cxx \
SMESH_ExtractGeometry.cxx \
SMESH_ActorUtils.cxx \
- SMESH_FaceOrientationFilter.cxx
+ SMESH_FaceOrientationFilter.cxx \
+ SMESH_ScalarBarActor.cxx
libSMESHObject_la_CPPFLAGS = \
$(QT_INCLUDES) \
#include "SMESH_DeviceActor.h"
#include "SMESH_ObjectDef.h"
#include "SMESH_ControlsDef.hxx"
+#include "SMESH_ScalarBarActor.h"
#include "VTKViewer_CellCenters.h"
#include "VTKViewer_ExtractUnstructuredGrid.h"
#include "VTKViewer_FramedTextActor.h"
#include <vtkLabeledDataMapper.h>
#include <vtkSelectVisiblePoints.h>
-#include <vtkScalarBarActor.h>
#include <vtkLookupTable.h>
#include <vtkMath.h>
//Controls - Aspect Ratio: incorrect colors of the best and worst values
myLookupTable->SetHueRange(0.667,0.0);
- myScalarBarActor = vtkScalarBarActor::New();
+ myScalarBarActor = SMESH_ScalarBarActor::New();
myScalarBarActor->SetVisibility(false);
myScalarBarActor->SetLookupTable(myLookupTable);
if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) )
anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal );
myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal );
+
+ bool distributionVisibility = mgr->booleanValue("SMESH","distribution_visibility");
+ myScalarBarActor->SetDistributionVisibility(distributionVisibility);
+
+ int coloringType = mgr->integerValue("SMESH", "distribution_coloring_type", 0);
+ myScalarBarActor->SetDistributionColoringType(coloringType);
+
+ QColor distributionColor = mgr->colorValue("SMESH", "distribution_color",
+ QColor(255, 255, 255));
+ double rgb[3];
+ rgb[0]= distributionColor.red()/255.;
+ rgb[1]= distributionColor.green()/255.;
+ rgb[2]= distributionColor.blue()/255.;
+ myScalarBarActor->SetDistributionColor(rgb);
+
}
class vtkUnstructuredGrid;
-class vtkScalarBarActor;
+class SMESH_ScalarBarActor;
class vtkPlane;
class vtkImplicitBoolean;
virtual eControl GetControlMode() = 0;
virtual SMESH::Controls::FunctorPtr GetFunctor() = 0;
- virtual vtkScalarBarActor* GetScalarBarActor() = 0;
+ virtual SMESH_ScalarBarActor* GetScalarBarActor() = 0;
virtual void RemoveAllClippingPlanes() = 0;
virtual vtkIdType GetNumberOfClippingPlanes() = 0;
class vtkUnstructuredGrid;
class vtkMergeFilter;
class vtkPolyData;
-
class vtkMapper;
class vtkActor2D;
class vtkMaskPoints;
class vtkLabeledDataMapper;
class vtkSelectVisiblePoints;
-
-class vtkScalarBarActor;
class vtkLookupTable;
-
class vtkPlane;
class vtkImplicitBoolean;
-
class vtkTimeStamp;
class VTKViewer_CellCenters;
class SMESH_DeviceActor;
+class SMESH_ScalarBarActor;
class SMESH_ActorDef : public SMESH_Actor
virtual eControl GetControlMode(){ return myControlMode;}
virtual SMESH::Controls::FunctorPtr GetFunctor() { return myFunctor; }
- virtual vtkScalarBarActor* GetScalarBarActor(){ return myScalarBarActor;}
+ virtual SMESH_ScalarBarActor* GetScalarBarActor(){ return myScalarBarActor;}
virtual void RemoveAllClippingPlanes();
virtual vtkIdType GetNumberOfClippingPlanes();
TVisualObjPtr myVisualObj;
vtkTimeStamp* myTimeStamp;
- vtkScalarBarActor* myScalarBarActor;
+ SMESH_ScalarBarActor* myScalarBarActor;
vtkLookupTable* myLookupTable;
vtkProperty* mySurfaceProp;
// Module : SMESH
//
#include "SMESH_DeviceActor.h"
+#include "SMESH_ScalarBarActor.h"
#include "SMESH_ExtractGeometry.h"
#include "SMESH_ControlsDef.hxx"
#include "SMESH_ActorUtils.h"
#include <vtkPolyDataMapper.h>
#include <vtkUnstructuredGrid.h>
-#include <vtkScalarBarActor.h>
#include <vtkLookupTable.h>
#include <vtkDoubleArray.h>
#include <vtkCellData.h>
void
SMESH_DeviceActor
::SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
- vtkScalarBarActor* theScalarBarActor,
+ SMESH_ScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable)
{
bool anIsInitialized = theFunctor;
double aValue = aNumericalFunctor->GetValue(anObjId);
aScalars->SetValue(i,aValue);
}
+ int nbIntervals = theScalarBarActor->GetMaximumNumberOfColors();
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ aNumericalFunctor->GetHistogram(nbIntervals, nbEvents, funValues);
+ theScalarBarActor->SetDistribution(nbEvents);
+
}else if(Predicate* aPredicate = dynamic_cast<Predicate*>(theFunctor.get())){
for(vtkIdType i = 0; i < aNbCells; i++){
vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i);
void
SMESH_DeviceActor
::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor,
- vtkScalarBarActor* theScalarBarActor,
+ SMESH_ScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable)
{
bool anIsInitialized = theFunctor;
myMergeFilter->SetScalars(aDataSet);
aDataSet->Delete();
}
+
+ //Set Distribution
+ if(NumericalFunctor* aNumericalFunctor = dynamic_cast<NumericalFunctor*>(theFunctor.get())){
+ int nbIntervals = theScalarBarActor->GetMaximumNumberOfColors();
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ aNumericalFunctor->GetHistogram(nbIntervals, nbEvents, funValues);
+ theScalarBarActor->SetDistribution(nbEvents);
+ }
+
}
GetMapper()->SetScalarVisibility(anIsInitialized);
theScalarBarActor->SetVisibility(anIsInitialized);
class vtkMergeFilter;
class vtkShrinkFilter;
class vtkUnstructuredGrid;
-class vtkScalarBarActor;
class vtkLookupTable;
class vtkImplicitBoolean;
class vtkPassThroughFilter;
class SMESH_ExtractGeometry;
class SMESH_FaceOrientationFilter;
+class SMESH_ScalarBarActor;
class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
vtkUnstructuredGrid* GetUnstructuredGrid();
void SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
- vtkScalarBarActor* theScalarBarActor,
+ SMESH_ScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable);
void SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor,
- vtkScalarBarActor* theScalarBarActor,
+ SMESH_ScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable);
void SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor);
// VTK includes
#include <vtkUnstructuredGrid.h>
-#include <vtkScalarBarActor.h>
#include <vtkPlane.h>
#include <vtkRenderer.h>
#include <vtkProperty.h>
--- /dev/null
+// Copyright (C) 2007-2010 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);
+}
--- /dev/null
+// Copyright (C) 2007-2010 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
+//
+
+// SMESH SCALAR BAR : 2D Actor for the visualization scalar bar with the distribution diagram
+// it is customized vtkScalarBarActor.
+// File : SMESH_ScalarBarActor.h
+// Author : Roman NIKOLAEV
+// Module : SMESH
+
+
+// .NAME vtkScalarBarActor - Create a scalar bar with labels
+// .SECTION Description
+// vtkScalarBarActor creates a scalar bar with annotation text. A scalar
+// bar is a legend that indicates to the viewer the correspondence between
+// color value and data value. The legend consists of a rectangular bar
+// made of rectangular pieces each colored a constant value. Since
+// vtkScalarBarActor is a subclass of vtkActor2D, it is drawn in the image
+// plane (i.e., in the renderer's viewport) on top of the 3D graphics window.
+//
+// To use vtkScalarBarActor you must associate a vtkScalarsToColors (or
+// subclass) with it. The lookup table defines the colors and the
+// range of scalar values used to map scalar data. Typically, the
+// number of colors shown in the scalar bar is not equal to the number
+// of colors in the lookup table, in which case sampling of
+// the lookup table is performed.
+//
+// Other optional capabilities include specifying the fraction of the
+// viewport size (both x and y directions) which will control the size
+// of the scalar bar and the number of annotation labels. The actual position
+// of the scalar bar on the screen is controlled by using the
+// vtkActor2D::SetPosition() method (by default the scalar bar is
+// centered in the viewport). Other features include the ability to
+// orient the scalar bar horizontally of vertically and controlling
+// the format (printf style) with which to print the labels on the
+// scalar bar. Also, the vtkScalarBarActor's property is applied to
+// the scalar bar and annotation (including layer, and
+// compositing operator).
+//
+// Set the text property/attributes of the title and the labels through the
+// vtkTextProperty objects associated to this actor.
+//
+// .SECTION Caveats
+// If a vtkLogLookupTable is specified as the lookup table to use, then the
+// labels are created using a logarithmic scale.
+//
+// .SECTION See Also
+// vtkActor2D vtkTextProperty vtkTextMapper vtkPolyDataMapper2D
+
+#ifndef SMESH_SCALAR_BAR_ACTOR_H
+#define SMESH_SCALAR_BAR_ACTOR_H
+
+#include <vtkActor2D.h>
+
+#include <SMESH_Object.h>
+
+#include <vector>
+
+class vtkPolyData;
+class vtkPolyDataMapper2D;
+class vtkScalarsToColors;
+class vtkTextMapper;
+class vtkTextProperty;
+
+#define VTK_ORIENT_HORIZONTAL 0
+#define VTK_ORIENT_VERTICAL 1
+
+#define SMESH_MONOCOLOR_TYPE 0
+#define SMESH_MULTICOLOR_TYPE 1
+
+
+class SMESHOBJECT_EXPORT SMESH_ScalarBarActor: public vtkActor2D {
+ public:
+ void PrintSelf(ostream& os, vtkIndent indent);
+
+ vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D);
+
+ // Description:
+ // 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.
+ static SMESH_ScalarBarActor *New();
+
+ // Description:
+ // Draw the scalar bar and annotation text to the screen.
+ int RenderOpaqueGeometry(vtkViewport* viewport);
+ int RenderTranslucentGeometry(vtkViewport*) { return 0; };
+ int RenderOverlay(vtkViewport* viewport);
+
+ // Description:
+ // Release any graphics resources that are being consumed by this actor.
+ // The parameter window could be used to determine which graphic
+ // resources to release.
+ virtual void ReleaseGraphicsResources(vtkWindow *);
+
+ // Description:
+ // Set/Get the vtkLookupTable to use. The lookup table specifies the number
+ // of colors to use in the table (if not overridden), as well as the scalar
+ // range.
+ virtual void SetLookupTable(vtkScalarsToColors*);
+ vtkGetObjectMacro(LookupTable,vtkScalarsToColors);
+
+ // Description:
+ // Set/Get the maximum number of scalar bar segments to show. This may
+ // differ from the number of colors in the lookup table, in which case
+ // the colors are samples from the lookup table.
+ vtkSetClampMacro(MaximumNumberOfColors, int, 2, VTK_LARGE_INTEGER);
+ vtkGetMacro(MaximumNumberOfColors, int);
+
+ // Description:
+ // Set/Get the number of annotation labels to show.
+ vtkSetClampMacro(NumberOfLabels, int, 0, 64);
+ vtkGetMacro(NumberOfLabels, int);
+
+ // Description:
+ // Control the orientation of the scalar bar.
+ vtkSetClampMacro(Orientation,int,VTK_ORIENT_HORIZONTAL, VTK_ORIENT_VERTICAL);
+ vtkGetMacro(Orientation, int);
+ void SetOrientationToHorizontal()
+ {this->SetOrientation(VTK_ORIENT_HORIZONTAL);};
+ void SetOrientationToVertical() {this->SetOrientation(VTK_ORIENT_VERTICAL);};
+
+ // Description:
+ // Set/Get the title text property.
+ virtual void SetTitleTextProperty(vtkTextProperty *p);
+ vtkGetObjectMacro(TitleTextProperty,vtkTextProperty);
+
+ // Description:
+ // Set/Get the labels text property.
+ virtual void SetLabelTextProperty(vtkTextProperty *p);
+ vtkGetObjectMacro(LabelTextProperty,vtkTextProperty);
+
+ // Description:
+ // Set/Get the format with which to print the labels on the scalar
+ // bar.
+ vtkSetStringMacro(LabelFormat);
+ vtkGetStringMacro(LabelFormat);
+
+ // Description:
+ // Set/Get the title of the scalar bar actor,
+ vtkSetStringMacro(Title);
+ vtkGetStringMacro(Title);
+
+ // Description:
+ // Shallow copy of a scalar bar actor. Overloads the virtual vtkProp method.
+ void ShallowCopy(vtkProp *prop);
+
+ // Description:
+ // Set visibility of the distribution histogram
+ // rnv: Customization of the vtkScalarBarActor to show distribution histogram:
+ virtual void SetDistributionVisibility(int flag);
+
+ // Description:
+ // Set visibility of the distribution histogram
+ // rnv: Customization of the vtkScalarBarActor to show distribution histogram:
+ virtual int GetDistributionVisibility();
+ // Description:
+ // Set distribution
+ virtual void SetDistribution(std::vector<int> theNbValues);
+
+ // Description:
+ // Set distribution coloring type (SMESH_MONOCOLOR_TYPE or SMESH_MULTICOLOR_TYPE)
+ void SetDistributionColoringType(int theDistributionColoringType) {myDistributionColoringType = theDistributionColoringType;Modified();}
+
+ // Description:
+ // Get distribution coloring type ((SMESH_MONOCOLOR_TYPE or SMESH_MULTICOLOR_TYPE))
+ int GetDistributionColoringType() {return myDistributionColoringType;}
+
+ // Description:
+ // Set Distribution Color
+ void SetDistributionColor (double rgb[3]);
+
+ // Description:
+ // Get Distribution Color
+ void GetDistributionColor (double rgb[3]);
+
+
+
+ protected:
+ SMESH_ScalarBarActor();
+ ~SMESH_ScalarBarActor();
+
+ vtkScalarsToColors *LookupTable;
+ vtkTextProperty *TitleTextProperty;
+ vtkTextProperty *LabelTextProperty;
+
+ int MaximumNumberOfColors;
+ int NumberOfLabels;
+ int NumberOfLabelsBuilt;
+ int Orientation;
+ char *Title;
+ char *LabelFormat;
+
+ vtkTextMapper **TextMappers;
+ virtual void AllocateAndSizeLabels(int *labelSize, int *size,
+ vtkViewport *viewport, double *range);
+
+
+
+ private:
+ vtkTextMapper *TitleMapper;
+ vtkActor2D *TitleActor;
+
+ vtkActor2D **TextActors;
+
+ vtkPolyData *ScalarBar;
+ vtkPolyDataMapper2D *ScalarBarMapper;
+ vtkActor2D *ScalarBarActor;
+
+ vtkTimeStamp BuildTime;
+ int LastSize[2];
+ int LastOrigin[2];
+
+ void SizeTitle(int *titleSize, int *size, vtkViewport *viewport);
+
+ // rnv: Customization of the vtkScalarBarActor to show distribution histogram:
+ vtkPolyData* myDistribution; //Distribution polygonal data
+ vtkActor2D* myDistributionActor; //Distribution actor
+ vtkPolyDataMapper2D* myDistributionMapper; //Distribution mapper
+ std::vector<int> myNbValues; //Nb values for the range
+ int myDistributionColoringType; //Distribution color type (monocolor or multicolor)
+
+ private:
+ SMESH_ScalarBarActor(const SMESH_ScalarBarActor&); // Not implemented.
+ void operator=(const SMESH_ScalarBarActor&); // Not implemented.
+};
+
+#endif //SMESH_SCALAR_BAR_ACTOR_H
#include <SMESH_Client.hxx>
#include <SMESH_Actor.h>
+#include <SMESH_ScalarBarActor.h>
#include <SMESH_TypeFilter.hxx>
#include "SMESH_ControlsDef.hxx"
#include <boost/shared_ptr.hpp>
// VTK includes
-#include <vtkScalarBarActor.h>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkPlane.h>
if ( anIO->hasEntry() ) {
SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
- vtkScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
+ SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
if ( aScalarBarActor && aFunctor ) {
SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
}
}
+ void ShowDistribution() {
+ LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
+ SALOME_ListIO selected;
+ if ( aSel )
+ aSel->selectedObjects( selected );
+
+ if ( selected.Extent() == 1 ) {
+ Handle(SALOME_InteractiveObject) anIO = selected.First();
+ if ( anIO->hasEntry() ) {
+ SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
+ if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
+ SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
+ aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
+ }
+ }
+ }
+ }
+
void DisableAutoColor(){
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
SALOME_ListIO selected;
break;
}
+ case 203:
+ {
+ // show/ distribution
+ ::ShowDistribution();
+ break;
+ }
+
// Auto-color
case 1136:
::AutoColor();
createSMESHAction( 200, "RESET" );
createSMESHAction( 201, "SCALAR_BAR_PROP" );
createSMESHAction( 202, "SAVE_DISTRIBUTION" );
+ createSMESHAction( 203, "SHOW_DISTRIBUTION","",0, true );
createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
popupMgr()->insert( action( 202 ), anId, -1 ); // SAVE_DISTRIBUTION
popupMgr()->setRule( action( 202 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
+ popupMgr()->insert( action( 203 ), anId, -1 ); // SHOW_DISTRIBUTION
+ popupMgr()->setRule( action( 203 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( 203 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
+
+
popupMgr()->insert( separator(), -1, -1 );
//-------------------------------------------------
setPreferenceProperty( hh, "min", 0.0 );
setPreferenceProperty( hh, "max", 1.0 );
setPreferenceProperty( hh, "step", 0.1 );
+
+ int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
+ int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
+ setPreferenceProperty( distributionGr, "columns", 3 );
+ QStringList types;
+ types.append( tr( "SMESH_MONOCOLOR" ) );
+ types.append( tr( "SMESH_MULTICOLOR" ) );
+ indices.clear(); indices.append( 0 ); indices.append( 1 );
+ setPreferenceProperty( coloringType, "strings", types );
+ setPreferenceProperty( coloringType, "indexes", indices );
+ addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
+
}
void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
#include "SMESHGUI_Utils.h"
#include <SMESH_Actor.h>
+#include <SMESH_ScalarBarActor.h>
+#include <SMESH_ControlsDef.hxx>
// SALOME GUI includes
#include <SUIT_Desktop.h>
// VTK includes
#include <vtkTextProperty.h>
-#include <vtkScalarBarActor.h>
#include <vtkLookupTable.h>
#define MINIMUM_WIDTH 70
myOriginDimGrpLayout->addWidget( myHeightSpin, 1, 3 );
aTopLayout->addWidget( myOriginDimGrp );
+ /******************************************************************************/
- /***************************************************************/
+ // Destribution
+ myDistributionGrp = new QGroupBox ( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), this );
+ myDistributionGrp->setCheckable(true);
+ QHBoxLayout* aDistributionGrpLayout = new QHBoxLayout( myDistributionGrp );
+ aDistributionGrpLayout->setSpacing( SPACING_SIZE ); aDistributionGrpLayout->setMargin( MARGIN_SIZE );
+
+ myDistribColorGrp = new QButtonGroup( this );
+
+ myDMonoColor = new QRadioButton( tr( "SMESH_MONOCOLOR" ) , myDistributionGrp );
+ myDMultiColor = new QRadioButton( tr( "SMESH_MULTICOLOR" ), myDistributionGrp );
+ myDMonoColor->setChecked( true );
+
+ myDistribColorGrp->addButton(myDMonoColor);myDistribColorGrp->setId(myDMonoColor,1);
+ myDistribColorGrp->addButton(myDMultiColor);myDistribColorGrp->setId(myDMultiColor,2);
+
+ aDistributionGrpLayout->addWidget( myDMultiColor );
+ aDistributionGrpLayout->addWidget( myDMonoColor );
+
+ //Color of the Distribution in monocolor case:
+ myDistributionColorLbl = new QLabel( tr( "SMESH_DISTRIBUTION_COLOR" ), myDistributionGrp );
+ aDistributionGrpLayout->addWidget( myDistributionColorLbl );
+ myMonoColorBtn = new QtxColorButton( myDistributionGrp );
+ aDistributionGrpLayout->addWidget(myMonoColorBtn);
+
+ aTopLayout->addWidget(myDistributionGrp);
+
+ /******************************************************************************/
// Common buttons
myButtonGrp = new QGroupBox( this );
QHBoxLayout* myButtonGrpLayout = new QHBoxLayout( myButtonGrp );
setOriginAndSize(myIniX, myIniY, myIniW, myIniH);
+
+ bool distributionVisibility = mgr->booleanValue("SMESH","distribution_visibility");
+ myDistributionGrp->setChecked(distributionVisibility);
+
+ int coloringType = mgr->integerValue("SMESH", "distribution_coloring_type", 0);
+ if( coloringType == SMESH_MONOCOLOR_TYPE ) {
+ myDMultiColor->setChecked(true);
+ onDistributionChanged(myDistribColorGrp->id(myDMultiColor));
+ } else {
+ myDMonoColor->setChecked(true);
+ onDistributionChanged(myDistribColorGrp->id(myDMonoColor));
+ }
+
+ QColor distributionColor = mgr->colorValue("SMESH", "distribution_color",
+ QColor(255, 255, 255));
+ myMonoColorBtn->setColor(distributionColor);
+
+
+
// --> then init from selection if necessary
onSelectionChanged();
connect( myXSpin, SIGNAL( valueChanged( double ) ), this, SLOT( onXYChanged() ) );
connect( myYSpin, SIGNAL( valueChanged( double ) ), this, SLOT( onXYChanged() ) );
connect( aOrientationGrp, SIGNAL( buttonClicked( int ) ), this, SLOT( onOrientationChanged() ) );
+ connect( myDistribColorGrp, SIGNAL( buttonClicked( int ) ), this, SLOT( onDistributionChanged( int ) ) );
connect( mySelectionMgr, SIGNAL( currentSelectionChanged() ), this, SLOT( onSelectionChanged() ) );
connect( mySMESHGUI, SIGNAL( SignalCloseAllDialogs() ), this, SLOT( onCancel() ) );
- myHelpFileName = "about_quality_controls_page.html";
+ myHelpFileName = "quality_page.html";
}
//=================================================================================================
// Scalar Bar properties
if (!myActor)
return false;
- vtkScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
+ SMESH_ScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty();
QColor aTColor = myTitleColorBtn->color();
myScalarBarActor->SetLabelTextProperty( aLabelsTextPrp );
myScalarBarActor->SetNumberOfLabels( myLabelsSpin->value() );
- myScalarBarActor->SetMaximumNumberOfColors( myColorsSpin->value() );
+ if( myColorsSpin->value() != myScalarBarActor->GetMaximumNumberOfColors() ) {
+ myScalarBarActor->SetMaximumNumberOfColors( myColorsSpin->value() );
+ SMESH::Controls::FunctorPtr fn = myActor->GetFunctor();
+ SMESH::Controls::NumericalFunctor* aNumericalFunctor = dynamic_cast<SMESH::Controls::NumericalFunctor*>(fn.get());
+ if( aNumericalFunctor ) {
+ int nbIntervals = myColorsSpin->value();
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ aNumericalFunctor->GetHistogram(nbIntervals, nbEvents, funValues);
+ myScalarBarActor->SetDistribution(nbEvents);
+ }
+ }
if ( myHorizRadioBtn->isChecked() )
myScalarBarActor->SetOrientationToHorizontal();
myScalarBarActor->SetWidth( myWidthSpin->value() );
myScalarBarActor->SetHeight( myHeightSpin->value() );
+ // Distribution
+ myScalarBarActor->SetDistributionVisibility((int)myDistributionGrp->isChecked());
+ if( myDistributionGrp->isChecked() ) {
+ int ColoringType = myDMultiColor->isChecked() ? SMESH_MULTICOLOR_TYPE : SMESH_MONOCOLOR_TYPE;
+ myScalarBarActor->SetDistributionColoringType(ColoringType);
+ if( !myDMultiColor->isChecked() ) {
+ QColor aTColor = myMonoColorBtn->color();
+ double rgb[3];
+ rgb [0] = aTColor.red()/255.;
+ rgb [1] = aTColor.green()/255.;
+ rgb [2] = aTColor.blue()/255.;
+ myScalarBarActor->SetDistributionColor(rgb);
+ }
+ }
+
double aMin = myMinEdit->text().toDouble();
double aMax = myMaxEdit->text().toDouble();
vtkLookupTable* myLookupTable =
SMESH_Actor* anActor = SMESH::FindActorByEntry(anIO->getEntry());
if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
myActor = anActor;
- vtkScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
+ SMESH_ScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
if ( myScalarBarActor->GetLookupTable() ) {
vtkFloatingPointType *range = myScalarBarActor->GetLookupTable()->GetRange();
myIniH = myScalarBarActor->GetHeight();
setOriginAndSize( myIniX, myIniY, myIniW, myIniH );
+ myDistributionGrp->setChecked((bool)myScalarBarActor->GetDistributionVisibility());
+ int coloringType = myScalarBarActor->GetDistributionColoringType();
+ myScalarBarActor->GetDistributionColor( aTColor );
+ myMonoColorBtn->setColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) );
+ if ( coloringType == SMESH_MONOCOLOR_TYPE ) {
+ myDMonoColor->setChecked(true);
+ onDistributionChanged(myDistribColorGrp->id(myDMonoColor));
+ } else {
+ myDMultiColor->setChecked(true);
+ onDistributionChanged(myDistribColorGrp->id(myDMultiColor));
+ }
myRangeGrp->setEnabled( true );
myFontGrp->setEnabled( true );
myLabColorGrp->setEnabled( true );
onXYChanged();
}
+
+//=================================================================================================
+/*!
+ * SMESHGUI_Preferences_ScalarBarDlg::onDistributionChanged
+ *
+ * Called when coloring type of the distribution is changed
+ */
+//=================================================================================================
+void SMESHGUI_Preferences_ScalarBarDlg::onDistributionChanged( int id ) {
+ myMonoColorBtn->setEnabled(myDistribColorGrp->id(myDMonoColor) == id);
+ myDistributionColorLbl->setEnabled(myDistribColorGrp->id(myDMonoColor) == id);
+}
+
//=================================================================================================
/*!
* SMESHGUI_Preferences_ScalarBarDlg::onOrientationChanged
class QPushButton;
class QToolButton;
class QRadioButton;
+class QButtonGroup;
+class QLabel;
class SMESHGUI;
class SMESH_Actor;
void onSelectionChanged();
void onXYChanged();
void onOrientationChanged();
+ void onDistributionChanged( int );
private:
SMESHGUI* mySMESHGUI;
SMESHGUI_SpinBox* myWidthSpin;
SMESHGUI_SpinBox* myHeightSpin;
+ QGroupBox* myDistributionGrp;
+ QRadioButton* myDMonoColor;
+ QRadioButton* myDMultiColor;
+ QtxColorButton* myMonoColorBtn;
+ QLabel* myDistributionColorLbl;
+
QGroupBox* myButtonGrp;
+ QButtonGroup* myDistribColorGrp;
QPushButton* myOkBtn;
QPushButton* myApplyBtn;
QPushButton* myCancelBtn;
#include <SMESH_Type.h>
#include <SMESH_Actor.h>
+#include <SMESH_ScalarBarActor.h>
// SALOME GUI includes
#include <SalomeApp_Study.h>
else if ( p=="facesOrientationMode" ) val = QVariant( facesOrientationMode( ind ) );
else if ( p=="groupType" ) val = QVariant( groupType( ind ) );
else if ( p=="quadratic2DMode") val = QVariant(quadratic2DMode(ind));
+ else if ( p=="isDistributionVisible") val = QVariant(isDistributionVisible(ind));
if( val.isValid() )
return val;
return "Unknown";
}
+//=======================================================================
+//function : isDistributionVisible
+//purpose : Visible/Invisible distribution of the ScalarBar Actor
+//=======================================================================
+
+bool SMESHGUI_Selection::isDistributionVisible(int ind) const {
+ SMESH_Actor* actor = getActor( ind );
+ return (actor && actor->GetScalarBarActor() && actor->GetScalarBarActor()->GetDistributionVisibility());
+}
+
//=======================================================================
//function : shrinkMode
//purpose : return either 'IsSrunk', 'IsNotShrunk' or 'IsNotShrinkable'
}
return type;
}
-
virtual QString quadratic2DMode(int ) const;
+ virtual bool isDistributionVisible(int ) const;
+
// parameters got from actor return nothing if an actor is not visible
virtual QList<QVariant> elemTypes( int ) const;
virtual QList<QVariant> labeledTypes( int ) const;
<source>MEN_SAVE_DISTRIBUTION</source>
<translation>Export Distribution...</translation>
</message>
+ <message>
+ <source>MEN_SHOW_DISTRIBUTION</source>
+ <translation>Show Distribution</translation>
+ </message>
<message>
<source>MEN_REVOLUTION</source>
<translation>Revolution</translation>
<source>SMESH_POSITION_SIZE_SCALARBAR</source>
<translation>Origin && Size</translation>
</message>
+ <message>
+ <source>SMESH_DISTRIBUTION_SCALARBAR</source>
+ <translation>Distribution</translation>
+ </message>
+ <message>
+ <source>SMESH_SHOW_DISTRIBUTION_SCALARBAR</source>
+ <translation>Show Distribution</translation>
+ </message>
<message>
<source>SMESH_PRECISION</source>
<translation>Precision</translation>
<message>
<source>SMESH_VERTICAL</source>
<translation>Vertical</translation>
+ </message>
+ <message>
+ <source>SMESH_DISTRIBUTION_COLORING_TYPE</source>
+ <translation>Coloring Type</translation>
+ </message>
+ <message>
+ <source>SMESH_MONOCOLOR</source>
+ <translation>Monocolor</translation>
+ </message>
+ <message>
+ <source>SMESH_DISTRIBUTION_COLOR</source>
+ <translation>Distribution color:</translation>
+ </message>
+ <message>
+ <source>SMESH_MULTICOLOR</source>
+ <translation>Multicolor</translation>
</message>
<message>
<source>SMESH_VISU_PROBLEM</source>
<message>
<source>STB_SAVE_DISTRIBUTION</source>
<translation>Save distribution to the file</translation>
+ </message>
+ <message>
+ <source>STB_SHOW_DISTRIBUTION</source>
+ <translation>Show Distribution</translation>
</message>
<message>
<source>STB_REVOLUTION</source>
<source>TOP_SAVE_DISTRIBUTION</source>
<translation>Export distribution</translation>
</message>
+ <message>
+ <source>TOP_SHOW_DISTRIBUTION</source>
+ <translation>Show Distribution</translation>
+ </message>
<message>
<source>TOP_REVOLUTION</source>
<translation>Revolution</translation>
