void RemoveAllGeom();
};
- //-------------------------------------------------------
- /*! \brief Gauss Points presentation interface
- *
- * Presentation parameters of the Gauss Points presentation.
- */
- //-------------------------------------------------------
- interface GaussPoints : ColoredPrs3d {
- };
-
- /*! \brief Deformed shape presentation interface
+ /*! \brief MonoColor presentation presentation interface
*
- * Presentation parameters of the deformed shape presentation.
+ * Presentation parameters of the MonoColor presentation.
*/
- interface DeformedShape : ScalarMap {
- /*!
- * Sets the scale of the presentatable object.
- * \param theScale Double value defining the scale of this presentable object.
- */
- void SetScale(in double theScale);
-
- /*!
- * Gets the scale of the presentatable object.
- */
- double GetScale();
+ interface MonoColorPrs : ScalarMap {
/*! This boolean method returns True if this deformed shape presentation is colored.
*/
};
+ //-------------------------------------------------------
+ /*! \brief Gauss Points presentation interface
+ *
+ * Presentation parameters of the Gauss Points presentation.
+ */
+ //-------------------------------------------------------
+ interface GaussPoints : ColoredPrs3d
+ {
+ };
+
+
+ /*! \brief Deformed shape presentation interface
+ *
+ * Presentation parameters of the deformed shape presentation.
+ */
+ interface DeformedShape : MonoColorPrs {
+ /*!
+ * Sets the scale of the presentatable object.
+ * \param theScale Double value defining the scale of this presentable object.
+ */
+ void SetScale(in double theScale);
+
+ /*!
+ * Gets the scale of the presentatable object.
+ */
+ double GetScale();
+ };
+
+
//-------------------------------------------------------
/*! \brief Scalar Map on Deformed shape presentation interface
*
* Streamlines are used to convey the structure of a vector field.
* Usually streamlines are created to explore the most interesting features in the field.
*/
- interface StreamLines : DeformedShape {
+ interface StreamLines : MonoColorPrs {
/*! This enumerations contains a set of elements necessary
* for definition of direction of the stream lines.
*/
* values on the cells and on the basis of them constructs
* isobaric surfaces, which form this presentation.
*/
- interface IsoSurfaces : ScalarMap {
+ interface IsoSurfaces : MonoColorPrs {
/*!
* Sets the number of isometric surfaces.
* \param theNb A long value defining the number of isometric surfaces
* Gets the number of isometric surfaces
*/
long GetNbSurfaces();
+
+ /*!
+ * Returns TRUE if labels with values are shown
+ */
+ boolean IsLabeled();
+
+ /*!
+ * Set show or not value labels
+ */
+ void ShowLabels(in boolean theShow, in long theNb);
+
+ /*!
+ * Returns Nb of labels per surface
+ */
+ long GetNbLabels();
};
//-------------------------------------------------------
VISU_MeshAct.h \
VISU_ScalarMapAct.h \
VISU_GaussPtsAct.h \
- VISU_VectorsAct.h
+ VISU_VectorsAct.h \
+ VISU_IsoSurfActor.h
# Libraries targets
VISU_GaussPtsDeviceActor.cxx \
VISU_GaussPtsSettings.cxx \
VISU_GaussPtsAct.cxx \
- VISU_VectorsAct.cxx
+ VISU_VectorsAct.cxx \
+ VISU_IsoSurfActor.cxx
LIB_CLIENT_IDL =
--- /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_IsoSurfActor_HeaderFile
+#define VISU_IsoSurfActor_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_WidgetCtrl.hxx \
VISU_ScalarMapOnDeformedShapePL.hxx \
VISU_PrsMergerPL.hxx \
- VISU_CellDataToPointData.hxx
+ VISU_CellDataToPointData.hxx \
+ VISU_LabelPointsFilter.hxx
# Libraries targets
VISU_ScalarBarCtrl.cxx \
VISU_ScalarMapOnDeformedShapePL.cxx \
VISU_PrsMergerPL.cxx \
- VISU_CellDataToPointData.cxx
+ VISU_CellDataToPointData.cxx \
+ VISU_LabelPointsFilter.cxx
# Executables targets
--- /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 <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():
+ vtkPolyDataToPolyDataFilter(),
+ myPointsNb(3)
+{
+}
+
+//----------------------------------------------------------------------------
+VISU_LabelPointsFilter::~VISU_LabelPointsFilter()
+{}
+
+//----------------------------------------------------------------------------
+void VISU_LabelPointsFilter::Execute()
+{
+ vtkPolyData *input= this->GetInput();
+ vtkPolyData *output = this->GetOutput();
+
+ GetRegions(input, output);
+}
+
+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 <vtkPolyDataToPolyDataFilter.h>
+
+class vtkIdList;
+class vtkPolyData;
+
+class VISU_LabelPointsFilter : public vtkPolyDataToPolyDataFilter
+{
+public:
+ vtkTypeMacro(VISU_LabelPointsFilter, vtkPolyDataToPolyDataFilter);
+
+ static VISU_LabelPointsFilter* New();
+
+ void SetPointsNb(int theNb);
+
+ int GetPointsNb() const { return myPointsNb; }
+
+protected:
+ VISU_LabelPointsFilter();
+
+ virtual ~VISU_LabelPointsFilter();
+
+ virtual void Execute();
+
+ 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_IsoSurfacesDlg::DEFINE_ISOSURFACES"
msgstr "Iso Surfaces Definition"
+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) ) );
// CBUpdate = new QCheckBox ( tr( "Update scalar bar with these values" ), TopGroup);
// CBUpdate->setSizePolicy( QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed) );
// TopGroupLayout->addMultiCellWidget( CBUpdate, 4, 4, 0, 1);
// CBUpdate->setChecked(false);
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() ) );
// CBLog = new QCheckBox ( tr( "Logarithmic scaling" ), TopGroup);
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());
// switch(thePrs->GetScaling()){
// case VISU::LOGARITHMIC :
// CBLog->setChecked(true);
{
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;
// if (CBUpdate->isChecked())
// {
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_DumpPython.cc \
VISU_ScalarMapOnDeformedShape_i.cc \
VISU_PrsMerger_i.cc \
+ VISU_MonoColorPrs_i.cc \
SALOME_GenericObjPointer.cc
LIB_MOC = \
VISU_TimeAnimation.h \
VISU_ScalarMapOnDeformedShape_i.hh \
VISU_PrsMerger_i.hh \
+ VISU_MonoColorPrs_i.hh \
SALOME_GenericObjPointer.hh
# additionnal information to compil and link file
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ PrsMerger_i(theResult,theAddToStudy),
TSuperClass(theResult,theAddToStudy),
myDeformedShapePL(NULL)
{
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ PrsMerger_i(theResult,theSObject),
TSuperClass(theResult,theSObject),
myDeformedShapePL(NULL)
{
{
return CreateActor(theIO, false);
}
-
-void VISU::DeformedShape_i::UpdateActor(VISU_Actor* theActor) {
- if(VISU_ScalarMapAct* anActor = dynamic_cast<VISU_ScalarMapAct*>(theActor)){
- if(IsColored()){
- anActor->SetBarVisibility(true);
- myPipeLine->GetMapper()->SetScalarVisibility(1);
- }else{
- anActor->SetBarVisibility(false);
- myPipeLine->GetMapper()->SetScalarVisibility(0);
- SALOMEDS::Color aColor = GetColor();
- anActor->GetProperty()->SetColor(aColor.R,aColor.G,aColor.B);
- }
- TSuperClass::UpdateActor(theActor);
- }
-}
#ifndef VISU_DeformedShape_i_HeaderFile
#define VISU_DeformedShape_i_HeaderFile
-#include "VISU_PrsMerger_i.hh"
+#include "VISU_MonoColorPrs_i.hh"
class VISU_DeformedShapePL;
namespace VISU{
class DeformedShape_i : public virtual POA_VISU::DeformedShape,
- public virtual PrsMerger_i
+ public virtual MonoColorPrs_i
{
static int myNbPresent;
DeformedShape_i();
DeformedShape_i(const DeformedShape_i&);
public:
- typedef PrsMerger_i TSuperClass;
+ typedef MonoColorPrs_i TSuperClass;
explicit
DeformedShape_i(Result_i* theResult,
virtual void SetScale(CORBA::Double theScale);
virtual CORBA::Double GetScale();
- virtual CORBA::Boolean IsColored() { return PrsMerger_i::IsColored(); }
- virtual void ShowColored(CORBA::Boolean theColored) { PrsMerger_i::ShowColored( theColored ); }
-
- virtual SALOMEDS::Color GetColor() { return PrsMerger_i::GetColor();}
- virtual void SetColor(const SALOMEDS::Color& theColor) { PrsMerger_i::SetColor( theColor ); }
-
typedef VISU::DeformedShape TInterface;
VISU_DeformedShapePL* GetDeformedShapePL(){ return myDeformedShapePL;}
virtual
VISU_Actor*
CreateActor(const Handle(SALOME_InteractiveObject)& theIO, bool toSupressShrinking);
-
- virtual void UpdateActor(VISU_Actor* theActor) ;
};
}
return thePrefix;
}
+ //===========================================================================
+ std::string
+ MonoColorPrsToPython(SALOMEDS::SObject_ptr theSObject,
+ VISU::MonoColorPrs_i* theServant,
+ std::ostream& theStr,
+ std::string& theName,
+ const std::string& theConstructorName,
+ const std::string& theArgumentName,
+ std::string thePrefix)
+ {
+ thePrefix = PrsMergerToPython(theSObject,theServant,theStr,theName,theConstructorName,theArgumentName,thePrefix);
+ theStr<<thePrefix<<endl;
+ theStr<<thePrefix<<theName<<".ShowColored("<<theServant->IsColored()<<")"<<endl;
+ SALOMEDS::Color aColor = theServant->GetColor();
+ theStr<<thePrefix<<theName<<".SetColor(SALOMEDS.Color("<<
+ aColor.R<<","<<aColor.G<<","<<aColor.B<<"))"<<endl;
+
+ return thePrefix;
+ }
+
//===========================================================================
std::string
DeformedShapeToPython(SALOMEDS::SObject_ptr theSObject,
const std::string& theArgumentName,
std::string thePrefix)
{
- thePrefix = PrsMergerToPython(theSObject,theServant,theStr,theName,theConstructorName,theArgumentName,thePrefix);
+ thePrefix = MonoColorPrsToPython(theSObject,theServant,theStr,theName,theConstructorName,theArgumentName,thePrefix);
theStr<<thePrefix<<theName<<".SetScale("<<theServant->GetScale()<<")"<<endl;
- theStr<<thePrefix<<theName<<".ShowColored("<<theServant->IsColored()<<")"<<endl;
- SALOMEDS::Color aColor = theServant->GetColor();
- theStr<<thePrefix<<theName<<".SetColor(SALOMEDS.Color("<<
- aColor.R<<","<<aColor.G<<","<<aColor.B<<"))"<<endl;
-
+
return thePrefix;
}
return;
case VISU::TSTREAMLINES:
if(StreamLines_i* aServant = dynamic_cast<StreamLines_i*>(GetServant(anObj).in())){
- thePrefix = DeformedShapeToPython(theSObject,aServant,theStr,aName,"StreamLinesOnField",theArgumentName,thePrefix);
+ thePrefix = MonoColorPrsToPython(theSObject,aServant,theStr,aName,"StreamLinesOnField",theArgumentName,thePrefix);
std::string aParam;
switch(aServant->GetDirection()){
#include "VISU_Result_i.hh"
#include "VISU_IsoSurfaces_i.hh"
#include "VISU_Actor.h"
+#include "VISU_ScalarMapAct.h"
+#include "VISU_IsoSurfActor.h"
#include "SUIT_ResourceMgr.h"
#include "SALOME_Event.hxx"
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ PrsMerger_i(theResult,theAddToStudy),
TSuperClass(theResult,theAddToStudy),
- myIsoSurfacesPL(NULL)
+ myIsoSurfacesPL(NULL),
+ myIsLabeled(false),
+ myNbLabels(3)
{}
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ PrsMerger_i(theResult,theSObject),
TSuperClass(theResult,theSObject),
- myIsoSurfacesPL(NULL)
+ myIsoSurfacesPL(NULL),
+ myIsLabeled(false),
+ myNbLabels(3)
{
}
VISU::Storable* VISU::IsoSurfaces_i::Create(const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration)
{
- return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
+ VISU::Storable* aRes = TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
+ myIsColored = true;
+ myColor.R = myColor.G = myColor.B = 0.;
+
+ 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", (int)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::~IsoSurfaces_i(){
if(MYDEBUG) MESSAGE("IsoSurfaces_i::~IsoSurfaces_i()");
VISU::IsoSurfaces_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
{
- if(VISU_Actor* anActor = TSuperClass::CreateActor(theIO)){
+ 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 anActor;
+}
+
+void VISU::IsoSurfaces_i::UpdateActor(VISU_Actor* theActor)
+{
+ if(VISU_IsoSurfActor* anActor = dynamic_cast<VISU_IsoSurfActor*>(theActor)){
+ anActor->SetLinesLabeled(myIsLabeled, myNbLabels);
}
- return NULL;
+ TSuperClass::UpdateActor(theActor);
}
void VISU::IsoSurfaces_i::SetMapScale(double theMapScale){
myIsoSurfacesPL->SetMapScale(theMapScale);
}
+
+CORBA::Boolean VISU::IsoSurfaces_i::IsLabeled()
+{
+ return myIsLabeled;
+}
+
+void VISU::IsoSurfaces_i::ShowLabels(CORBA::Boolean theShow, CORBA::Long theNb)
+{
+ myIsLabeled = theShow;
+ myNbLabels = theNb;
+}
+
+CORBA::Long VISU::IsoSurfaces_i::GetNbLabels()
+{
+ return myNbLabels;
+}
#ifndef VISU_IsoSurfaces_i_HeaderFile
#define VISU_IsoSurfaces_i_HeaderFile
-#include "VISU_PrsMerger_i.hh"
+#include "VISU_MonoColorPrs_i.hh"
class VISU_IsoSurfacesPL;
namespace VISU{
class IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
- public virtual PrsMerger_i
+ public virtual MonoColorPrs_i
{
static int myNbPresent;
IsoSurfaces_i();
IsoSurfaces_i(const IsoSurfaces_i&);
public:
- typedef PrsMerger_i TSuperClass;
+ typedef MonoColorPrs_i TSuperClass;
explicit
IsoSurfaces_i(Result_i* theResult,
explicit
IsoSurfaces_i(Result_i* theResult,
SALOMEDS::SObject_ptr theSObject);
+
+ virtual void SameAs(const Prs3d_i* theOrigin);
+
virtual ~IsoSurfaces_i();
virtual VISU::VISUType GetType() { return VISU::TISOSURFACE;};
typedef VISU::IsoSurfaces TInterface;
VISU_IsoSurfacesPL* GetIsoSurfacesPL(){ return myIsoSurfacesPL;}
+ virtual CORBA::Boolean IsLabeled();
+ virtual void ShowLabels(CORBA::Boolean theShow, CORBA::Long theNb);
+
+ virtual CORBA::Long GetNbLabels();
+
protected:
virtual void DoHook();
virtual const char* GetIconName();
VISU_IsoSurfacesPL* myIsoSurfacesPL;
+ bool myIsLabeled;
+ CORBA::Long myNbLabels;
+
public:
static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration, int isMemoryCheck = true);
CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL);
virtual void SetMapScale(double theMapScale = 1.0);
+
+ virtual void UpdateActor(VISU_Actor* 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_Result_i.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(Result_i* theResult,
+ bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult,theAddToStudy),
+ ColoredPrs3d_i(theResult,theAddToStudy),
+ ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy)
+{
+}
+
+VISU::MonoColorPrs_i::
+MonoColorPrs_i(Result_i* theResult,
+ SALOMEDS::SObject_ptr theSObject) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult,theSObject),
+ ColoredPrs3d_i(theResult,theSObject),
+ ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject)
+{
+}
+
+//---------------------------------------------------------------
+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 char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ myIsColored = true;
+ myColor.R = myColor.G = myColor.B = 0.5;
+ TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
+
+ return this;
+}
+
+//---------------------------------------------------------------
+VISU::Storable*
+VISU::MonoColorPrs_i
+::Restore(const Storable::TRestoringMap& theMap)
+{
+ if(!TSuperClass::Restore(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)
+{
+ myIsColored = theColored;
+}
+
+//---------------------------------------------------------------
+SALOMEDS::Color VISU::MonoColorPrs_i::GetColor()
+{
+ return myColor;
+}
+
+//---------------------------------------------------------------
+void VISU::MonoColorPrs_i::SetColor(const SALOMEDS::Color& theColor)
+{
+ myColor = theColor;
+}
+
+VISU_Actor*
+VISU::MonoColorPrs_i
+::CreateActor(const Handle(SALOME_InteractiveObject)& theIO, bool toSupressShrinking)
+{
+ VISU_Actor* anActor = TSuperClass::CreateActor(theIO, toSupressShrinking);
+ anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
+
+ return anActor;
+}
+
+//---------------------------------------------------------------
+VISU_Actor* VISU::MonoColorPrs_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
+{
+ return CreateActor(theIO, false);
+}
+
+//---------------------------------------------------------------
+void VISU::MonoColorPrs_i::UpdateActor(VISU_Actor* theActor)
+{
+ if(VISU_ScalarMapAct* anActor = dynamic_cast<VISU_ScalarMapAct*>(theActor)){
+ if(IsColored()){
+ anActor->SetBarVisibility(true);
+ GetPL()->GetMapper()->SetScalarVisibility(1);
+ }else{
+ anActor->SetBarVisibility(false);
+ GetPL()->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_PrsMerger_i.hh"
+
+namespace VISU
+{
+ //----------------------------------------------------------------------------
+ class MonoColorPrs_i : public virtual POA_VISU::MonoColorPrs,
+ public virtual PrsMerger_i
+ {
+ MonoColorPrs_i(const MonoColorPrs_i&);
+
+ public:
+ //----------------------------------------------------------------------------
+ typedef PrsMerger_i TSuperClass;
+ typedef VISU::MonoColorPrs TInterface;
+
+ explicit
+ MonoColorPrs_i(Result_i* theResult,
+ bool theAddToStudy);
+ explicit
+ MonoColorPrs_i(Result_i* theResult,
+ SALOMEDS::SObject_ptr theSObject);
+
+ 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 char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap);
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL);
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO, bool toSupressShrinking);
+
+ virtual void UpdateActor(VISU_Actor* theActor);
+ };
+};
+#endif
{
if (MYDEBUG) MESSAGE("PrsMerger_i::Create");
- myIsColored = true;
- myColor.R = myColor.G = myColor.B = 0.5;
VISU::Storable* aRes = TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
this->SetScalarMap(theMeshName,theEntity,theFieldName,theIteration);
VISU::Storable* VISU::PrsMerger_i::Restore(const Storable::TRestoringMap& theMap)
{
if (MYDEBUG) MESSAGE("VISU::PrsMerger_i::Restore");
-
- myIsColored = VISU::Storable::FindValue(theMap,"myIsColored",QString( "1" )).toInt();
- myColor.R = VISU::Storable::FindValue(theMap,"myColor.R",QString( "0.5" )).toDouble();
- myColor.G = VISU::Storable::FindValue(theMap,"myColor.G",QString( "0.5" )).toDouble();
- myColor.B = VISU::Storable::FindValue(theMap,"myColor.B",QString( "0.5" )).toDouble();
TSuperClass::Restore(theMap);
Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() );
Storable::DataToStream( theStr, "myGeomNameList", aStrSubMeshName.latin1());
Storable::DataToStream( theStr, "myGeomEntityList", aStrEntity.latin1());
-
- 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 );
-
-
}
void VISU::PrsMerger_i::clearMeshList()
::DoHook(){
if(!myPipeLine) myPipeLine = VISU_PrsMergerPL::New();
myPrsMergerPL = dynamic_cast<VISU_PrsMergerPL*>(myPipeLine);
- myPipeLine->GetMapper()->SetScalarVisibility(IsColored());
TSuperClass::DoHook();
}
virtual VISU::VISUType GetType() { return VISU::TPRSMERGER;};
- virtual CORBA::Boolean IsColored() { return myIsColored; }
- virtual void ShowColored(CORBA::Boolean theColored) { myIsColored = theColored; }
-
- virtual SALOMEDS::Color GetColor() { return myColor;}
- virtual void SetColor(const SALOMEDS::Color& theColor) { myColor = theColor;}
-
VISU_PrsMergerPL* GetPrsMergerPL(){ return myPrsMergerPL;}
virtual void Update();
* you we will need in different mesh entities (ENTITY,FAMILY,GROUP) as geometries.
*/
TNameAndEntityList myGeomNameEntityList;
-
- private:
-
- SALOMEDS::Color myColor;
- bool myIsColored;
-
public:
static int IsCompatibleCellTypes(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
PrsMerger_i(theResult,theAddToStudy),
- DeformedShape_i(theResult,theAddToStudy),
+ MonoColorPrs_i(theResult,theAddToStudy),
myStreamLinesPL(NULL),
myAppendFilter(vtkAppendFilter::New())
{
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
PrsMerger_i(theResult,theSObject),
- DeformedShape_i(theResult,theSObject),
+ MonoColorPrs_i(theResult,theSObject),
myStreamLinesPL(NULL),
myAppendFilter(vtkAppendFilter::New())
{
VISU::Storable* VISU::StreamLines_i::Create(const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration)
{
- return DeformedShape_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
}
void VISU::StreamLines_i::ToStream(std::ostringstream& theStr){
- DeformedShape_i::ToStream(theStr);
+ TSuperClass::ToStream(theStr);
Storable::DataToStream( theStr, "myIntegrationStep", GetIntegrationStep());
Storable::DataToStream( theStr, "myPropagationTime", GetPropagationTime());
if(!myPipeLine) myPipeLine = VISU_StreamLinesPL::New();
myStreamLinesPL = dynamic_cast<VISU_StreamLinesPL*>(myPipeLine);
- DeformedShape_i::DoHook();
+ TSuperClass::DoHook();
}
const char*
void VISU::StreamLines_i::Update() {
SetSource();
- VISU::DeformedShape_i::Update();
+ TSuperClass::Update();
}
VISU::StreamLines_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
{
- if(VISU_Actor* anActor = VISU::DeformedShape_i::CreateActor(theIO, true)){
+ if(VISU_Actor* anActor = TSuperClass::CreateActor(theIO, true)){
anActor->SetVTKMapping(true);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU", "stream_lines_represent", 1);
void VISU::StreamLines_i::UpdateActor(VISU_Actor* theActor) {
- VISU::DeformedShape_i::UpdateActor(theActor);
+ TSuperClass::UpdateActor(theActor);
}
#ifndef VISU_StreamLines_i_HeaderFile
#define VISU_StreamLines_i_HeaderFile
-#include "VISU_DeformedShape_i.hh"
+#include "VISU_MonoColorPrs_i.hh"
class VISU_StreamLinesPL;
class vtkAppendFilter;
namespace VISU{
class StreamLines_i : public virtual POA_VISU::StreamLines,
- public virtual DeformedShape_i
+ public virtual MonoColorPrs_i
{
static int myNbPresent;
StreamLines_i();
StreamLines_i(const StreamLines_i&);
public:
- typedef DeformedShape_i TSuperClass;
+ typedef MonoColorPrs_i TSuperClass;
explicit
StreamLines_i(Result_i* theResult,
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
PrsMerger_i(theResult,theAddToStudy),
+ MonoColorPrs_i(theResult,theAddToStudy),
DeformedShape_i(theResult,theAddToStudy),
myVectorsPL(NULL)
{
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
PrsMerger_i(theResult,theSObject),
+ MonoColorPrs_i(theResult,theSObject),
DeformedShape_i(theResult,theSObject),
myVectorsPL(NULL)
{
void VISU::Vectors_i::DoHook(){
if(!myPipeLine) myPipeLine = VISU_VectorsPL::New();
myVectorsPL = dynamic_cast<VISU_VectorsPL*>(myPipeLine);
-
+
DeformedShape_i::DoHook();
}
