VTKViewer_Actor.h

Go to the documentation of this file.

// Copyright (C) 2007-2023  CEA, EDF, 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, or (at your option) any later version.
//
// 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
//
 
//  SALOME OBJECT : implementation of interactive object visualization for OCC and VTK viewers
//  File   : SALOME_Actor.h
//  Author : Nicolas REJNERI
 
#ifndef VTKVIEVER_ACTOR_H
#define VTKVIEVER_ACTOR_H
 
#include "VTKViewer.h"
 
#include <string>
#include <vector>
#include <limits>
 
#include <NCollection_IndexedMap.hxx>
#include <NCollection_Map.hxx>
 
#include <vtkLODActor.h>
#include <vtkProperty.h>
 
class vtkCell;
class vtkPointPicker;
class vtkCellPicker;
class vtkDataSet;
class vtkCamera;
class vtkProperty;
class vtkRenderer;
class vtkPassThrough;
 
class VTKViewer_Transform;
class VTKViewer_GeometryFilter;
class VTKViewer_TransformFilter;
 
extern int VTKViewer_POINT_SIZE;
extern int VTKViewer_LINE_WIDTH;
 
namespace VTKViewer
{
  namespace Representation
  {
    typedef int Type;
    const Type Points = VTK_POINTS;
    const Type Wireframe = VTK_WIREFRAME;
    const Type Surface = VTK_SURFACE;
    const Type Insideframe = Surface + 1;
    const Type SurfaceWithEdges = Insideframe + 1;
  }
}
 
#ifdef WIN32
#pragma warning ( disable:4251 )
#endif
 
class VTKVIEWER_EXPORT VTKViewer_Actor : public vtkLODActor 
{
 public:
  static VTKViewer_Actor* New();
  
  vtkTypeMacro(VTKViewer_Actor,vtkLODActor)
 
  //----------------------------------------------------------------------------
  virtual 
  const char* 
  getName();
 
  virtual
  void
  setName(const char* theName);
 
  //----------------------------------------------------------------------------
  virtual
  void
  SetOpacity(double theOpacity);
 
  virtual
  double 
  GetOpacity();
 
  virtual
  void
  SetColor(double r,
           double g,
           double b);
 
  virtual
  void
  GetColor(double& r,
           double& g,
           double& b);
 
  virtual
  void
  SetColor(const double theRGB[3]);
 
  virtual
  void
  SetMaterial(std::vector<vtkProperty*> theProps);
 
  virtual
  vtkProperty* 
  GetFrontMaterial();
 
  virtual
  vtkProperty* 
  GetBackMaterial();
 
  //----------------------------------------------------------------------------
  // For selection mapping purpose
  virtual
  vtkIdType 
  GetNodeObjId(vtkIdType theVtkID);
 
  virtual
  double*
  GetNodeCoord(vtkIdType theObjID);
 
  virtual
  vtkIdType 
  GetNodeVtkId(vtkIdType theObjID);
 
  virtual 
  vtkIdType
  GetElemObjId(vtkIdType theVtkID);
 
  virtual
  vtkCell* 
  GetElemCell(vtkIdType theObjID);
 
  //----------------------------------------------------------------------------
  virtual
  int
  GetObjDimension( const vtkIdType theObjId );
 
  virtual
  void
  SetMapper(vtkMapper* theMapper); 
 
  virtual
  vtkDataSet* 
  GetInput(); 
 
  virtual
  void
  SetTransform(VTKViewer_Transform* theTransform); 
 
  virtual
  vtkMTimeType
  GetMTime();
 
  //----------------------------------------------------------------------------
  virtual
  void
  SetRepresentation(int theMode);
 
  virtual
  int
  GetRepresentation();
 
  virtual
  int
  getDisplayMode();
 
  virtual
  void
  setDisplayMode(int theMode);
 
  //----------------------------------------------------------------------------
 
  void
  SetInfinitive(bool theIsInfinite);
 
  virtual
  bool
  IsInfinitive();
    
