src/PIPELINE/VISU_GaussPointsPL.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  VISU OBJECT : interactive object for VISU entities implementation
// File:    VISU_GaussPointsPL.hxx
// Author:  
// Module : VISU
//
#ifndef VISU_GaussPointsPL_HeaderFile
#define VISU_GaussPointsPL_HeaderFile

#include "VISUPipeline.hxx"
#include "VISU_MergedPL.hxx"
#include "VISU_ColoredPL.hxx"

#include <vector>

class VISU_OpenGLPointSpriteMapper;
class VISU_PointSpriteMapperHolder;

class vtkGeometryFilter;
class vtkGlyph3D;
class vtkSphereSource;
class vtkDataArray;
class vtkImageData;
class vtkPointSet;
class vtkPassThroughFilter;
class vtkDataSet;

class vtkWarpVector;
class SALOME_Transform;

class VISU_AppendFilter;
class VISU_GaussMergeFilter;

//----------------------------------------------------------------------------

class VISU_PIPELINE_EXPORT VISU_GaussPointsPL : public VISU_MergedPL,
                                                public VISU_ColoredPL
{
public:
  //----------------------------------------------------------------------------
  vtkTypeMacro(VISU_GaussPointsPL, VISU_ColoredPL);

  static 
  VISU_GaussPointsPL* 
  New();
  
  virtual
  unsigned long int 
  GetMTime();

  //----------------------------------------------------------------------------
  void 
  SetGaussPtsIDMapper(const VISU::PGaussPtsIDMapper& theGaussPtsIDMapper);

  const VISU::PGaussPtsIDMapper&  
  GetGaussPtsIDMapper();

  VISU_PointSpriteMapperHolder*
  GetPointSpriteMapperHolder();

  VISU_OpenGLPointSpriteMapper*
  GetPointSpriteMapper();

  vtkDataSet*  
  GetParentMesh();

  vtkPolyData*
  GetPickableDataSet();

  //----------------------------------------------------------------------------
  virtual
  void
  Init();

  virtual
  void
  Update();

  virtual
  unsigned long int
  GetMemorySize();

  //----------------------------------------------------------------------------
  void
  UpdateGlyph();

  virtual 
  VISU::TGaussPointID 
  GetObjID(vtkIdType theID);


  void
  SetBicolor(bool theBicolor);

  bool
  GetBicolor();


  void
  SetIsColored(bool theIsColored);

  bool 
  GetIsColored();

  void
  SetPrimitiveType(int thePrimitiveType);

  int
  GetPrimitiveType();

  vtkFloatingPointType 
  GetMaximumSupportedSize();

  void
  SetClamp(vtkFloatingPointType theClamp);

  vtkFloatingPointType
  GetClamp();

  void
  SetSize(vtkFloatingPointType theSize);

  vtkFloatingPointType 
  GetSize();

  void
  SetMinSize(vtkFloatingPointType theMinSize);

  vtkFloatingPointType 
  GetMinSize();

  void
  SetMaxSize(vtkFloatingPointType theMaxSize);

  vtkFloatingPointType 
  GetMaxSize();

  void
  SetMagnification(vtkFloatingPointType theMagnification);

  vtkFloatingPointType
  GetMagnification();

  void
  SetMagnificationIncrement(vtkFloatingPointType theIncrement);

  vtkFloatingPointType
  GetMagnificationIncrement() { return myMagnificationIncrement; }

  void
  SetAlphaThreshold(vtkFloatingPointType theAlphaThreshold);

  vtkFloatingPointType
  GetAlphaThreshold();

  void
  SetOpacity(vtkFloatingPointType theOpacity);

  vtkFloatingPointType
  GetOpacity();

  void
  SetResolution(int theResolution);

  int
  GetResolution();

  void
  ChangeMagnification( bool up );

  vtkFloatingPointType
  GetMaxPointSize();

  vtkFloatingPointType
  GetPointSize(vtkIdType theID);

  vtkFloatingPointType
  GetPointSize(vtkIdType theID, vtkDataArray* theScalarArray);

  void
  SetAverageCellSize(vtkFloatingPointType AverageCellSize);

  vtkFloatingPointType
  GetAverageCellSize();

  void
  SetImageData(vtkImageData* theImageData);


  static
  vtkSmartPointer<vtkImageData>
  MakeTexture( const char* theMainTexture,
               const char* theAlphaTexture );

public:
  //----------------------------------------------------------------------------
  virtual 
  void
  SetIsDeformed( bool theIsDeformed );

  virtual
  bool
  GetIsDeformed();

  virtual
  void
  SetScale( vtkFloatingPointType theScale );

  virtual
  vtkFloatingPointType 
  GetScale();

  virtual
  void
  SetMapScale( vtkFloatingPointType theMapScale = 1.0 );

public:

  virtual  
  void  
  SetSourceGeometry();

  virtual
  int
  AddGeometry(vtkDataSet* theGeometry, const VISU::TName& theGeomName);

  virtual
  vtkDataSet*
  GetGeometry(int theGeomNumber, VISU::TName& theGeomName);

  virtual
  int
  GetNumberOfGeometry();

  virtual
  bool 
  IsExternalGeometryUsed();

  virtual
  void
  ClearGeometry();

  virtual
  void
  GetSourceRange(vtkFloatingPointType theRange[2]);

  virtual 
  vtkPointSet* 
  GetMergedInput();

protected:
  //----------------------------------------------------------------------------
  VISU_GaussPointsPL();

  virtual
  ~VISU_GaussPointsPL();

  virtual
  void
  OnCreateMapperHolder();

  virtual
  void
  Build();

  virtual
  vtkDataSet* 
  InsertCustomPL();

  virtual
  void
  DoShallowCopy(VISU_PipeLine *thePipeLine,
                bool theIsCopyInput);

private:
  //----------------------------------------------------------------------------
  vtkFloatingPointType myScaleFactor;
  vtkWarpVector *myWarpVector;
  std::vector<vtkPassThroughFilter*> myPassFilter;
  vtkSmartPointer<VISU_PointSpriteMapperHolder> myPointSpriteMapperHolder;
  
  vtkGlyph3D* myGlyph;
  vtkSphereSource* mySphereSource;

  vtkFloatingPointType myMagnificationIncrement;

  int myPrimitiveType;

  vtkSmartPointer<VISU_AppendFilter>      myAppendFilter;
  vtkSmartPointer<VISU_GaussMergeFilter>  myMergeFilter;

private:
  VISU_GaussPointsPL(const VISU_GaussPointsPL&);  // Not implemented.
  void operator=(const VISU_GaussPointsPL&);  // Not implemented.
};
  
#endif