-// VISU OBJECT : interactive object for VISU entities implementation
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-//
-//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
+// VISU OBJECT : interactive object for VISU entities implementation
// File: VISU_GaussPoints.cxx
// Author: Alexey PETROV
// Module : VISU
-
-
+//
#include "VISU_GaussPointsPL.hxx"
+#include "VISU_PointSpriteMapperHolder.hxx"
+#include "VISU_OpenGLPointSpriteMapper.hxx"
#include "VISU_DeformedShapePL.hxx"
+#include "VISU_FieldTransform.hxx"
+#include "VISU_LookupTable.hxx"
+
#include "VISU_PipeLineUtils.hxx"
-#include "SALOME_ExtractGeometry.h"
-#include "VISU_DeformedShapePL.hxx"
-#include "VISU_OpenGLPointSpriteMapper.hxx"
-#include "VTKViewer_PassThroughFilter.h"
+#include "VISU_AppendFilter.hxx"
+#include "VISU_GaussMergeFilter.hxx"
#include <vtkPointSource.h>
#include <vtkElevationFilter.h>
#include <vtkWarpVector.h>
#include <vtkGlyph3D.h>
#include <vtkSphereSource.h>
+#include <vtkPassThroughFilter.h>
//----------------------------------------------------------------------------
vtkStandardNewMacro(VISU_GaussPointsPL);
//----------------------------------------------------------------------------
VISU_GaussPointsPL
::VISU_GaussPointsPL():
- myIsDeformed(false),
myScaleFactor(0.0),
- myResolution( 8 ),
- myMagnificationIncrement(2)
+ myMagnificationIncrement(2),
+ myAppendFilter(VISU_AppendFilter::New()),
+ myMergeFilter(VISU_GaussMergeFilter::New())
{
- myExtractGeometry->SetExtractInside(0);
-
- myPSMapper = VISU_OpenGLPointSpriteMapper::New();
- myPSMapper->SetColorModeToMapScalars();
- myPSMapper->ScalarVisibilityOn();
-
- myGeomFilter = vtkGeometryFilter::New();
+ SetIsShrinkable(false);
+ SetIsFeatureEdgesAllowed(false);
myWarpVector = vtkWarpVector::New();
- myCellDataToPointData = vtkCellDataToPointData::New();
- myCellDataToPointData->SetPassCellData(true);
myGlyph = vtkGlyph3D::New();
myGlyph->SetScaleModeToScaleByScalar();
myGlyph->SetColorModeToColorByScalar();
myGlyph->ClampingOn();
- myExtractor->SetInput( myExtractGeometry->GetOutput() );
- myFieldTransform->SetInput( myExtractor->GetOutput() );
-
- myCellDataToPointData->SetInput( myFieldTransform->GetUnstructuredGridOutput() );
-
mySphereSource = vtkSphereSource::New();
+ mySphereSource->SetThetaResolution( 8 );
+ mySphereSource->SetPhiResolution( 8 );
myGlyph->SetSource( mySphereSource->GetOutput() );
- for(int i = 0; i < 2; i++)
- myPassFilter.push_back(VTKViewer_PassThroughFilter::New());
+ for(int i = 0; i < 3; i++)
+ myPassFilter.push_back(vtkPassThroughFilter::New());
+
+ myPrimitiveType = VISU_OpenGLPointSpriteMapper::PointSprite;
+
+ myAppendFilter->SetMergingInputs(true);
+ myAppendFilter->Delete();
+
+ myMergeFilter->SetMergingInputs(true);
+ myMergeFilter->Delete();
}
VISU_GaussPointsPL
::~VISU_GaussPointsPL()
{
- if (this->myPSMapper)
- {
- this->myPSMapper->Delete();
- this->myPSMapper = NULL;
- }
- if (this->myGeomFilter)
- {
- this->myGeomFilter->Delete();
- this->myGeomFilter = NULL;
- }
-
myWarpVector->Delete();
- myCellDataToPointData->Delete();
-
myGlyph->Delete();
mySphereSource->Delete();
- for(int i = 0; i < 2; i++)
+ for(int i = 0; i < 3; i++)
myPassFilter[i]->Delete();
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_GaussPointsPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myWarpVector->GetMTime());
+ aTime = std::max(aTime, myGlyph->GetMTime());
+ aTime = std::max(aTime, mySphereSource->GetMTime());
+ aTime = std::max(aTime, myAppendFilter->GetMTime());
+ aTime = std::max(aTime, myMergeFilter->GetMTime());
+
+ for(int i = 0; i < 3; i++)
+ aTime = std::max(aTime, myPassFilter[i]->GetMTime());
+
+ return aTime;
+}
+
+
+//----------------------------------------------------------------------------
+void
+VISU_GaussPointsPL
+::OnCreateMapperHolder()
+{
+ myPointSpriteMapperHolder = VISU_PointSpriteMapperHolder::New();
+ myPointSpriteMapperHolder->Delete();
+
+ SetMapperHolder(myPointSpriteMapperHolder.GetPointer());
+}
+
+
//----------------------------------------------------------------------------
void
-CopyGlyph( vtkGlyph3D* source, vtkGlyph3D* dest )
+VISU_GaussPointsPL
+::SetGaussPtsIDMapper(const VISU::PGaussPtsIDMapper& theIDMapper)
{
- dest->SetRange( source->GetRange() );
- dest->SetScaling( source->GetScaling() );
- dest->SetClamping( source->GetClamping() );
- dest->SetScaleMode( source->GetScaleMode() );
- dest->SetColorMode( source->GetColorMode() );
- dest->SetScaleFactor( source->GetScaleFactor() );
+ GetPointSpriteMapperHolder()->SetGaussPtsIDMapper(theIDMapper);
+}
+
+
+//----------------------------------------------------------------------------
+const VISU::PGaussPtsIDMapper&
+VISU_GaussPointsPL
+::GetGaussPtsIDMapper()
+{
+ return GetPointSpriteMapperHolder()->GetGaussPtsIDMapper();
+}
+
+
+//----------------------------------------------------------------------------
+VISU_PointSpriteMapperHolder*
+VISU_GaussPointsPL
+::GetPointSpriteMapperHolder()
+{
+ GetMapperHolder();
+
+ return myPointSpriteMapperHolder.GetPointer();
+}
+
+//----------------------------------------------------------------------------
+vtkDataSet*
+VISU_GaussPointsPL
+::GetParentMesh()
+{
+ VISU::TNamedIDMapper* aNamedIDMapper = GetGaussPtsIDMapper()->GetParent();
+ return aNamedIDMapper->GetOutput();
+}
+
+//----------------------------------------------------------------------------
+void
+CopyGlyph( vtkGlyph3D* theSource, vtkGlyph3D* theDestination )
+{
+ vtkFloatingPointType* aSourceRange = theSource->GetRange();
+ vtkFloatingPointType* aDestinationRange = theDestination->GetRange();
+ if(!VISU::CheckIsSameRange(aDestinationRange, aSourceRange))
+ theDestination->SetRange( aSourceRange );
+
+ theDestination->SetScaling( theSource->GetScaling() );
+ theDestination->SetClamping( theSource->GetClamping() );
+ theDestination->SetScaleMode( theSource->GetScaleMode() );
+ theDestination->SetColorMode( theSource->GetColorMode() );
+ theDestination->SetScaleFactor( theSource->GetScaleFactor() );
}
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::ShallowCopy(VISU_PipeLine *thePipeLine)
+::DoShallowCopy(VISU_PipeLine *thePipeLine,
+ bool theIsCopyInput)
{
- if(VISU_GaussPointsPL *aPipeLine = dynamic_cast<VISU_GaussPointsPL*>(thePipeLine)){
- // To restore mapper input from pipeline
- vtkPolyData* aDatsSet = myPSMapper->GetInput();
- myPSMapper->ShallowCopy(aPipeLine->GetPSMapper());
- myPSMapper->SetInput(aDatsSet);
+ Superclass::DoShallowCopy(thePipeLine, theIsCopyInput);
+ VISU_MergedPL::DoShallowCopy(thePipeLine, theIsCopyInput);
+ if(VISU_GaussPointsPL *aPipeLine = dynamic_cast<VISU_GaussPointsPL*>(thePipeLine)){
SetPrimitiveType(aPipeLine->GetPrimitiveType());
SetBicolor(aPipeLine->GetBicolor());
SetClamp(aPipeLine->GetClamp());
SetIsDeformed( aPipeLine->GetIsDeformed() );
SetScale( aPipeLine->GetScale() );
- mySphereSource->SetRadius( aPipeLine->mySphereSource->GetRadius() );
+ vtkFloatingPointType aRadius = aPipeLine->mySphereSource->GetRadius();
+ if(!VISU::CheckIsSameValue(mySphereSource->GetRadius(), aRadius))
+ mySphereSource->SetRadius( aRadius );
+
CopyGlyph( aPipeLine->myGlyph, this->myGlyph );
}
- Superclass::ShallowCopy(thePipeLine);
}
//----------------------------------------------------------------------------
-VISU_PipeLine::TMapper*
-VISU_GaussPointsPL
-::GetMapper()
-{
- return GetPSMapper();
-}
-
VISU_OpenGLPointSpriteMapper*
VISU_GaussPointsPL
-::GetPSMapper()
+::GetPointSpriteMapper()
{
- if(GetInput()){
- if(!myPSMapper->GetInput()){
- GetInput2()->Update();
- Build();
- Init();
- }
- myPSMapper->Update();
- }
- return myPSMapper;
+ return GetPointSpriteMapperHolder()->GetPointSpriteMapper();
}
-vtkDataSet*
+
+//----------------------------------------------------------------------------
+vtkPolyData*
VISU_GaussPointsPL
::GetPickableDataSet()
{
- return myGeomFilter->GetOutput();
+ return myPassFilter[1]->GetPolyDataOutput();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
{
Superclass::Init();
+ //SetExtractInside(false);
+
vtkDataSet* aDataSet = GetParentMesh();
- float aScaleFactor = VISU_DeformedShapePL::GetScaleFactor( aDataSet );
+ vtkFloatingPointType aScaleFactor = VISU_DeformedShapePL::GetScaleFactor( aDataSet );
- float* aScalarRange = GetScalarRange();
+ vtkFloatingPointType* aScalarRange = GetScalarRange();
static double EPS = 1.0 / VTK_LARGE_FLOAT;
if(fabs(aScalarRange[1]) > EPS)
SetScale( aScaleFactor / aScalarRange[1] );
else
SetScale(0.0);
-
- // Deformed Shape
- myPassFilter[0]->SetInput(myCellDataToPointData->GetUnstructuredGridOutput());
-
- myGeomFilter->SetInput( myPassFilter[0]->GetOutput() );
-
- // Geometrical Sphere
- myPassFilter[1]->SetInput(myGeomFilter->GetOutput());
-
- myPSMapper->SetInput( myPassFilter[1]->GetPolyDataOutput() );
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::Build()
{
+ Superclass::Build();
+
+ SetSourceGeometry();
+
+ vtkDataSet* aDataSet = GetFieldTransformFilter()->GetOutput();
+
+ myMergeFilter->SetGeometry(myAppendFilter->GetOutput());
+
+ myMergeFilter->SetScalars(aDataSet);
+ myMergeFilter->SetVectors(aDataSet);
+
+ myMergeFilter->RemoveFields();
+ myMergeFilter->AddField("VISU_FIELD", aDataSet);
+ myMergeFilter->AddField("VISU_POINTS_MAPPER", aDataSet);
+ myMergeFilter->AddField("VISU_INPUTS_MAPPER", aDataSet);
+ myMergeFilter->AddField("VISU_CELLS_MAPPER", aDataSet);
+
+ myMergeFilter->SetGaussPtsIDMapper(GetGaussPtsIDMapper());
+
+ myPassFilter[0]->SetInput(InsertCustomPL());
+
+ myPassFilter[1]->SetInput(myPassFilter[0]->GetOutput());
+
+ // Geometrical Sphere
+ myPassFilter[2]->SetInput(myPassFilter[1]->GetOutput());
+
+ GetPointSpriteMapper()->SetInput( myPassFilter[2]->GetPolyDataOutput() );
+
+ // Update according the current state
+ SetIsDeformed(GetIsDeformed());
+
+ SetPrimitiveType(GetPrimitiveType());
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::Update()
{
- //cout << "VISU_GaussPointsPL::Update()" << endl;
- float* aScalarRange = GetScalarRange();
- mySourceScalarRange[0] = aScalarRange[0];
- mySourceScalarRange[1] = aScalarRange[1];
- myDeltaScalarRange = aScalarRange[1] - aScalarRange[0];
+ if(IsExternalGeometryUsed() || GetNumberOfGeometry() > 1 ){
+ myMergeFilter->Update();
+ myPassFilter[0]->SetInput(myMergeFilter->GetOutput());
+ }
+ else{
+ myPassFilter[0]->SetInput(GetFieldTransformFilter()->GetOutput());
+ }
SetAverageCellSize( VISU_DeformedShapePL::GetScaleFactor( GetParentMesh() ) );
- vtkMapper* aMapper = GetMapper();
- vtkDataSet* aDataSet = aMapper->GetInput();
- vtkCellData* aCellData = aDataSet->GetCellData();
- myScalarArray = aCellData->GetScalars();
+ this->UpdateGlyph();
- myPSMapper->SetLookupTable( myMapperTable );
- myPSMapper->SetScalarRange( aScalarRange );
+ Superclass::Update();
+
+}
- this->UpdateGlyph();
- VISU_ScalarMapPL::Update();
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_GaussPointsPL
+::GetMemorySize()
+{
+ unsigned long int aSize = Superclass::GetMemorySize();
+
+ if(GetIsDeformed())
+ if(vtkDataSet* aDataSet = myWarpVector->GetOutput())
+ aSize += aDataSet->GetActualMemorySize() * 1024;
+
+ if(GetPrimitiveType() == VISU_OpenGLPointSpriteMapper::GeomSphere)
+ if(vtkDataSet* aDataSet = myGlyph->GetOutput())
+ aSize += aDataSet->GetActualMemorySize() * 1024;
+
+ return aSize;
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::UpdateGlyph()
{
- //cout << "VISU_GaussPointsPL::UpdateGlyph()" << endl;
-
- float* aScalarRange = GetScalarRange();
+ vtkFloatingPointType* aScalarRange = GetScalarRange();
- if( myPSMapper->GetPointSpriteMode() == 0 ) // Results
+ if( GetPointSpriteMapper()->GetPointSpriteMode() == 0 ) // Results
{
- //cout << "Results" << endl;
myGlyph->ClampingOn();
myGlyph->SetScaleModeToScaleByScalar();
myGlyph->SetColorModeToColorByScalar();
- float aRange = 0;
- float aMinSize = GetMinSize();
- float aMaxSize = GetMaxSize();
- if( fabs( aMaxSize - aMinSize ) > 0.0001 )
- aRange = ( aScalarRange[1] - aScalarRange[0] ) / ( aMaxSize - aMinSize );
- float aMinRange = aScalarRange[0] - aMinSize * aRange;
- float aMaxRange = aMinRange + aRange;
-
- myGlyph->SetRange( aMinRange, aMaxRange );
- myGlyph->SetScaleFactor( 1.0 );
+ vtkFloatingPointType aScaleFactor = 0.0;
+ vtkFloatingPointType aMinSize = GetMinSize();
+ vtkFloatingPointType aMaxSize = GetMaxSize();
+ if(!VISU::CheckIsSameValue(aMaxSize, aMinSize))
+ aScaleFactor = ( aScalarRange[1] - aScalarRange[0] ) / ( aMaxSize - aMinSize );
+
+ vtkFloatingPointType aMinRange = aScalarRange[0] - aMinSize * aScaleFactor;
+ vtkFloatingPointType aMaxRange = aMinRange + aScaleFactor;
+ vtkFloatingPointType aRange[2] = {aMinRange, aMaxRange};
+
+ if(!VISU::CheckIsSameRange(myGlyph->GetRange(), aRange))
+ myGlyph->SetRange( aRange );
+
+ if(!VISU::CheckIsSameValue(myGlyph->GetScaleFactor(), 1.0))
+ myGlyph->SetScaleFactor( 1.0 );
}
- else if( myPSMapper->GetPointSpriteMode() == 1 ) // Geometry
+ else if( GetPointSpriteMapper()->GetPointSpriteMode() == 1 ) // Geometry
{
- //cout << "Geometry" << endl;
myGlyph->ClampingOff();
myGlyph->SetScaleModeToDataScalingOff();
myGlyph->SetColorModeToColorByScale();
- myGlyph->SetScaleFactor( GetSize() );
+ vtkFloatingPointType aScaleFactor = GetSize();
+ if(!VISU::CheckIsSameValue(myGlyph->GetScaleFactor(), aScaleFactor))
+ myGlyph->SetScaleFactor( aScaleFactor );
}
- else if( myPSMapper->GetPointSpriteMode() == 2 ) // Outside
+ else if( GetPointSpriteMapper()->GetPointSpriteMode() == 2 ) // Outside
{
- //cout << "Outside" << endl;
myGlyph->ClampingOff();
myGlyph->SetScaleModeToDataScalingOff();
myGlyph->SetColorModeToColorByScalar();
- myGlyph->SetScaleFactor( GetSize() );
+ vtkFloatingPointType aScaleFactor = GetSize();
+ if(!VISU::CheckIsSameValue(myGlyph->GetScaleFactor(), aScaleFactor))
+ myGlyph->SetScaleFactor( aScaleFactor );
}
- mySphereSource->SetRadius( GetMagnification() * GetAverageCellSize() / 2. );
+ vtkFloatingPointType aRadius = GetMagnification() * GetAverageCellSize() / 2.0;
+ if(!VISU::CheckIsSameValue(mySphereSource->GetRadius(), aRadius))
+ mySphereSource->SetRadius( aRadius );
}
+
//----------------------------------------------------------------------------
VISU::TGaussPointID
VISU_GaussPointsPL
-::GetObjID(vtkIdType theID) const
+::GetObjID(vtkIdType theID)
{
- return myGaussPtsIDMapper->GetObjID(theID);
+ return GetGaussPtsIDMapper()->GetObjID(theID);
}
-float*
-VISU_GaussPointsPL
-::GetNodeCoord(int theObjID)
-{
- vtkIdType anID = GetNodeVTKID(theObjID);
- vtkDataSet* aDataSet = myGeomFilter->GetInput();
- return aDataSet->GetPoint(anID);
-}
-
-void
-VISU_GaussPointsPL
-::SetGaussPtsIDMapper(const VISU::PGaussPtsIDMapper& theGaussPtsIDMapper)
-{
- myGaussPtsIDMapper = theGaussPtsIDMapper;
- SetIDMapper(myGaussPtsIDMapper);
-}
-
-const VISU::PGaussPtsIDMapper&
-VISU_GaussPointsPL
-::GetGaussPtsIDMapper() const
-{
- return myGaussPtsIDMapper;
-}
-
-VISU::TVTKOutput*
-VISU_GaussPointsPL
-::GetParentMesh() const
-{
- VISU::TNamedIDMapper* aNamedIDMapper = myGaussPtsIDMapper->GetParent();
- return aNamedIDMapper->GetVTKOutput();
-}
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::SetIsDeformed( bool theIsDeformed )
{
- if( theIsDeformed )
- {
- myWarpVector->SetInput( myCellDataToPointData->GetUnstructuredGridOutput() );
- myPassFilter[0]->SetInput(myWarpVector->GetOutput());
- }
- else
- myPassFilter[0]->SetInput(myCellDataToPointData->GetUnstructuredGridOutput());
-
- myIsDeformed = theIsDeformed;
-
- Modified();
+ if(theIsDeformed){
+ myWarpVector->SetInput( myPassFilter[0]->GetPolyDataOutput() );
+ myPassFilter[1]->SetInput(myWarpVector->GetOutput());
+ }else
+ myPassFilter[1]->SetInput(myPassFilter[0]->GetOutput());
}
//----------------------------------------------------------------------------
bool
VISU_GaussPointsPL
-::GetIsDeformed() const
+::GetIsDeformed()
{
- return myIsDeformed;
+ return myPassFilter[1]->GetInput() != myPassFilter[0]->GetOutput();
}
//----------------------------------------------------------------------------
if(GetBicolor() == theBicolor)
return;
- myMapperTable->SetBicolor( theBicolor );
- myBarTable->SetBicolor( theBicolor );
-
- Modified();
+ GetMapperTable()->SetBicolor( theBicolor );
+ GetBarTable()->SetBicolor( theBicolor );
}
//----------------------------------------------------------------------------
VISU_GaussPointsPL
::GetBicolor()
{
- return myMapperTable->GetBicolor();
+ return GetMapperTable()->GetBicolor();
}
//----------------------------------------------------------------------------
VISU_GaussPointsPL
::SetIsColored(bool theIsColored)
{
- myPSMapper->SetPointSpriteMode( theIsColored ? 0 : 1 ); // Results / Geometry
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteMode( theIsColored ? 0 : 1 ); // Results / Geometry
+}
+
+//----------------------------------------------------------------------------
+bool
+VISU_GaussPointsPL
+::GetIsColored()
+{
+ return GetPointSpriteMapper()->GetPointSpriteMode() == 0;
}
//----------------------------------------------------------------------------
{
if( thePrimitiveType == VISU_OpenGLPointSpriteMapper::GeomSphere )
{
- myGlyph->SetInput( myGeomFilter->GetOutput() );
- myPassFilter[1]->SetInput(myGlyph->GetOutput());
+ myGlyph->SetInput( myPassFilter[1]->GetOutput() );
+ myPassFilter[2]->SetInput(myGlyph->GetOutput());
}
else
- myPassFilter[1]->SetInput(myGeomFilter->GetOutput());
-
- myPSMapper->SetPrimitiveType( thePrimitiveType );
+ myPassFilter[2]->SetInput(myPassFilter[1]->GetOutput());
- Modified();
+ GetPointSpriteMapper()->SetPrimitiveType( thePrimitiveType );
+
+ myPrimitiveType = thePrimitiveType;
}
+
//----------------------------------------------------------------------------
int
VISU_GaussPointsPL
::GetPrimitiveType()
-{
- return myPSMapper->GetPrimitiveType();
+{
+ return myPrimitiveType;
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetMaximumSupportedSize()
{
- return myPSMapper->GetMaximumSupportedSize();
+ return GetPointSpriteMapper()->GetMaximumSupportedSize();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetClamp(float theClamp)
+::SetClamp(vtkFloatingPointType theClamp)
{
- myPSMapper->SetPointSpriteClamp( theClamp );
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteClamp( theClamp );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetClamp()
{
- return myPSMapper->GetPointSpriteClamp();
+ return GetPointSpriteMapper()->GetPointSpriteClamp();
}
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetSize(float theSize)
+::SetSize(vtkFloatingPointType theSize)
{
- myPSMapper->SetPointSpriteSize( theSize );
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteSize( theSize );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetSize()
{
- return myPSMapper->GetPointSpriteSize();
+ return GetPointSpriteMapper()->GetPointSpriteSize();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetMinSize(float theMinSize)
+::SetMinSize(vtkFloatingPointType theMinSize)
{
- myPSMapper->SetPointSpriteMinSize( theMinSize );
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteMinSize( theMinSize );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetMinSize()
{
- return myPSMapper->GetPointSpriteMinSize();
+ return GetPointSpriteMapper()->GetPointSpriteMinSize();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetMaxSize(float theMaxSize)
+::SetMaxSize(vtkFloatingPointType theMaxSize)
{
- myPSMapper->SetPointSpriteMaxSize( theMaxSize );
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteMaxSize( theMaxSize );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetMaxSize()
{
- return myPSMapper->GetPointSpriteMaxSize();
+ return GetPointSpriteMapper()->GetPointSpriteMaxSize();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetMagnification(float theMagnification)
+::SetMagnification(vtkFloatingPointType theMagnification)
{
- myPSMapper->SetPointSpriteMagnification( theMagnification );
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteMagnification( theMagnification );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetMagnification()
{
- return myPSMapper->GetPointSpriteMagnification();
+ return GetPointSpriteMapper()->GetPointSpriteMagnification();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetMagnificationIncrement(float theIncrement)
+::SetMagnificationIncrement(vtkFloatingPointType theIncrement)
{
+ if(VISU::CheckIsSameValue(myMagnificationIncrement, theIncrement))
+ return;
+
myMagnificationIncrement = theIncrement;
+ Modified();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetAlphaThreshold(float theAlphaThreshold)
+::SetAlphaThreshold(vtkFloatingPointType theAlphaThreshold)
{
- myPSMapper->SetPointSpriteAlphaThreshold( theAlphaThreshold );
- Modified();
+ GetPointSpriteMapper()->SetPointSpriteAlphaThreshold( theAlphaThreshold );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetAlphaThreshold()
{
- return myPSMapper->GetPointSpriteAlphaThreshold();
+ return GetPointSpriteMapper()->GetPointSpriteAlphaThreshold();
}
+
+//----------------------------------------------------------------------------
+void
+VISU_GaussPointsPL
+::SetOpacity(vtkFloatingPointType theOpacity)
+{
+ GetPointSpriteMapper()->SetPointSpriteOpacity( theOpacity );
+}
+
+
+//----------------------------------------------------------------------------
+vtkFloatingPointType
+VISU_GaussPointsPL
+::GetOpacity()
+{
+ return GetPointSpriteMapper()->GetPointSpriteOpacity();
+}
+
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::SetResolution(int theResolution)
{
- myResolution = theResolution;
- mySphereSource->SetThetaResolution( myResolution );
- mySphereSource->SetPhiResolution( myResolution );
+ mySphereSource->SetThetaResolution( theResolution );
+ mySphereSource->SetPhiResolution( theResolution );
+}
+
+
+//----------------------------------------------------------------------------
+int
+VISU_GaussPointsPL
+::GetResolution()
+{
+ return mySphereSource->GetThetaResolution();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::ChangeMagnification( bool up )
{
- float anIncrement = up ? myMagnificationIncrement : 1.0 / myMagnificationIncrement;
+ vtkFloatingPointType anIncrement = up ? myMagnificationIncrement : 1.0 / myMagnificationIncrement;
SetMagnification( GetMagnification() * anIncrement );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetPointSize(vtkIdType theID, vtkDataArray* theScalarArray)
{
- float aMaxSize = GetAverageCellSize() * GetMaxSize();
- float aMinSize = GetAverageCellSize() * GetMinSize();
- float aDelta = aMaxSize - aMinSize;
- float aVal = theScalarArray->GetTuple1(theID);
+ vtkFloatingPointType aMaxSize = GetAverageCellSize() * GetMaxSize();
+ vtkFloatingPointType aMinSize = GetAverageCellSize() * GetMinSize();
+ vtkFloatingPointType aDelta = aMaxSize - aMinSize;
+ vtkFloatingPointType aVal = theScalarArray->GetTuple1(theID);
+
+ vtkFloatingPointType* aScalarRange = GetScalarRange();
+ vtkFloatingPointType aDeltaScalarRange = aScalarRange[1] - aScalarRange[0];
- return aMinSize + aDelta*(aVal - mySourceScalarRange[0])/myDeltaScalarRange;
+ // to avoid FPE if the minimum is equal to maximum
+ if( aDeltaScalarRange < 1.0 / VTK_LARGE_FLOAT )
+ return aMinSize;
+
+ return aMinSize + aDelta*(aVal - aScalarRange[0]) / aDeltaScalarRange;
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetMaxPointSize()
{
return GetAverageCellSize() * GetMaxSize();
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetPointSize(vtkIdType theID)
{
vtkMapper* aMapper = GetMapper();
vtkDataSet* aDataSet = aMapper->GetInput();
- vtkCellData* aCellData = aDataSet->GetCellData();
- vtkDataArray* aScalarArray = aCellData->GetScalars();
- return GetPointSize(theID,aScalarArray);
+ vtkPointData* aPointData = aDataSet->GetPointData();
+ vtkDataArray* aScalarArray = aPointData->GetScalars();
+ return GetPointSize(theID, aScalarArray);
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
-::SetAverageCellSize(float theAverageCellSize)
+::SetAverageCellSize(vtkFloatingPointType theAverageCellSize)
{
- myPSMapper->SetAverageCellSize( theAverageCellSize );
- Modified();
+ GetPointSpriteMapper()->SetAverageCellSize( theAverageCellSize );
}
+
//----------------------------------------------------------------------------
-float
+vtkFloatingPointType
VISU_GaussPointsPL
::GetAverageCellSize()
{
- return myPSMapper->GetAverageCellSize();
+ return GetPointSpriteMapper()->GetAverageCellSize();
}
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
::SetImageData(vtkImageData* theImageData)
{
- myPSMapper->SetImageData( theImageData );
+ GetPointSpriteMapper()->SetImageData( theImageData );
}
+
//----------------------------------------------------------------------------
vtkSmartPointer<vtkImageData>
VISU_GaussPointsPL
::MakeTexture( const char* theMainTexture,
- const char* theAlphaTexture )
+ const char* theAlphaTexture )
{
if( !theMainTexture || !theAlphaTexture )
return 0;
return aCompositeImageData;
}
-void VISU_GaussPointsPL::SetScale( float theScale )
+
+void
+VISU_GaussPointsPL
+::SetScale( vtkFloatingPointType theScale )
{
+ if(VISU::CheckIsSameValue(myWarpVector->GetScaleFactor(), theScale))
+ return;
+
myWarpVector->SetScaleFactor( theScale );
- myScaleFactor = GetScale();
- Modified();
+ myScaleFactor = theScale;
}
-float VISU_GaussPointsPL::GetScale()
+
+vtkFloatingPointType
+VISU_GaussPointsPL
+::GetScale()
{
return myWarpVector->GetScaleFactor();
}
-void VISU_GaussPointsPL::SetMapScale( float theMapScale )
+
+void
+VISU_GaussPointsPL
+::SetMapScale( vtkFloatingPointType theMapScale )
+{
+ Superclass::SetMapScale( theMapScale );
+
+ vtkFloatingPointType aMapScale = myScaleFactor * theMapScale;
+ if(VISU::CheckIsSameValue(myWarpVector->GetScaleFactor(), aMapScale))
+ return;
+
+ myWarpVector->SetScaleFactor( aMapScale );
+}
+
+void
+VISU_GaussPointsPL
+::SetSourceGeometry()
{
- VISU_ScalarMapPL::SetMapScale( theMapScale );
+ if(IsExternalGeometryUsed()){
+ ClearGeometry();
+ myAppendFilter->AddInput(GetFieldTransformFilter()->GetOutput());
+ }
+}
- myWarpVector->SetScaleFactor( myScaleFactor * theMapScale );
- Modified();
+vtkDataSet*
+VISU_GaussPointsPL
+::InsertCustomPL()
+{
+ return GetMergedInput();
+}
+
+int
+VISU_GaussPointsPL
+::AddGeometry(vtkDataSet* theGeometry, const VISU::TName& theGeomName)
+{
+ // Fix for issue 0020167 (like in VISU_ScalarMapPL)
+ if(!IsExternalGeometryUsed())
+ ClearGeometry();
+ AddGeometryName(theGeomName);
+ myAppendFilter->AddInput(theGeometry);
+ return GetNumberOfGeometry();
+}
+
+vtkDataSet*
+VISU_GaussPointsPL
+::GetGeometry(int theGeomNumber, VISU::TName& theGeomName)
+{
+ theGeomName = GetGeometryName(theGeomNumber);
+ return vtkDataSet::SafeDownCast(myAppendFilter->GetInput(theGeomNumber));
+}
+
+int
+VISU_GaussPointsPL
+::GetNumberOfGeometry()
+{
+ return myAppendFilter->GetNumberOfInputConnections(0);
+}
+
+bool
+VISU_GaussPointsPL
+::IsExternalGeometryUsed()
+{
+ return myAppendFilter->GetInput() != GetFieldTransformFilter()->GetOutput();
+}
+
+void
+VISU_GaussPointsPL
+::ClearGeometry()
+{
+ ClearGeometryNames();
+ myAppendFilter->RemoveAllInputs();
+}
+
+void
+VISU_GaussPointsPL
+::GetSourceRange(vtkFloatingPointType theRange[2])
+{
+ if(!IsExternalGeometryUsed())
+ Superclass::GetSourceRange(theRange);
+ else
+ GetMergedInput()->GetScalarRange( theRange );
+}
+
+vtkPointSet*
+VISU_GaussPointsPL
+::GetMergedInput()
+{
+ if(myMergeFilter->GetInput())
+ myMergeFilter->Update();
+ return myMergeFilter->GetOutput();
}
