VISU_GaussPtsAct.h \
VISU_VectorsAct.h \
VISU_PointMap3dActor.h \
- VISU_ActorBase.h
+ VISU_ActorBase.h \
+ VISU_IsoSurfActor.h
dist_libVisuObject_la_SOURCES = \
VISU_Actor.cxx \
VISU_GaussPtsAct.cxx \
VISU_VectorsAct.cxx \
VISU_PointMap3dActor.cxx \
- VISU_ActorBase.cxx
+ VISU_ActorBase.cxx \
+ VISU_IsoSurfActor.cxx
libVisuObject_la_CPPFLAGS= \
$(QT_INCLUDES) \
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 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 : VISU_IsoSurfActor.cxx
+// Author : Vitaly Smetannikov
+// Module : VISU
+
+
+#include "VISU_IsoSurfActor.h"
+#include "VISU_PipeLine.hxx"
+#include "VISU_LabelPointsFilter.hxx"
+
+
+#include <vtkObjectFactory.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkPolyData.h>
+#include <vtkActor2D.h>
+//#include <vtkMaskPoints.h>
+#include <vtkLabeledDataMapper.h>
+#include <vtkProperty2D.h>
+#include <vtkRenderer.h>
+#include <vtkCellArray.h>
+#include <vtkPointData.h>
+
+
+
+//----------------------------------------------------------------------------
+vtkStandardNewMacro(VISU_IsoSurfActor);
+
+
+//----------------------------------------------------------------------------
+VISU_IsoSurfActor::VISU_IsoSurfActor():
+ VISU_ScalarMapAct(),
+ myIsLinesLabeled(true)
+{
+ myLabelsDataSet = vtkPolyData::New();
+
+// myMaskPoints = vtkMaskPoints::New();
+// myMaskPoints->SetInput(myLabelsDataSet);
+// myMaskPoints->SetOnRatio(100);
+
+ myMaskPoints = VISU_LabelPointsFilter::New();
+ myMaskPoints->SetInput(myLabelsDataSet);
+
+ myLabeledDataMapper = vtkLabeledDataMapper::New();
+ myLabeledDataMapper->SetInput(myMaskPoints->GetOutput());
+ //myLabeledDataMapper->SetLabelFormat("%e");
+ myLabeledDataMapper->SetLabelModeToLabelScalars();
+
+ myLabels = vtkActor2D::New();
+ myLabels->SetMapper(myLabeledDataMapper);
+ myLabels->GetProperty()->SetColor(1,1,1);
+ myLabels->SetVisibility(myIsLinesLabeled);
+}
+
+
+//----------------------------------------------------------------------------
+VISU_IsoSurfActor::~VISU_IsoSurfActor()
+{
+ myLabelsDataSet->Delete();
+ myMaskPoints->Delete();
+ myLabeledDataMapper->Delete();
+ myLabels->Delete();
+}
+
+//----------------------------------------------------------------------------
+void VISU_IsoSurfActor::SetLinesLabeled(bool theIsLinesLabeled, int theNbLbl)
+{
+ myIsLinesLabeled = theIsLinesLabeled;
+ myMaskPoints->SetPointsNb(theNbLbl);
+ Modified();
+}
+
+//----------------------------------------------------------------------------
+int VISU_IsoSurfActor::GetNbLabels() const
+{
+ return myMaskPoints->GetPointsNb();
+}
+
+
+//----------------------------------------------------------------------------
+void VISU_IsoSurfActor::UpdateLabels()
+{
+ if (myIsLinesLabeled) {
+ vtkDataSet* aDataSet = GetPipeLine()->GetOutput();
+ if (aDataSet != NULL) {
+ unsigned long aTime = myLabelsDataSet->GetMTime();
+ unsigned long anObjTime = GetMTime();
+ if (aTime < anObjTime) {
+ myLabelsDataSet->ShallowCopy(aDataSet);
+ myLabelsDataSet->Modified();
+ }
+ }
+ }
+ myLabels->SetVisibility(myIsLinesLabeled);
+}
+
+
+//----------------------------------------------------------------------------
+void VISU_IsoSurfActor::AddToRender(vtkRenderer* theRenderer)
+{
+ VISU_ScalarMapAct::AddToRender(theRenderer);
+ theRenderer->AddActor2D(myLabels);
+}
+
+//----------------------------------------------------------------------------
+void VISU_IsoSurfActor::RemoveFromRender(vtkRenderer* theRenderer)
+{
+ VISU_ScalarMapAct::RemoveFromRender(theRenderer);
+ theRenderer->RemoveActor(myLabels);
+}
+
+//From vtkFollower
+int VISU_IsoSurfActor::RenderOpaqueGeometry(vtkViewport *vp)
+{
+ UpdateLabels();
+ return VISU_ScalarMapAct::RenderOpaqueGeometry(vp);
+}
+
+
+int VISU_IsoSurfActor::RenderTranslucentGeometry(vtkViewport *vp)
+{
+ UpdateLabels();
+ return VISU_ScalarMapAct::RenderTranslucentGeometry(vp);
+}
+
+void VISU_IsoSurfActor::SetVisibility(int theMode){
+ VISU_ScalarMapAct::SetVisibility(theMode);
+ if(GetVisibility())
+ myLabels->VisibilityOn();
+ else
+ myLabels->VisibilityOff();
+ Modified();
+}
+
+
+///!!!! For test purposes only
+// void VISU_IsoSurfActor::SetMapperInput(vtkDataSet* theDataSet)
+// {
+// VISU_ScalarMapAct::SetMapperInput(theDataSet);
+
+// vtkFeatureEdges* aFilter = vtkFeatureEdges::New();
+// aFilter->SetInput(VISU_ScalarMapAct::GetInput());
+// SetInput(aFilter->GetOutput());
+// }
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 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 : VISU_IsoSurfActor.h
+// Author : Vitaly Smetannikov
+// Module : VISU
+
+
+#ifndef VISU_VectorsAct_HeaderFile
+#define VISU_VectorsAct_HeaderFile
+
+#include "VISU_ScalarMapAct.h"
+
+class vtkActor2D;
+//class vtkMaskPoints;
+class vtkLabeledDataMapper;
+class vtkPolyData;
+class VISU_LabelPointsFilter;
+
+
+class VTKOCC_EXPORT VISU_IsoSurfActor : public VISU_ScalarMapAct
+{
+ public:
+ vtkTypeMacro(VISU_IsoSurfActor, VISU_ScalarMapAct);
+
+ static VISU_IsoSurfActor* New();
+
+
+ //----------------------------------------------------------------------------
+ virtual void AddToRender( vtkRenderer* );
+
+ virtual void RemoveFromRender( vtkRenderer* );
+
+ virtual int RenderOpaqueGeometry(vtkViewport *viewport);
+ virtual int RenderTranslucentGeometry(vtkViewport *viewport);
+
+ //virtual void SetPipeLine(VISU_PipeLine* thePipeLine);
+
+ void SetLinesLabeled(bool theIsLinesLabeled, int theNbLbl);
+ bool GetLinesLabeled() const { return myIsLinesLabeled;}
+
+ int GetNbLabels() const;
+
+
+ //----------------------------------------------------------------------------
+ //! Visibility management
+ virtual void SetVisibility( int );
+
+
+ protected:
+
+ VISU_IsoSurfActor();
+ ~VISU_IsoSurfActor();
+
+ void UpdateLabels();
+
+ vtkActor2D *myLabels;
+ vtkLabeledDataMapper* myLabeledDataMapper;
+ //vtkMaskPoints* myMaskPoints;
+ VISU_LabelPointsFilter* myMaskPoints;
+ vtkPolyData* myLabelsDataSet;
+
+ bool myIsLinesLabeled;
+ //int myNbLabels;
+};
+
+
+#endif
VISU_SphereWidget.hxx \
VISU_WidgetCtrl.hxx \
VISU_ScalarMapOnDeformedShapePL.hxx \
- VISUPipeline.hxx
+ VISUPipeline.hxx \
+ VISU_LabelPointsFilter.hxx
dist_libVisuPipeLine_la_SOURCES= \
VISU_MapperHolder.cxx \
VISU_SphereWidget.cxx \
VISU_WidgetCtrl.cxx \
VISU_ScalarBarCtrl.cxx \
- VISU_ScalarMapOnDeformedShapePL.cxx
+ VISU_ScalarMapOnDeformedShapePL.cxx \
+ VISU_LabelPointsFilter.cxx
libVisuPipeLine_la_CPPFLAGS= \
$(VTK_INCLUDES) \
#include "VISU_LookupTable.hxx"
#include "VISU_PipeLineUtils.hxx"
+#include "VISU_LabelPointsFilter.hxx"
#include <vtkContourFilter.h>
+
//----------------------------------------------------------------------------
vtkStandardNewMacro(VISU_IsoSurfacesPL);
return myContourFilter->GetNumberOfContours();
}
+//----------------------------------------------------------------------------
+vtkFloatingPointType
+VISU_IsoSurfacesPL
+::GetValue(int i)
+{
+ return myContourFilter->GetValue(i);
+}
+
//----------------------------------------------------------------------------
void
VISU::CellDataToPoint(myContourFilter,
myCellDataToPointData,
GetMergedInput());
+
}
int
GetNbParts();
+ virtual vtkFloatingPointType GetValue(int i);
+
virtual
void
SetNbParts(int theNb = 10);
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 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: VISU_LabelPointsFilter.cxx
+// Author: Vitaly Smetannikov
+// Module : VISU
+
+
+
+#include "VISU_LabelPointsFilter.hxx"
+
+#include <vtkPolyData.h>
+#include <vtkObjectFactory.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
+#include <vtkFeatureEdges.h>
+#include <vtkCellArray.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+#include <vtkDataArray.h>
+#include <vtkDoubleArray.h>
+#include <vtkGeometryFilter.h>
+#include <vtkPolyDataConnectivityFilter.h>
+#include <vtkMath.h>
+
+#include <set>
+#include <vector>
+
+
+#define CONTAINS(SET, PT) (SET.find(PT) != SET.end())
+
+struct ltIdType
+{
+ bool operator()(const vtkIdType a1, const vtkIdType a2) const
+ {
+ return a1 < a2;
+ }
+};
+
+
+
+//----------------------------------------------------------------------------
+vtkStandardNewMacro(VISU_LabelPointsFilter);
+
+
+//----------------------------------------------------------------------------
+void VISU_LabelPointsFilter::SetPointsNb(int theNb)
+{
+ if (myPointsNb == theNb) return;
+ myPointsNb = (theNb < 1)? 1:theNb;
+ Modified();
+}
+
+//----------------------------------------------------------------------------
+VISU_LabelPointsFilter::VISU_LabelPointsFilter():
+ vtkPolyDataAlgorithm(),
+ myPointsNb(3)
+{
+}
+
+//----------------------------------------------------------------------------
+VISU_LabelPointsFilter::~VISU_LabelPointsFilter()
+{}
+
+
+
+//----------------------------------------------------------------------------
+int VISU_LabelPointsFilter::RequestData(vtkInformation* vtkNotUsed(request),
+ vtkInformationVector** inputVector,
+ vtkInformationVector* outputVector)
+{
+ // get the info objects
+ vtkInformation* inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation* outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkPolyData* input = vtkPolyData::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkPolyData* output = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
+ GetRegions(input, output);
+
+ return 1;
+}
+
+int VISU_LabelPointsFilter::RequestUpdateExtent(vtkInformation* vtkNotUsed(request),
+ vtkInformationVector** inputVector,
+ vtkInformationVector* outputVector)
+{
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ vtkPolyData* input = vtkPolyData::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkPolyData* output = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
+ GetRegions(input, output);
+ return 1;
+}
+
+
+
+int VISU_LabelPointsFilter::GetRegions(vtkPolyData* theInput,
+ vtkPolyData* theOutput)
+{
+ vtkIdType cellId, i;
+ vtkIdType numPts, numCells;
+ vtkPoints *inPts;
+
+ vtkPointData *aInpPD=theInput->GetPointData(), *aOutPD=theOutput->GetPointData();
+ vtkCellData *aInpCD=theInput->GetCellData(), *aOutCD=theOutput->GetCellData();
+
+ // Check input/allocate storage
+ //
+ inPts = theInput->GetPoints();
+
+ if (inPts == NULL)
+ return 1;
+
+ numPts = inPts->GetNumberOfPoints();
+ numCells = theInput->GetNumberOfCells();
+
+ if ( numPts < 1 || numCells < 1 )
+ return 1;
+
+ // Build cell structure
+ //
+ vtkPolyData* aMesh = vtkPolyData::New();
+ aMesh->CopyStructure(theInput);
+ aMesh->BuildLinks();
+
+ // Initialize. Keep track of points and cells visited.
+ //
+ vtkIdTypeArray* aRegionSizes = vtkIdTypeArray::New();
+ int* aVisited = new int[numCells];
+ for ( i=0; i < numCells; i++ )
+ aVisited[i] = -1;
+
+ vtkIdType* aPointMap = new vtkIdType[numPts];
+ for ( i=0; i < numPts; i++ )
+ aPointMap[i] = -1;
+
+ vtkPoints* newPts = vtkPoints::New();
+ newPts->Allocate(numPts);
+
+ // Traverse all cells marking those visited. Each new search
+ // starts a new connected region. Connected region grows
+ // using a connected wave propagation.
+ //
+ vtkIdList* aWave = vtkIdList::New();
+ aWave->Allocate(numPts/4+1,numPts);
+ vtkIdList* aWave2 = vtkIdList::New();
+ aWave2->Allocate(numPts/4+1,numPts);
+
+ vtkIdType aPointNumber = 0;
+ int aRegionNumber = 0;
+
+ vtkIdList* aCellIds = vtkIdList::New();
+ aCellIds->Allocate(8, VTK_CELL_SIZE);
+ vtkIdList* aPointIds = vtkIdList::New();
+ aPointIds->Allocate(8, VTK_CELL_SIZE);
+
+ // vtkIdType aNumCellsInRegion;
+
+ aOutPD->CopyAllocate(aInpPD);
+ aOutCD->CopyAllocate(aInpCD);
+
+ //visit all cells marking with region number
+ for (cellId=0; cellId < numCells; cellId++) {
+ if ( aVisited[cellId] < 0 ) {
+ aWave->InsertNextId(cellId);
+ aPointNumber = 0;
+ TraverseAndMark(aWave, aWave2, aVisited, aPointMap,
+ aRegionNumber, aPointNumber, aMesh);
+
+ if (aPointNumber >= myPointsNb) {
+ std::set<vtkIdType, ltIdType> aIdxSet;
+ for (i=0; i < numPts; i++) {
+ if ( aPointMap[i] > -1 ) {
+ aIdxSet.insert(i);
+ aPointMap[i] = -1;
+ }
+ }
+ std::vector<vtkIdType> aIdx(aIdxSet.begin(), aIdxSet.end());
+ int aActualPts = aIdx.size();
+ int aNewId;
+ if (myPointsNb > 2) {
+ int k = aActualPts/(myPointsNb - 1);
+ int count;
+ for (i=0, count = 0; i < aActualPts; i+=k, count++) {
+ aNewId = newPts->InsertNextPoint(inPts->GetPoint(aIdx[i]));
+ aOutPD->CopyData(aInpPD, aIdx[i], aNewId);
+ }
+ if (count < myPointsNb) {
+ aNewId = newPts->InsertNextPoint(inPts->GetPoint(aIdx[aActualPts - 1]));
+ aOutPD->CopyData(aInpPD, aIdx[aActualPts - 1], aNewId);
+ }
+ } else {
+ aNewId = newPts->InsertNextPoint(inPts->GetPoint(aIdx[0]));
+ aOutPD->CopyData(aInpPD, aIdx[0], aNewId);
+ if (myPointsNb == 2) {
+ aNewId = newPts->InsertNextPoint(inPts->GetPoint(aIdx[aActualPts - 1]));
+ aOutPD->CopyData(aInpPD, aIdx[aActualPts - 1], aNewId);
+ }
+ }
+ }
+ aWave->Reset();
+ aWave2->Reset();
+ }
+ }
+
+ aWave->Delete();
+ aWave2->Delete();
+
+ theOutput->SetPoints(newPts);
+ newPts->Delete();
+
+
+ delete [] aVisited;
+ delete [] aPointMap;
+ aMesh->Delete();
+ theOutput->Squeeze();
+ aCellIds->Delete();
+ aPointIds->Delete();
+
+ return aRegionSizes->GetMaxId() + 1;
+}
+
+
+// Mark current cell as visited and assign region number. Note:
+// traversal occurs across shared vertices.
+//
+void VISU_LabelPointsFilter::TraverseAndMark (vtkIdList* theWave,
+ vtkIdList* theWave2,
+ int* theVisited,
+ vtkIdType* thePointMap,
+ int& theRegionNumber,
+ vtkIdType& thePointNumber,
+ vtkPolyData* theMesh)
+{
+ vtkIdType cellId, ptId, numIds, i;
+ int j, k;
+ vtkIdType *pts, *cells, npts;
+ vtkIdList *tmpWave;
+ unsigned short ncells;
+ vtkIdList* aNeighborCellPointIds = vtkIdList::New();
+
+
+ while ( (numIds=theWave->GetNumberOfIds()) > 0 ) {
+ for ( i=0; i < numIds; i++ ) {
+ cellId = theWave->GetId(i);
+ if ( theVisited[cellId] < 0 ) {
+ theVisited[cellId] = theRegionNumber;
+ theMesh->GetCellPoints(cellId, npts, pts);
+
+ for (j=0; j < npts; j++) {
+ if ( thePointMap[ptId=pts[j]] < 0 ) {
+ thePointMap[ptId] = thePointNumber++;
+ }
+ theMesh->GetPointCells(ptId,ncells,cells);
+
+ // check connectivity criterion (geometric + scalar)
+ for (k=0; k < ncells; k++) {
+ cellId = cells[k];
+ theWave2->InsertNextId(cellId);
+ // }
+ }//for all cells using this point
+ }//for all points of this cell
+ }//if cell not yet visited
+ }//for all cells in this wave
+
+ tmpWave = theWave;
+ theWave = theWave2;
+ theWave2 = tmpWave;
+ tmpWave->Reset();
+ } //while wave is not empty
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 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: VISU_LabelPointsFilter.hxx
+// Author: Vitaly Smetannikov
+// Module : VISU
+
+#ifndef VISU_LabelPointsFilter_HeaderFile
+#define VISU_LabelPointsFilter_HeaderFile
+
+#include "VISUPipeline.hxx"
+#include <vtkPolyDataAlgorithm.h>
+
+class vtkPolyData;
+
+class VISU_PIPELINE_EXPORT VISU_LabelPointsFilter : public vtkPolyDataAlgorithm
+{
+public:
+ vtkTypeMacro(VISU_LabelPointsFilter, vtkPolyDataAlgorithm);
+
+ static VISU_LabelPointsFilter* New();
+
+ void SetPointsNb(int theNb);
+
+ int GetPointsNb() const { return myPointsNb; }
+
+protected:
+ VISU_LabelPointsFilter();
+
+ virtual ~VISU_LabelPointsFilter();
+
+ virtual int RequestData(vtkInformation* request,
+ vtkInformationVector** inputVector,
+ vtkInformationVector* outputVector);
+
+ virtual int RequestUpdateExtent(vtkInformation*,
+ vtkInformationVector**,
+ vtkInformationVector*);
+
+
+ void TraverseAndMark (vtkIdList* theWave,
+ vtkIdList* theWave2,
+ int* theVisited,
+ vtkIdType* thePointMap,
+ int& theRegionNumber,
+ vtkIdType& thePointNumber,
+ vtkPolyData* theMesh);
+
+ int GetRegions(vtkPolyData* theInput,
+ vtkPolyData* theOutput);
+
+ int myPointsNb;
+
+};
+
+
+#endif
msgid "VisuGUI_IsoSurfPane::SHOW_LEVEL_LABELS"
msgstr "Show level labels"
+msgid "VisuGUI_IsoSurfPane::MAGNITUDE_COLORING_CHK"
+msgstr "Magnitude coloring"
+
+msgid "VisuGUI_IsoSurfPane::SEL_COLOR_BTN"
+msgstr "Select Color"
+
+msgid "VisuGUI_IsoSurfPane::SHOW_VALUES_CHK"
+msgstr "Show values (nb per surface)"
+
#: VisuGUI_NonIsometricDlg.cxx
#include <qlayout.h>
#include <qvalidator.h>
#include <qtabwidget.h>
+#include <qcolordialog.h>
using namespace std;
LabelMax->setBuddy(MaxIso);
TopGroupLayout->addWidget( MaxIso, 2, 1 );
+ myUseMagnitude = new QCheckBox(tr("MAGNITUDE_COLORING_CHK"), TopGroup, "myUseMagnitude");
+ myUseMagnitude->setChecked(true);
+ TopGroupLayout->addWidget( myUseMagnitude, 3, 0 );
+ mySelColor = new QPushButton(tr("SEL_COLOR_BTN"), TopGroup, "mySelColor");
+ mySelColor->setPaletteBackgroundColor(Qt::black);
+ mySelColor->setPaletteForegroundColor(Qt::gray);
+ mySelColor->setDisabled(true);
+ TopGroupLayout->addWidget( mySelColor, 3, 1 );
+ connect( mySelColor, SIGNAL( clicked() ), this, SLOT( setColor() ) );
+ connect( myUseMagnitude, SIGNAL( toggled(bool) ), mySelColor, SLOT( setDisabled(bool) ) );
+
+ myUseLabels = new QCheckBox(tr("SHOW_VALUES_CHK"), TopGroup, "myUseLabels");
+ myUseLabels->setChecked(false);
+ TopGroupLayout->addWidget( myUseLabels, 4, 0 );
+ myNbLabels = new QSpinBox( 1, 100, 1, TopGroup, "myNbLabels" );
+ myNbLabels->setEnabled(false);
+ TopGroupLayout->addWidget( myNbLabels, 4, 1 );
+ connect( myUseLabels, SIGNAL( toggled(bool) ), myNbLabels, SLOT( setEnabled(bool) ) );
+
+
QPushButton* aUpdateBtn = new QPushButton( "Update scalar bar range with these values", TopGroup);
- TopGroupLayout->addMultiCellWidget( aUpdateBtn, 3, 3, 0, 1);
+ TopGroupLayout->addMultiCellWidget( aUpdateBtn, 5, 5, 0, 1);
connect( aUpdateBtn, SIGNAL( clicked() ), this, SLOT(onCBUpdate() ) );
}
NbrIso->setValue(thePrs->GetNbSurfaces());
MinIso->setText(QString::number(thePrs->GetSubMin()));
MaxIso->setText(QString::number(thePrs->GetSubMax()));
+ myUseMagnitude->setChecked(thePrs->IsColored());
+ SALOMEDS::Color anOldColor = thePrs->GetColor();
+ QColor aColor = QColor(int(255*anOldColor.R),int(255*anOldColor.G),int(255*anOldColor.B));
+ setColor(aColor);
+
+ myUseLabels->setChecked(thePrs->IsLabeled());
+ myNbLabels->setValue(thePrs->GetNbLabels());
}
int VisuGUI_IsoSurfPane::storeToPrsObject (VISU::IsoSurfaces_i* thePrs)
{
thePrs->SetNbSurfaces(NbrIso->value());
thePrs->SetSubRange(MinIso->text().toDouble(), MaxIso->text().toDouble());
+ thePrs->ShowLabels(myUseLabels->isOn(), myNbLabels->value());
+ thePrs->ShowColored(myUseMagnitude->isOn());
+ if(!thePrs->IsColored()){
+ QColor aQColor = color();
+ SALOMEDS::Color aColor;
+ aColor.R = aQColor.red()/255.;
+ aColor.G = aQColor.green()/255.;
+ aColor.B = aQColor.blue()/255.;
+ thePrs->SetColor(aColor);
+ }
return 1;
}
return true;
}
+void VisuGUI_IsoSurfPane::setColor()
+{
+ QColor cnew = QColorDialog::getColor( mySelColor->paletteBackgroundColor(), this );
+ if ( cnew.isValid() )
+ setColor(cnew);
+}
+void VisuGUI_IsoSurfPane::setColor(const QColor& theColor)
+{
+ mySelColor->setPaletteBackgroundColor(theColor);
+}
+QColor VisuGUI_IsoSurfPane::color() const
+{
+ return mySelColor->paletteBackgroundColor();
+}
/*!
bool check();
+ void setColor(const QColor& theColor);
+ QColor color() const;
+
protected slots:
void onCBUpdate();
+ void setColor();
private:
QLineEdit* MinIso;
QLineEdit* MaxIso;
QSpinBox* NbrIso;
VisuGUI_ScalarBarPane* myScalarPane;
+ QCheckBox* myUseMagnitude;
+ QPushButton* mySelColor;
+ QCheckBox* myUseLabels;
+ QSpinBox* myNbLabels;
};
VISU_TimeAnimation.h \
VISU_ScalarMapOnDeformedShape_i.hh \
VISU_ColoredPrs3dFactory.hh \
+ VISU_MonoColorPrs_i.hh \
SALOME_GenericObjPointer.hh
libVISUEngineImpl_la_SOURCES = \
VISU_Table_i.cc \
VISU_PointMap3d_i.cc \
VISU_DumpPython.cc \
+ VISU_MonoColorPrs_i.cc \
SALOME_GenericObjPointer.cc
MOC_FILES = VISU_TimeAnimation_moc.cxx
::DeformedShape_i(EPublishInStudyMode thePublishInStudyMode):
ColoredPrs3d_i(thePublishInStudyMode),
ScalarMap_i(thePublishInStudyMode),
+ MonoColorPrs_i(thePublishInStudyMode),
myDeformedShapePL(NULL)
{
if(MYDEBUG) MESSAGE("DeformedShape_i::DeformedShape_i");
const std::string& theFieldName,
CORBA::Long theTimeStampNumber)
{
- myIsColored = false;
- myColor.R = myColor.G = myColor.B = 0.5;
return TSuperClass::Create(theMeshName,theEntity,theFieldName,theTimeStampNumber);
}
return NULL;
SetScale(VISU::Storable::FindValue(theMap,"myFactor").toDouble());
- myIsColored = VISU::Storable::FindValue(theMap,"myIsColored").toInt();
- myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
- myColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble();
- myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble();
return this;
}
TSuperClass::ToStream(theStr);
Storable::DataToStream( theStr, "myFactor", GetScale() );
-
- Storable::DataToStream( theStr, "myIsColored", myIsColored );
- Storable::DataToStream( theStr, "myColor.R", myColor.R );
- Storable::DataToStream( theStr, "myColor.G", myColor.G );
- Storable::DataToStream( theStr, "myColor.B", myColor.B );
}
}
-//---------------------------------------------------------------
-CORBA::Boolean
-VISU::DeformedShape_i
-::IsColored()
-{
- return myIsColored;
-}
-
-
-//---------------------------------------------------------------
-void
-VISU::DeformedShape_i
-::ShowColored(CORBA::Boolean theColored)
-{
- if(myIsColored == theColored)
- return;
-
- myIsColored = theColored;
- myParamsTime.Modified();
-}
-
-//---------------------------------------------------------------
-SALOMEDS::Color
-VISU::DeformedShape_i
-::GetColor()
-{
- return myColor;
-}
-
-
-//---------------------------------------------------------------
-void
-VISU::DeformedShape_i
-::SetColor(const SALOMEDS::Color& theColor)
-{
- bool anIsSameValue = VISU::CheckIsSameValue(myColor.R, theColor.R);
- anIsSameValue &= VISU::CheckIsSameValue(myColor.G, theColor.G);
- anIsSameValue &= VISU::CheckIsSameValue(myColor.B, theColor.B);
- if(anIsSameValue)
- return;
-
- VISU::TSetModified aModified(this);
-
- myColor = theColor;
- myParamsTime.Modified();
-}
-
-
//---------------------------------------------------------------
void
VISU::DeformedShape_i
bool toShrink = aResourceMgr->booleanValue("VISU", "deformed_shape_shrink", false);
anActor->SetRepresentation(aDispMode);
if (toShrink && !toSupressShrinking) anActor->SetShrink();
- anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
return anActor;
}
-//---------------------------------------------------------------
-VISU_Actor*
-VISU::DeformedShape_i
-::CreateActor()
-{
- return CreateActor(false);
-}
-
-
-//---------------------------------------------------------------
-void
-VISU::DeformedShape_i
-::UpdateActor(VISU_Actor* theActor)
-{
- if(VISU_ScalarMapAct* anActor = dynamic_cast<VISU_ScalarMapAct*>(theActor)){
- if(IsColored()){
- anActor->SetBarVisibility(true);
- GetPipeLine()->GetMapper()->SetScalarVisibility(1);
- }else{
- anActor->SetBarVisibility(false);
- GetPipeLine()->GetMapper()->SetScalarVisibility(0);
- anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
- }
- TSuperClass::UpdateActor(theActor);
- }
-}
#define VISU_DeformedShape_i_HeaderFile
#include <VISU_I.hxx>
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_MonoColorPrs_i.hh"
class VISU_DeformedShapePL;
{
//----------------------------------------------------------------------------
class VISU_I_EXPORT DeformedShape_i : public virtual POA_VISU::DeformedShape,
- public virtual ScalarMap_i
+ public virtual MonoColorPrs_i
{
static int myNbPresent;
DeformedShape_i(const DeformedShape_i&);
public:
//----------------------------------------------------------------------------
- typedef ScalarMap_i TSuperClass;
+ typedef MonoColorPrs_i TSuperClass;
typedef VISU::DeformedShape TInterface;
explicit
CORBA::Double
GetScale();
- virtual
- CORBA::Boolean
- IsColored();
-
- virtual
- void
- ShowColored(CORBA::Boolean theColored);
-
- virtual
- SALOMEDS::Color
- GetColor();
-
- virtual
- void
- SetColor(const SALOMEDS::Color& theColor);
-
VISU_DeformedShapePL*
GetSpecificPL() const
{
CheckIsPossible();
VISU_DeformedShapePL *myDeformedShapePL;
- SALOMEDS::Color myColor;
- bool myIsColored;
public:
static
void
SetMapScale(double theMapScale = 1.0);
- virtual
- VISU_Actor*
- CreateActor();
-
virtual
VISU_Actor*
CreateActor(bool toSupressShrinking);
- virtual
- void
- UpdateActor(VISU_Actor* theActor) ;
};
}
return thePrefix;
}
+ //---------------------------------------------------------------------------
+ std::string
+ MonoColorPrsToPython(SALOMEDS::SObject_ptr theSObject,
+ VISU::MonoColorPrs_i* theServant,
+ std::ostream& theStr,
+ const std::string& theName,
+ TColoredPrs3dFactory& thePrsFactory,
+ std::string thePrefix)
+ {
+ thePrefix = ScalarMapToPython(theSObject, theServant, theStr, theName, thePrsFactory, thePrefix);
+ theStr<<thePrefix<<endl;
+ theStr<<thePrefix<<theName<<".ShowColored("<<GetBoolean(theServant->IsColored())<<")"<<endl;
+ theStr<<thePrefix<<theName<<".SetColor("<<GetColor(theServant->GetColor())<<")"<<endl;
+ return thePrefix;
+ }
//---------------------------------------------------------------------------
std::string
TColoredPrs3dFactory& thePrsFactory,
std::string thePrefix)
{
- thePrefix = ScalarMapToPython(theSObject, theServant, theStr, theName, thePrsFactory, thePrefix);
+ thePrefix = MonoColorPrsToPython(theSObject, theServant, theStr, theName, thePrsFactory, thePrefix);
theStr<<thePrefix<<endl;
theStr<<thePrefix<<theName<<".SetScale("<<theServant->GetScale()<<")"<<endl;
- theStr<<thePrefix<<theName<<".ShowColored("<<GetBoolean(theServant->IsColored())<<")"<<endl;
- theStr<<thePrefix<<theName<<".SetColor("<<GetColor(theServant->GetColor())<<")"<<endl;
+// theStr<<thePrefix<<theName<<".ShowColored("<<GetBoolean(theServant->IsColored())<<")"<<endl;
+// theStr<<thePrefix<<theName<<".SetColor("<<GetColor(theServant->GetColor())<<")"<<endl;
return thePrefix;
}
TColoredPrs3dFactory& thePrsFactory,
std::string thePrefix)
{
- thePrefix = DeformedShapeToPython(theSObject, theServant, theStr, theName, thePrsFactory, thePrefix);
+ thePrefix = MonoColorPrsToPython(theSObject, theServant, theStr, theName, thePrsFactory, thePrefix);
+ // thePrefix = DeformedShapeToPython(theSObject, theServant, theStr, theName, thePrsFactory, thePrefix);
theStr<<thePrefix<<endl;
std::string aParam;
theStr<<thePrefix<<endl;
theStr<<thePrefix<<theName<<".SetNbSurfaces("<<theServant->GetNbSurfaces()<<")"<<endl;
+ theStr<<thePrefix<<theName<<".ShowLabels("<<theServant->IsLabeled()<<","<<theServant->GetNbLabels()<<")"<<endl;
return thePrefix;
}
#include "VISU_IsoSurfacesPL.hxx"
#include "VISU_Result_i.hh"
#include "VISU_Actor.h"
+#include "VISU_ScalarMapAct.h"
+#include "VISU_IsoSurfActor.h"
#include "SUIT_ResourceMgr.h"
#include "SALOME_Event.hxx"
+#include <vtkMapper.h>
#ifdef _DEBUG_
static int MYDEBUG = 0;
::IsoSurfaces_i(EPublishInStudyMode thePublishInStudyMode) :
ColoredPrs3d_i(thePublishInStudyMode),
ScalarMap_i(thePublishInStudyMode),
- myIsoSurfacesPL(NULL)
+ MonoColorPrs_i(thePublishInStudyMode),
+ myIsoSurfacesPL(NULL),
+ myIsLabeled(false),
+ myNbLabels(3)
{}
const std::string& theFieldName,
CORBA::Long theTimeStampNumber)
{
- return TSuperClass::Create(theMeshName,theEntity,theFieldName,theTimeStampNumber);
+ VISU::Storable* aRes = TSuperClass::Create(theMeshName,theEntity,theFieldName,theTimeStampNumber);
+ myIsColored = true;
+ myColor.R = myColor.G = myColor.B = 0.;
+ //myIsLabeled = false;
+ //myNbLabels = 3;
+ return aRes;
}
SetNbSurfaces(VISU::Storable::FindValue(theMap,"myNbSurface").toInt());
float aMin = VISU::Storable::FindValue(theMap,"myRange[0]").toDouble();
float aMax = VISU::Storable::FindValue(theMap,"myRange[1]").toDouble();
+ myNbLabels = VISU::Storable::FindValue(theMap,"myNbLabels").toInt();
+ myIsLabeled = VISU::Storable::FindValue(theMap,"myIsLabeled").toInt();
SetSubRange(aMin,aMax);
return this;
Storable::DataToStream( theStr, "myNbSurface", int(GetNbSurfaces()) );
Storable::DataToStream( theStr, "myRange[0]", GetSubMin() );
Storable::DataToStream( theStr, "myRange[1]", GetSubMax() );
+ Storable::DataToStream( theStr, "myNbLabels", myNbLabels );
+ Storable::DataToStream( theStr, "myIsLabeled", myIsLabeled );
}
+//---------------------------------------------------------------
+void VISU::IsoSurfaces_i::SameAs(const Prs3d_i* theOrigin)
+{
+ TSuperClass::SameAs(theOrigin);
+
+ if(const IsoSurfaces_i* aPrs3d = dynamic_cast<const IsoSurfaces_i*>(theOrigin)){
+ IsoSurfaces_i* anOrigin = const_cast<IsoSurfaces_i*>(aPrs3d);
+ ShowLabels(anOrigin->IsLabeled(), anOrigin->GetNbLabels());
+ }
+}
+
+
//---------------------------------------------------------------
VISU::IsoSurfaces_i
}
//---------------------------------------------------------------
-VISU_Actor*
-VISU::IsoSurfaces_i
-::CreateActor()
+VISU_Actor* VISU::IsoSurfaces_i::CreateActor()
{
- if(VISU_Actor* anActor = TSuperClass::CreateActor()){
+ VISU_IsoSurfActor* anActor = VISU_IsoSurfActor::New();
+ try{
+ VISU::Prs3d_i::CreateActor(anActor);
+ anActor->SetBarVisibility(true);
anActor->SetVTKMapping(true);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU" , "iso_surfaces_represent", 2);
anActor->SetRepresentation(aDispMode);
- return anActor;
+ UpdateActor(anActor);
+ }catch(...){
+ anActor->Delete();
+ throw ;
}
- return NULL;
+
+ return anActor;
}
+//---------------------------------------------------------------
+void VISU::IsoSurfaces_i::UpdateActor(VISU_ActorBase* theActor)
+{
+ if(VISU_IsoSurfActor* anActor = dynamic_cast<VISU_IsoSurfActor*>(theActor)){
+ anActor->SetLinesLabeled(myIsLabeled, myNbLabels);
+ }
+ TSuperClass::UpdateActor(theActor);
+}
//---------------------------------------------------------------
void
{
myIsoSurfacesPL->SetMapScale(theMapScale);
}
+
+//---------------------------------------------------------------
+CORBA::Boolean VISU::IsoSurfaces_i::IsLabeled()
+{
+ return myIsLabeled;
+}
+
+//---------------------------------------------------------------
+void VISU::IsoSurfaces_i::ShowLabels(CORBA::Boolean theShow, CORBA::Long theNb)
+{
+ if ((myIsLabeled == theShow) && (myNbLabels == theNb)) return;
+ VISU::TSetModified aModified(this);
+ myIsLabeled = theShow;
+ myNbLabels = theNb;
+ myParamsTime.Modified();
+}
+
+//---------------------------------------------------------------
+CORBA::Long VISU::IsoSurfaces_i::GetNbLabels()
+{
+ return myNbLabels;
+}
+
#define VISU_IsoSurfaces_i_HeaderFile
#include "VISU_I.hxx"
-#include "VISU_ScalarMap_i.hh"
+//#include "VISU_ScalarMap_i.hh"
+#include "VISU_MonoColorPrs_i.hh"
class VISU_IsoSurfacesPL;
{
//----------------------------------------------------------------------------
class VISU_I_EXPORT IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
- public virtual ScalarMap_i
+ public virtual MonoColorPrs_i
{
static int myNbPresent;
IsoSurfaces_i(const IsoSurfaces_i&);
public:
//----------------------------------------------------------------------------
- typedef ScalarMap_i TSuperClass;
+ typedef MonoColorPrs_i TSuperClass;
typedef VISU::IsoSurfaces TInterface;
explicit
IsoSurfaces_i(EPublishInStudyMode thePublishInStudyModep);
+ virtual void SameAs(const Prs3d_i* theOrigin);
+
virtual
~IsoSurfaces_i();
{
return myIsoSurfacesPL;
}
+
+
+ virtual CORBA::Boolean IsLabeled();
+ virtual void ShowLabels(CORBA::Boolean theShow, CORBA::Long theNb);
+
+ virtual CORBA::Long GetNbLabels();
+
protected:
//! Redefines VISU_ColoredPrs3d_i::CreatePipeLine
virtual
VISU_IsoSurfacesPL* myIsoSurfacesPL;
+ bool myIsLabeled;
+ CORBA::Long myNbLabels;
+
public:
static
size_t
virtual
void
SetMapScale(double theMapScale = 1.0);
+
+ virtual void UpdateActor(VISU_ActorBase* theActor);
+
};
}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 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 : VISU_MonoColorPrs_i.cxx
+// Author : Vitaly Smetannikov
+// Module : VISU
+
+
+#include "VISU_MonoColorPrs_i.hh"
+#include "VISU_Prs3dUtils.hh"
+#include "VISU_PipeLineUtils.hxx"
+#include "VISU_ScalarMapAct.h"
+
+#include "VISU_PipeLine.hxx"
+
+#include <vtkDataSetMapper.h>
+#include <vtkProperty.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+//---------------------------------------------------------------
+VISU::MonoColorPrs_i
+::MonoColorPrs_i(EPublishInStudyMode thePublishInStudyMode):
+ ColoredPrs3d_i(thePublishInStudyMode),
+ ScalarMap_i(thePublishInStudyMode)
+{
+ if(MYDEBUG) MESSAGE("MonoColorPrs_i::MonoColorPrs_i");
+}
+
+//---------------------------------------------------------------
+void
+VISU::MonoColorPrs_i
+::SameAs(const Prs3d_i* theOrigin)
+{
+ TSuperClass::SameAs(theOrigin);
+
+ if(const MonoColorPrs_i* aPrs3d = dynamic_cast<const MonoColorPrs_i*>(theOrigin)){
+ MonoColorPrs_i* anOrigin = const_cast<MonoColorPrs_i*>(aPrs3d);
+ SetColor(anOrigin->GetColor());
+ ShowColored(anOrigin->IsColored());
+ }
+}
+
+
+//---------------------------------------------------------------
+VISU::Storable*
+VISU::MonoColorPrs_i
+::Create(const std::string& theMeshName,
+ VISU::Entity theEntity,
+ const std::string& theFieldName,
+ CORBA::Long theTimeStampNumber)
+{
+ myIsColored = false;
+ myColor.R = myColor.G = myColor.B = 0.5;
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theTimeStampNumber);
+}
+
+//---------------------------------------------------------------
+VISU::Storable*
+VISU::MonoColorPrs_i
+::Restore(SALOMEDS::SObject_ptr theSObject,
+ const Storable::TRestoringMap& theMap)
+{
+ if(!TSuperClass::Restore(theSObject, theMap))
+ return NULL;
+
+ myIsColored = VISU::Storable::FindValue(theMap,"myIsColored").toInt();
+ myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
+ myColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble();
+ myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble();
+
+ return this;
+}
+
+//---------------------------------------------------------------
+void
+VISU::MonoColorPrs_i
+::ToStream(std::ostringstream& theStr)
+{
+ TSuperClass::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myIsColored", myIsColored );
+ Storable::DataToStream( theStr, "myColor.R", myColor.R );
+ Storable::DataToStream( theStr, "myColor.G", myColor.G );
+ Storable::DataToStream( theStr, "myColor.B", myColor.B );
+}
+
+
+//---------------------------------------------------------------
+VISU::MonoColorPrs_i::~MonoColorPrs_i()
+{
+ if(MYDEBUG) MESSAGE("MonoColorPrs_i::~MonoColorPrs_i()");
+}
+
+//---------------------------------------------------------------
+CORBA::Boolean VISU::MonoColorPrs_i::IsColored()
+{
+ return myIsColored;
+}
+
+
+
+//---------------------------------------------------------------
+void
+VISU::MonoColorPrs_i::ShowColored(CORBA::Boolean theColored)
+{
+ if(myIsColored == theColored)
+ return;
+ myIsColored = theColored;
+ myParamsTime.Modified();
+}
+
+//---------------------------------------------------------------
+SALOMEDS::Color VISU::MonoColorPrs_i::GetColor()
+{
+ return myColor;
+}
+
+//---------------------------------------------------------------
+void VISU::MonoColorPrs_i::SetColor(const SALOMEDS::Color& theColor)
+{
+ bool anIsSameValue = VISU::CheckIsSameValue(myColor.R, theColor.R);
+ anIsSameValue &= VISU::CheckIsSameValue(myColor.G, theColor.G);
+ anIsSameValue &= VISU::CheckIsSameValue(myColor.B, theColor.B);
+ if(anIsSameValue)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myColor = theColor;
+ myParamsTime.Modified();
+}
+
+//---------------------------------------------------------------
+VISU_Actor* VISU::MonoColorPrs_i::CreateActor(bool toSupressShrinking)
+{
+ VISU_Actor* anActor = TSuperClass::CreateActor(toSupressShrinking);
+ anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
+ return anActor;
+}
+
+//---------------------------------------------------------------
+VISU_Actor* VISU::MonoColorPrs_i::CreateActor()
+{
+ return CreateActor(false);
+}
+
+//---------------------------------------------------------------
+void VISU::MonoColorPrs_i::UpdateActor(VISU_ActorBase* theActor)
+{
+ if(VISU_ScalarMapAct* anActor = dynamic_cast<VISU_ScalarMapAct*>(theActor)){
+ if(IsColored()){
+ anActor->SetBarVisibility(true);
+ GetPipeLine()->GetMapper()->SetScalarVisibility(1);
+ }else{
+ anActor->SetBarVisibility(false);
+ GetPipeLine()->GetMapper()->SetScalarVisibility(0);
+ anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
+ }
+ TSuperClass::UpdateActor(theActor);
+ }
+}
+
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 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 : VISU_MonoColorPrs_i.hxx
+// Author : Vitaly Smetannikov
+// Module : VISU
+
+
+#ifndef VISU_MonoColorPrs_i_HeaderFile
+#define VISU_MonoColorPrs_i_HeaderFile
+
+#include <VISU_I.hxx>
+#include "VISU_ScalarMap_i.hh"
+
+namespace VISU
+{
+ //----------------------------------------------------------------------------
+ class VISU_I_EXPORT MonoColorPrs_i : public virtual POA_VISU::MonoColorPrs,
+ public virtual ScalarMap_i
+ {
+ MonoColorPrs_i(const MonoColorPrs_i&);
+
+ public:
+ //----------------------------------------------------------------------------
+ typedef ScalarMap_i TSuperClass;
+ typedef VISU::MonoColorPrs TInterface;
+
+ explicit MonoColorPrs_i(EPublishInStudyMode thePublishInStudyModep);
+
+ virtual void SameAs(const Prs3d_i* theOrigin);
+
+ virtual ~MonoColorPrs_i();
+
+ virtual CORBA::Boolean IsColored();
+
+ virtual void ShowColored(CORBA::Boolean theColored);
+
+ virtual SALOMEDS::Color GetColor();
+
+ virtual void SetColor(const SALOMEDS::Color& theColor);
+
+ protected:
+ SALOMEDS::Color myColor;
+ bool myIsColored;
+
+ public:
+ virtual Storable* Create(const std::string& theMeshName,
+ VISU::Entity theEntity,
+ const std::string& theFieldName,
+ CORBA::Long theTimeStampNumber);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const Storable::TRestoringMap& theMap);
+
+ virtual VISU_Actor* CreateActor();
+
+ virtual VISU_Actor* CreateActor(bool toSupressShrinking);
+
+ virtual void UpdateActor(VISU_ActorBase* theActor);
+ };
+};
+#endif
#include <boost/bind.hpp>
#ifdef _DEBUG_
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
#else
static int MYDEBUG = 0;
#endif
::StreamLines_i(EPublishInStudyMode thePublishInStudyMode) :
ColoredPrs3d_i(thePublishInStudyMode),
ScalarMap_i(thePublishInStudyMode),
- DeformedShape_i(thePublishInStudyMode),
+ MonoColorPrs_i(thePublishInStudyMode),
myStreamLinesPL(NULL),
myAppendFilter(vtkAppendFilter::New())
{}
#ifndef VISU_StreamLines_i_HeaderFile
#define VISU_StreamLines_i_HeaderFile
-#include "VISU_DeformedShape_i.hh"
+//#include "VISU_DeformedShape_i.hh"
+#include "VISU_MonoColorPrs_i.hh"
class VISU_StreamLinesPL;
class vtkAppendFilter;
{
//----------------------------------------------------------------------------
class VISU_I_EXPORT StreamLines_i : public virtual POA_VISU::StreamLines,
- public virtual DeformedShape_i
+ public virtual MonoColorPrs_i
+ //public virtual DeformedShape_i
{
static int myNbPresent;
StreamLines_i(const StreamLines_i&);
public:
//----------------------------------------------------------------------------
- typedef DeformedShape_i TSuperClass;
+ typedef MonoColorPrs_i TSuperClass;
typedef VISU::StreamLines TInterface;
explicit
::Vectors_i(EPublishInStudyMode thePublishInStudyMode) :
ColoredPrs3d_i(thePublishInStudyMode),
ScalarMap_i(thePublishInStudyMode),
+ MonoColorPrs_i(thePublishInStudyMode),
DeformedShape_i(thePublishInStudyMode),
myLineWidth(1.0),
myVectorsPL(NULL)
