Orientation GetBarOrientation();
};
+ /*! \brief Presentation merger interface
+ *
+ * Presentation parameters of the prsmerger shape presentation.
+ */
+ interface PrsMerger : ScalarMap {
+
+ void SetMeshOnGroup(in string theMeshName,
+ in string theGroupName);
+
+ long AddMeshOnGroup(in string theMeshName,
+ in string theGroupName);
+
+ void RemoveGeometryById(in long theId);
+
+ string_array getGroupNames();
+
+ void SetFamilyOnEntity(in string theMeshName,
+ in Entity theEntity,
+ in string theFamilyName);
+
+ void SetMeshOnEntity(in string theMeshName,
+ in Entity theEntity);
+
+ void SetScalarMap(in string theMeshName,
+ in Entity theEntity,
+ in string theFieldName,
+ in long theStampsNum);
+
+ long GetMeshGeometryPlace(in long theId);
+
+ };
+
//-------------------------------------------------------
/*! \brief Gauss Points presentation interface
*
*
* Presentation parameters of the deformed shape presentation.
*/
- interface DeformedShape : ScalarMap {
+ interface DeformedShape : PrsMerger {
/*!
* Sets the scale of the presentatable object.
* \param theScale Double value defining the scale of this presentable object.
};
- /*! \brief Presentation merger interface
- *
- * Presentation parameters of the prsmerger shape presentation.
- */
- interface PrsMerger : ScalarMap {
-
- void SetMeshOnGroup(in string theMeshName,
- in string theGroupName);
-
- long AddMeshOnGroup(in string theMeshName,
- in string theGroupName);
-
- void RemoveGeometryById(in long theId);
-
- string_array getGroupNames();
-
- void SetFamilyOnEntity(in string theMeshName,
- in Entity theEntity,
- in string theFamilyName);
-
- void SetMeshOnEntity(in string theMeshName,
- in Entity theEntity);
-
- void SetScalarMap(in string theMeshName,
- in Entity theEntity,
- in string theFieldName,
- in long theStampsNum);
-
- long GetMeshGeometryPlace(in long theId);
-
- };
-
//-------------------------------------------------------
/*! \brief Scalar Map on Deformed shape presentation interface
*
* Presentation parameters of the scalar map on deformed shape presentation.
*/
- interface ScalarMapOnDeformedShape : ScalarMap {
+ interface ScalarMapOnDeformedShape : PrsMerger {
/*!
* Sets the source ranges of pipeline
* consists of deforming initial planar mesh according to values assigned to the mesh elements.
* If mesh not planar but volumic one, it is possible to generate intermediate planar mesh.
*/
- interface Plot3D : ScalarMap {
+ interface Plot3D : PrsMerger {
/*!
* This enumeration contains a set of elements defining
* the type of orientation in 3D space of the cutting plane.
* consists of cutting your initial mesh by a definite number of planes. As the
* result you will see these planes which will be cutted by the borders of the mesh.
*/
- interface CutPlanes : ScalarMap {
+ interface CutPlanes : PrsMerger {
/*!
* This enumeration contains a set of elements defining the type of orientation in 3D space
* of the cut planes.
* operation is a regular array of lines in space, belonging to the same plane
* and having the same orientation. They are located inside or on the mesh.
*/
- interface CutLines : ScalarMap {
+ interface CutLines : PrsMerger {
/*!
* Sets the type of orientation in 3D space of the base plane of a cut lines presentation.
* \param theOrientation The orientation of the base plane in 3D space.
* values on the cells and on the basis of them constructs
* isobaric surfaces, which form this presentation.
*/
- interface IsoSurfaces : ScalarMap {
+ interface IsoSurfaces : PrsMerger {
/*!
* Sets the number of isometric surfaces.
* \param theNb A long value defining the number of isometric surfaces
CorrectPnt(myBasePnt,aBaseBounds);
- VISU_ScalarMapPL::Update();
+ VISU_PrsMergerPL::Update();
}
for (int i = 0, iend = GetNbParts(); i < iend; i++)
if(!aPipeLine->IsPartDefault(i)) SetPartPosition(i, aPipeLine->GetPartPosition(i));
}
- VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ Superclass::ShallowCopy(thePipeLine);
}
void
VISU_CutPlanesPL
::Init()
{
- VISU_ScalarMapPL::Init();
+ Superclass::Init();
SetNbParts(10);
myBasePlane[0] = YZ;
CutWithPlanes(myAppendPolyData,aDataSet,myNbParts,aDir,aBounds,
myPartPosition,myPartCondition,myDisplacement[0]);
- VISU_ScalarMapPL::Update();
+ Superclass::Update();
}
void
#ifndef VISU_CutPlanesPL_HeaderFile
#define VISU_CutPlanesPL_HeaderFile
-#include "VISU_ScalarMapPL.hxx"
+#include "VISU_PrsMergerPL.hxx"
#include <vector>
class vtkAppendPolyData;
-class VISU_CutPlanesPL : public VISU_ScalarMapPL{
+class VISU_CutPlanesPL : public VISU_PrsMergerPL{
protected:
VISU_CutPlanesPL();
VISU_CutPlanesPL(const VISU_CutPlanesPL&);
public:
- vtkTypeMacro(VISU_CutPlanesPL,VISU_ScalarMapPL);
+ vtkTypeMacro(VISU_CutPlanesPL,VISU_PrsMergerPL);
static VISU_CutPlanesPL* New();
virtual
if(VISU_DeformedShapePL *aPipeLine = dynamic_cast<VISU_DeformedShapePL*>(thePipeLine)){
SetScale(aPipeLine->GetScale());
}
- VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ TSupperClass::ShallowCopy(thePipeLine);
}
vtkFloatingPointType
VISU_DeformedShapePL
::Init()
{
- VISU_ScalarMapPL::Init();
+ TSupperClass::Init();
vtkFloatingPointType aScalarRange[2];
GetSourceRange(aScalarRange);
vtkDataSet* aDataSet = GetInput2();
+ //vtkDataSet* aDataSet = GetScalars()->GetInput();
vtkFloatingPointType aScaleFactor = VISU_DeformedShapePL::GetScaleFactor( aDataSet );
static double EPS = 1.0 / VTK_LARGE_FLOAT;
VISU_DeformedShapePL
::Update()
{
- VISU_ScalarMapPL::Update();
+ TSupperClass::Update();
}
void
VISU_DeformedShapePL
::SetMapScale(vtkFloatingPointType theMapScale)
{
- VISU_ScalarMapPL::SetMapScale(theMapScale);
+ TSupperClass::SetMapScale(theMapScale);
myWarpVector->SetScaleFactor(myScaleFactor*theMapScale);
Modified();
#ifndef VISU_DeformedShapePL_HeaderFile
#define VISU_DeformedShapePL_HeaderFile
-#include "VISU_ScalarMapPL.hxx"
+#include "VISU_PrsMergerPL.hxx"
class vtkCellDataToPointData;
class SALOME_Transform;
class vtkWarpVector;
-class VISU_DeformedShapePL : public VISU_ScalarMapPL
+class VISU_DeformedShapePL : public VISU_PrsMergerPL
{
+ typedef VISU_PrsMergerPL TSupperClass;
+
protected:
VISU_DeformedShapePL();
VISU_DeformedShapePL(const VISU_DeformedShapePL&);
~VISU_DeformedShapePL();
public:
- vtkTypeMacro(VISU_DeformedShapePL,VISU_ScalarMapPL);
+ vtkTypeMacro(VISU_DeformedShapePL,TSupperClass);
static
VISU_DeformedShapePL*
vtkFloatingPointType aRange[2] = {aPipeLine->GetMin(), aPipeLine->GetMax()};
SetRange(aRange);
}
- VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ TSupperClass::ShallowCopy(thePipeLine);
}
int
VISU_IsoSurfacesPL
::SetScaling(int theScaling)
{
- VISU_ScalarMapPL::SetScaling(theScaling);
+ TSupperClass::SetScaling(theScaling);
SetRange(myRange);
}
void
VISU_IsoSurfacesPL
::Init()
{
- VISU_ScalarMapPL::Init();
+ TSupperClass::Init();
SetNbParts(10);
vtkFloatingPointType aScalarRange[2];
VISU_IsoSurfacesPL
::Update()
{
- VISU_ScalarMapPL::Update();
+ TSupperClass::Update();
}
void
VISU_IsoSurfacesPL
::SetMapScale(vtkFloatingPointType theMapScale)
{
- VISU_ScalarMapPL::SetMapScale(theMapScale);
+ TSupperClass::SetMapScale(theMapScale);
vtkFloatingPointType aRange[2] = {GetMax() - theMapScale*(GetMax()-GetMin()), GetMax()};
vtkFloatingPointType aNewRange[2] = {aRange[0], aRange[1]};
#ifndef VISU_IsoSurfacesPL_HeaderFile
#define VISU_IsoSurfacesPL_HeaderFile
-#include "VISU_ScalarMapPL.hxx"
+#include "VISU_PrsMergerPL.hxx"
class vtkContourFilter;
class vtkCellDataToPointData;
-class VISU_IsoSurfacesPL : public VISU_ScalarMapPL
+class VISU_IsoSurfacesPL : public VISU_PrsMergerPL
{
+ typedef VISU_ScalarMapPL TSupperClass;
+
protected:
VISU_IsoSurfacesPL();
VISU_IsoSurfacesPL(const VISU_IsoSurfacesPL&);
~VISU_IsoSurfacesPL();
public:
- vtkTypeMacro(VISU_IsoSurfacesPL,VISU_ScalarMapPL);
+ vtkTypeMacro(VISU_IsoSurfacesPL,TSupperClass);
static
VISU_IsoSurfacesPL*
SetContourPrs( aPipeLine->GetIsContourPrs() );
SetNumberOfContours( aPipeLine->GetNumberOfContours() );
}
- VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ TSupperClass::ShallowCopy(thePipeLine);
}
VISU_CutPlanesPL::PlaneOrientation
VISU_Plot3DPL::
Init()
{
- VISU_ScalarMapPL::Init();
+ TSupperClass::Init();
myOrientation = GetOrientation(GetInput2());
SetScaleFactor(GetScaleFactor(GetInput2()));
myWarpScalar->SetNormal(aPlaneNormal);
- VISU_ScalarMapPL::Update();
+ TSupperClass::Update();
}
void
void VISU_Plot3DPL::SetMapScale(vtkFloatingPointType theMapScale)
{
- VISU_ScalarMapPL::SetMapScale(theMapScale);
+ TSupperClass::SetMapScale(theMapScale);
if ( myIsContour ) {
vtkFloatingPointType aRange[2];
#ifndef VISU_Plot3DPL_HeaderFile
#define VISU_Plot3DPL_HeaderFile
-#include "VISU_ScalarMapPL.hxx"
+#include "VISU_PrsMergerPL.hxx"
#include "VISU_CutPlanesPL.hxx"
class vtkWarpScalar;
class vtkGeometryFilter;
class vtkCellDataToPointData;
-class VISU_Plot3DPL : public VISU_ScalarMapPL{
+class VISU_Plot3DPL : public VISU_PrsMergerPL{
+ typedef VISU_ScalarMapPL TSupperClass;
protected:
VISU_Plot3DPL();
VISU_Plot3DPL(const VISU_Plot3DPL&);
public:
- vtkTypeMacro(VISU_Plot3DPL,VISU_ScalarMapPL);
+ vtkTypeMacro(VISU_Plot3DPL,TSupperClass);
static VISU_Plot3DPL* New();
virtual ~VISU_Plot3DPL();
VISU_ScalarMapOnDeformedShapePL
::Init()
{
- if (GetScalars() == NULL) SetScalars(GetInput2());
+ if (GetScalarsUnstructuredGrid() == NULL) SetScalars(GetInput2());
Superclass::Init();
VISU_ScalarMapOnDeformedShapePL *aPipeLine = dynamic_cast<VISU_ScalarMapOnDeformedShapePL*>(thePipeLine);
if(aPipeLine){
SetScale(aPipeLine->GetScale());
- SetScalars(aPipeLine->GetScalars());
+ SetScalars(aPipeLine->GetScalarsUnstructuredGrid());
vtkFloatingPointType aRange[2];
aPipeLine->GetSourceRange(aRange);
SetScalarRange(aRange);
::SetScalars(vtkDataSet *theScalars)
{
myScalars = theScalars;
- vtkUnstructuredGrid* aScalars = GetScalars();
+ vtkUnstructuredGrid* aScalars = GetScalarsUnstructuredGrid();
vtkCellData *aInCellData = GetInput()->GetCellData();
if(aScalars->GetPointData()->GetScalars())
*/
vtkUnstructuredGrid*
VISU_ScalarMapOnDeformedShapePL
-::GetScalars()
+::GetScalarsUnstructuredGrid()
{
return myScalars.GetPointer();
}
#ifndef VISU_ScalarMapOnDeformedShapePL_HeaderFile
#define VISU_ScalarMapOnDeformedShapePL_HeaderFile
-#include "VISU_ScalarMapPL.hxx"
+#include "VISU_PrsMergerPL.hxx"
class vtkMergeFilter;
class vtkWarpVector;
class vtkCellDataToPointData;
class vtkPointDataToCellData;
-class VISU_ScalarMapOnDeformedShapePL : public VISU_ScalarMapPL
+class VISU_ScalarMapOnDeformedShapePL : public VISU_PrsMergerPL
{
protected:
VISU_ScalarMapOnDeformedShapePL();
VISU_ScalarMapOnDeformedShapePL(const VISU_ScalarMapOnDeformedShapePL&);
public:
- vtkTypeMacro(VISU_ScalarMapOnDeformedShapePL,VISU_ScalarMapPL);
+ vtkTypeMacro(VISU_ScalarMapOnDeformedShapePL,VISU_PrsMergerPL);
static VISU_ScalarMapOnDeformedShapePL* New();
virtual void GetSourceRange(vtkFloatingPointType theRange[2]);
virtual void SetScalars(vtkDataSet *theScalars);
- virtual vtkUnstructuredGrid* GetScalars();
+ virtual vtkUnstructuredGrid* GetScalarsUnstructuredGrid();
public:
//! Redefined method for initialization of the pipeline.
VISU_StreamLinesPL
::Init()
{
- VISU_ScalarMapPL::Init();
+ VISU_PrsMergerPL::Init();
vtkPointSet* aDataSet = myExtractor->GetOutput();
vtkFloatingPointType anIntStep = GetBaseIntegrationStep(aDataSet);
vtkFloatingPointType aPropagationTime = GetBasePropagationTime(aDataSet);
VISU_StreamLinesPL
::Update()
{
- VISU_ScalarMapPL::Update();
+ VISU_PrsMergerPL::Update();
}
void
int VISU::CutLines_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration, int isMemoryCheck)
{
- return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
+ return TSuperClass::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
}
int VISU::CutLines_i::myNbPresent = 0;
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy),
myCutLinesPL(NULL)
{}
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject),
myCutLinesPL(NULL)
{
}
VISU::Storable* VISU::CutLines_i::Create(const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration)
{
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
}
void VISU::CutLines_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
+ TSuperClass::ToStream(theStr);
int aNbLines = GetNbLines();
if(!myPipeLine) myPipeLine = VISU_CutLinesPL::New();
myCutLinesPL = dynamic_cast<VISU_CutLinesPL*>(myPipeLine);
- ScalarMap_i::DoHook();
+ TSuperClass::DoHook();
}
VISU_Actor*
VISU::CutLines_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
{
- if(VISU_Actor* anActor = ScalarMap_i::CreateActor(theIO)){
+ if(VISU_Actor* anActor = TSuperClass::CreateActor(theIO)){
anActor->SetVTKMapping(true);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU" , "cut_lines_represent", 2);
#ifndef VISU_CutLines_i_HeaderFile
#define VISU_CutLines_i_HeaderFile
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_PrsMerger_i.hh"
class VISU_CutLinesPL;
namespace VISU{
class CutLines_i : public virtual POA_VISU::CutLines,
- public virtual ScalarMap_i
+ public virtual PrsMerger_i
{
static int myNbPresent;
CutLines_i();
CutLines_i(const CutLines_i&);
public:
- typedef ScalarMap_i TSuperClass;
+ typedef PrsMerger_i TSuperClass;
explicit
CutLines_i(Result_i* theResult,
int VISU::CutPlanes_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration, int isMemoryCheck)
{
- return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
+ return TSuperClass::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
}
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy),
myCutPlanesPL(NULL)
{}
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject),
myCutPlanesPL(NULL)
{
}
VISU::Storable* VISU::CutPlanes_i::Create(const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration)
{
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
}
void VISU::CutPlanes_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
+ TSuperClass::ToStream(theStr);
Storable::DataToStream( theStr, "myNbPlanes", int(GetNbPlanes()));
Storable::DataToStream( theStr, "myDisplacement", GetDisplacement());
if(!myPipeLine) myPipeLine = VISU_CutPlanesPL::New();
myCutPlanesPL = dynamic_cast<VISU_CutPlanesPL*>(myPipeLine);
- ScalarMap_i::DoHook();
+ TSuperClass::DoHook();
}
VISU_Actor*
VISU::CutPlanes_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
{
- if(VISU_Actor* anActor = ScalarMap_i::CreateActor(theIO)){
+ if(VISU_Actor* anActor = TSuperClass::CreateActor(theIO)){
anActor->SetVTKMapping(true);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU" , "cut_planes_represent", 1);
#ifndef VISU_CutPlanes_i_HeaderFile
#define VISU_CutPlanes_i_HeaderFile
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_PrsMerger_i.hh"
class VISU_CutPlanesPL;
namespace VISU{
class CutPlanes_i : public virtual POA_VISU::CutPlanes,
- public virtual ScalarMap_i
+ public virtual PrsMerger_i
{
static int myNbPresent;
CutPlanes_i();
CutPlanes_i(const CutPlanes_i&);
public:
- typedef ScalarMap_i TSuperClass;
+ typedef PrsMerger_i TSuperClass;
explicit
CutPlanes_i(Result_i* theResult,
const char* theFieldName, int theIteration, int isMemoryCheck)
{
try{
- if(!VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck)) return 0;
+ if(!TSuperClass::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck)) return 0;
const VISU::PField aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName);
return aField->myNbComp > 1;
}catch(std::exception& exc){
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy),
myDeformedShapePL(NULL)
{
if(MYDEBUG) MESSAGE("DeformedShape_i::DeformedShape_i");
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject),
myDeformedShapePL(NULL)
{
if(MYDEBUG) MESSAGE("DeformedShape_i::DeformedShape_i");
{
myIsColored = false;
myColor.R = myColor.G = myColor.B = 0.5;
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
}
void VISU::DeformedShape_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
+ TSuperClass::ToStream(theStr);
Storable::DataToStream( theStr, "myFactor", GetScale() );
myDeformedShapePL = dynamic_cast<VISU_DeformedShapePL*>(myPipeLine);
myPipeLine->GetMapper()->SetScalarVisibility(IsColored());
- ScalarMap_i::DoHook();
+ TSuperClass::DoHook();
}
VISU::DeformedShape_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO, bool toSupressShrinking)
{
- VISU_Actor* anActor = VISU::ScalarMap_i::CreateActor(theIO, true);
+ VISU_Actor* anActor = TSuperClass::CreateActor(theIO, true);
anActor->SetVTKMapping(false);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU", "deformed_shape_represent", 1);
myPipeLine->GetMapper()->SetScalarVisibility(0);
anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
}
- VISU::ScalarMap_i::UpdateActor(theActor);
+ TSuperClass::UpdateActor(theActor);
}
}
#ifndef VISU_DeformedShape_i_HeaderFile
#define VISU_DeformedShape_i_HeaderFile
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_PrsMerger_i.hh"
class VISU_DeformedShapePL;
namespace VISU{
class DeformedShape_i : public virtual POA_VISU::DeformedShape,
- public virtual ScalarMap_i
+ public virtual PrsMerger_i
{
static int myNbPresent;
DeformedShape_i();
DeformedShape_i(const DeformedShape_i&);
public:
- typedef ScalarMap_i TSuperClass;
+ typedef PrsMerger_i TSuperClass;
explicit
DeformedShape_i(Result_i* theResult,
int VISU::IsoSurfaces_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration, int isMemoryCheck)
{
- return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
+ return TSuperClass::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
}
int VISU::IsoSurfaces_i::myNbPresent = 0;
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy),
myIsoSurfacesPL(NULL)
{}
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject),
myIsoSurfacesPL(NULL)
{
}
VISU::Storable* VISU::IsoSurfaces_i::Create(const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration)
{
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
}
}
void VISU::IsoSurfaces_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
+ TSuperClass::ToStream(theStr);
Storable::DataToStream( theStr, "myNbSurface", int(GetNbSurfaces()) );
Storable::DataToStream( theStr, "myRange[0]", GetSubMin() );
if(!myPipeLine) myPipeLine = VISU_IsoSurfacesPL::New();
myIsoSurfacesPL = dynamic_cast<VISU_IsoSurfacesPL*>(myPipeLine);
- ScalarMap_i::DoHook();
+ TSuperClass::DoHook();
}
VISU::IsoSurfaces_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
{
- if(VISU_Actor* anActor = ScalarMap_i::CreateActor(theIO)){
+ if(VISU_Actor* anActor = TSuperClass::CreateActor(theIO)){
anActor->SetVTKMapping(true);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU" , "iso_surfaces_represent", 2);
#ifndef VISU_IsoSurfaces_i_HeaderFile
#define VISU_IsoSurfaces_i_HeaderFile
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_PrsMerger_i.hh"
class VISU_IsoSurfacesPL;
namespace VISU{
class IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
- public virtual ScalarMap_i
+ public virtual PrsMerger_i
{
static int myNbPresent;
IsoSurfaces_i();
IsoSurfaces_i(const IsoSurfaces_i&);
public:
- typedef ScalarMap_i TSuperClass;
+ typedef PrsMerger_i TSuperClass;
explicit
IsoSurfaces_i(Result_i* theResult,
int VISU::Plot3D_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration, int isMemoryCheck)
{
- return VISU::ScalarMap_i::IsPossible
+ return TSuperClass::IsPossible
(theResult,theMeshName,theEntity,theFieldName,theIteration,isMemoryCheck);
}
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy),
myPlot3DPL(NULL)
{}
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject),
myPlot3DPL(NULL)
{}
VISU::Storable* VISU::Plot3D_i::Create (const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, int theIteration)
{
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+ return TSuperClass::Create(theMeshName,theEntity,theFieldName,theIteration);
}
VISU::Storable* VISU::Plot3D_i::Restore (const Storable::TRestoringMap& theMap)
void VISU::Plot3D_i::ToStream (std::ostringstream& theStr)
{
- ScalarMap_i::ToStream(theStr);
+ TSuperClass::ToStream(theStr);
Storable::DataToStream(theStr, "myBasePlane", int(GetOrientationType()));
Storable::DataToStream(theStr, "aRot[0]", GetRotateX());
if (!myPipeLine) myPipeLine = VISU_Plot3DPL::New();
myPlot3DPL = dynamic_cast<VISU_Plot3DPL*>(myPipeLine);
- ScalarMap_i::DoHook();
+ TSuperClass::DoHook();
}
VISU_Actor*
VISU::Plot3D_i
::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
{
- if(VISU_Actor* anActor = ScalarMap_i::CreateActor(theIO)){
+ if(VISU_Actor* anActor = TSuperClass::CreateActor(theIO)){
anActor->SetVTKMapping(true);
SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
int aDispMode = aResourceMgr->integerValue("VISU", "plot3d_represent", 2);
#ifndef VISU_Plot3D_i_HeaderFile
#define VISU_Plot3D_i_HeaderFile
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_PrsMerger_i.hh"
class VISU_Plot3DPL;
namespace VISU {
class Plot3D_i : public virtual POA_VISU::Plot3D,
- public virtual ScalarMap_i
+ public virtual PrsMerger_i
{
static int myNbPresent;
Plot3D_i();
Plot3D_i(const Plot3D_i&);
public:
- typedef ScalarMap_i TSuperClass;
+ typedef PrsMerger_i TSuperClass;
explicit
Plot3D_i (Result_i* theResult, bool theAddToStudy = true);
#include "VISU_ScalarMapOnDeformedShapePL.hxx"
#include "VISU_Result_i.hh"
-#include "VISU_ScalarMap_i.hh"
#include "VISU_ScalarMapOnDeformedShape_i.hh"
#include "VISU_Convertor.hxx"
#include "VISU_ScalarMapAct.h"
{
bool aResult = false;
try{
- aResult = VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,false);
+ aResult = TSuperClass::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,false);
if(isMemoryCheck && aResult){
const VISU::PField aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName);
if(aField->myNbComp <= 1)
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ TSuperClass(theResult,theAddToStudy),
myScalarMapOnDeformedShapePL(NULL),
myScalarIteration(1)
{
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ TSuperClass(theResult,theSObject),
myScalarMapOnDeformedShapePL(NULL),
myScalarIteration(1)
{
#ifndef VISU_ScalarMapOnDeformedShape_i_HeaderFile
#define VISU_ScalarMapOnDeformedShape_i_HeaderFile
-#include "VISU_ScalarMap_i.hh"
+#include "VISU_PrsMerger_i.hh"
class VISU_ScalarMapOnDeformedShapePL;
//! Class of Scalar Map on Deformed Shape presentation.
class ScalarMapOnDeformedShape_i : public virtual POA_VISU::ScalarMapOnDeformedShape,
- public virtual ScalarMap_i
+ public virtual PrsMerger_i
{
static int myNbPresent;
ScalarMapOnDeformedShape_i();
public:
- typedef ScalarMap_i TSuperClass;
+ typedef PrsMerger_i TSuperClass;
explicit
ScalarMapOnDeformedShape_i(Result_i* theResult,
const char* theFieldName, int theIteration, int isMemoryCheck)
{
try{
- if(!VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,false))
+ if(!TSuperClass::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration,false))
return 0;
VISU::PIDMapper anIDMapper =
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ PrsMerger_i(theResult,theAddToStudy),
DeformedShape_i(theResult,theAddToStudy),
myStreamLinesPL(NULL),
myAppendFilter(vtkAppendFilter::New())
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ PrsMerger_i(theResult,theSObject),
DeformedShape_i(theResult,theSObject),
myStreamLinesPL(NULL),
myAppendFilter(vtkAppendFilter::New())
Prs3d_i(theResult,theAddToStudy),
ColoredPrs3d_i(theResult,theAddToStudy),
ScalarMap_i(theResult,theAddToStudy),
+ PrsMerger_i(theResult,theAddToStudy),
DeformedShape_i(theResult,theAddToStudy),
myVectorsPL(NULL)
{
Prs3d_i(theResult,theSObject),
ColoredPrs3d_i(theResult,theSObject),
ScalarMap_i(theResult,theSObject),
+ PrsMerger_i(theResult,theSObject),
DeformedShape_i(theResult,theSObject),
myVectorsPL(NULL)
{