  virtual
  double* 
  GetBounds();
 
  void
  GetBounds(double bounds[6]);
 
  //----------------------------------------------------------------------------
  virtual
  bool
  IsSetCamera() const;
 
  virtual
  bool
  IsResizable() const;
 
  virtual
  void
  SetSize( const double );
 
  virtual
  void 
  SetCamera( vtkCamera* );
 
  //----------------------------------------------------------------------------
  void
  SetResolveCoincidentTopology(bool theIsResolve);
 
  void
  SetPolygonOffsetParameters(double factor, 
                             double units);
 
  void
  GetPolygonOffsetParameters(double& factor, 
                             double& units);
  
  static 
  void
  GetDefaultPolygonOffsetParameters(double& factor, 
                        double& units);
 
  virtual
  void
  Render(vtkRenderer *, vtkMapper *);
 
  //----------------------------------------------------------------------------
  virtual
  double
  GetShrinkFactor();
 
  virtual
  bool
  IsShrunkable();
 
  virtual
  bool
  IsShrunk();
 
  virtual
  void
  SetShrink();
 
  virtual
  void
  UnShrink();
 
  //----------------------------------------------------------------------------
  virtual
  void
  AddToRender(vtkRenderer* theRendere); 
 
  virtual
  void
  RemoveFromRender(vtkRenderer* theRendere);
 
  virtual
  void
  GetChildActors(vtkActorCollection*);
 
  //----------------------------------------------------------------------------
  virtual
  void
  EnableSelection( bool /*enable*/ ) {}
 
  virtual
  bool
  hasHighlight(); 
 
  virtual
  bool
  isHighlighted();
 
  virtual
  bool
  isPreselected();
 
  virtual
  void
  SetPreSelected(bool thePreselect = false);
 
  //----------------------------------------------------------------------------
  virtual
  void
  highlight(bool theHighlight);  
 
  void
  SetPreviewProperty(vtkProperty* theProperty);
 
  //----------------------------------------------------------------------------
  virtual void SetQuadraticArcMode(bool theFlag);
  virtual bool GetQuadraticArcMode() const;
 
  virtual void   SetQuadraticArcAngle(double theMaxAngle);
  virtual double GetQuadraticArcAngle() const;
 
  //----------------------------------------------------------------------------
  virtual vtkDataSet* GetHighlightedDataSet();
 
 protected:
  //----------------------------------------------------------------------------
  bool myIsResolveCoincidentTopology;
  double myPolygonOffsetFactor;
  double myPolygonOffsetUnits;
 
  std::string myName;
 
  double myOpacity;
  int myDisplayMode;
  bool myIsInfinite;
 
  bool myStoreMapping;
  VTKViewer_GeometryFilter *myGeomFilter;
  VTKViewer_TransformFilter *myTransformFilter;
  std::vector<vtkPassThrough*> myPassFilter;
 
  int myRepresentation;
  vtkProperty *myProperty;
 
  void
  InitPipeLine(vtkMapper* theMapper); 
 
  VTKViewer_Actor();
  ~VTKViewer_Actor();
 
 protected:
  vtkProperty *PreviewProperty;
  bool myIsPreselected;
  bool myIsHighlighted;
};
 
struct vtkIdHasher
{
  static int HashCode(const vtkIdType theValue,  const int theUpperBound)
  {
    return static_cast<int> ((theValue & (std::numeric_limits<vtkIdType>::max)()) % theUpperBound + 1);
  }
 
  static bool IsEqual( const vtkIdType& id1, const vtkIdType& id2 )
  {
    return id1 == id2;
  }
};
 
typedef NCollection_Map< vtkIdType, vtkIdHasher > TVtkIDsMap;
typedef NCollection_IndexedMap<vtkIdType,vtkIdHasher> TIndexedMapOfVtkId;
 
#ifdef WIN32
#pragma warning ( default:4251 )
#endif
 
#endif // VTKVIEVER_ACTOR_H