G4VtkViewer Class Reference

#include <G4VtkViewer.hh>

Inheritance diagram for G4VtkViewer:

Public Member Functions
	G4VtkViewer (G4VSceneHandler &, const G4String &name)
void	Initialise ()
virtual	~G4VtkViewer ()
void	SetView ()
void	ClearView ()
void	DrawView ()
void	ShowView ()
void	FinishView ()
void	DrawViewHUD ()
void	DrawShadows ()
void	ExportScreenShot (G4String, G4String)
void	ExportOBJScene (G4String)
void	ExportVRMLScene (G4String)
void	ExportVTPScene (G4String)
void	ExportView ()
void	SetGeant4View ()
Public Member Functions inherited from G4VViewer
	G4VViewer (G4VSceneHandler &, G4int id, const G4String &name="")
virtual	~G4VViewer ()
virtual void	Initialise ()
virtual void	ResetView ()
virtual void	SetView ()=0
virtual void	ClearView ()=0
virtual void	DrawView ()=0
void	RefreshView ()
virtual void	ShowView ()
virtual void	FinishView ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
const G4String &	GetName () const
const G4String &	GetShortName () const
void	SetName (const G4String &)
G4int	GetViewId () const
G4VSceneHandler *	GetSceneHandler () const
const G4ViewParameters &	GetViewParameters () const
const G4ViewParameters &	GetDefaultViewParameters () const
G4double	GetKernelVisitElapsedTimeSeconds () const
virtual const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const
void	SetViewParameters (const G4ViewParameters &vp)
void	SetDefaultViewParameters (const G4ViewParameters &vp)
const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const
void	SetNeedKernelVisit (G4bool need)
void	NeedKernelVisit ()
void	ProcessView ()

Public Attributes
vtkNew< vtkTextActor >	infoTextActor
vtkNew< vtkInfoCallback >	infoCallback
vtkNew< vtkGeant4Callback >	geant4Callback
vtkSmartPointer< vtkLight >	light
vtkNew< vtkCamera >	camera
vtkNew< vtkRenderer >	renderer
vtkRenderWindow *	_renderWindow
vtkRenderWindowInteractor *	renderWindowInteractor

Additional Inherited Members
Protected Member Functions inherited from G4VViewer
void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)
void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)
void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)
Protected Attributes inherited from G4VViewer
G4VSceneHandler &	fSceneHandler
G4int	fViewId
G4String	fName
G4String	fShortName
G4ViewParameters	fVP
G4ViewParameters	fDefaultVP
G4double	fKernelVisitElapsedTimeSeconds = 999.
G4bool	fNeedKernelVisit

Detailed Description

Definition at line 158 of file G4VtkViewer.hh.

Constructor & Destructor Documentation

G4VtkViewer()

G4VtkViewer::G4VtkViewer	(	G4VSceneHandler &	sceneHandler,
		const G4String &	name
	)

Definition at line 55 of file G4VtkViewer.cc.

  : G4VViewer(sceneHandler, sceneHandler.IncrementViewCount(), name)
{
  vtkObject::GlobalWarningDisplayOff();
 
  // Set default and current view parameters
  fVP.SetAutoRefresh(true);
  fDefaultVP.SetAutoRefresh(true);
}

~G4VtkViewer()

G4VtkViewer::~G4VtkViewer ( )

virtual

Definition at line 123 of file G4VtkViewer.cc.

{}

Member Function Documentation

ClearView()

void G4VtkViewer::ClearView ( void  )

virtual

Implements G4VViewer.

Definition at line 219 of file G4VtkViewer.cc.

                            {
  vtkActorCollection *actors = renderer->GetActors();
  vtkActor *actor = actors->GetLastActor();
 
  while(actor) {
#ifdef G4VTKDEBUG
    G4cout << "G4VtkViewer::ClearView() remove actor " << actor << G4endl;
#endif
    renderer->RemoveActor(actor);
    actor = actors->GetLastActor();
  }
 
  vtkPropCollection *props = renderer->GetViewProps();
  vtkProp *prop  = props->GetLastProp();
 
  while(prop) {
#ifdef G4VTKDEBUG
    G4cout << "G4VtkViewer::ClearView() remove prop " << prop << G4endl;
#endif
    renderer->RemoveViewProp(prop);
    prop = props->GetLastProp();
  }
}

DrawShadows()

void G4VtkViewer::DrawShadows

(

)

Definition at line 276 of file G4VtkViewer.cc.

{
  _renderWindow->SetMultiSamples(0);
 
  vtkNew<vtkShadowMapPass> shadows;
  vtkNew<vtkSequencePass> seq;
 
  vtkNew<vtkRenderPassCollection> passes;
  passes->AddItem(shadows->GetShadowMapBakerPass());
  passes->AddItem(shadows);
  seq->SetPasses(passes);
 
  vtkNew<vtkCameraPass> cameraP;
  cameraP->SetDelegatePass(seq);
 
  // tell the renderer to use our render pass pipeline
  vtkOpenGLRenderer* glrenderer = dynamic_cast<vtkOpenGLRenderer*>(renderer.GetPointer());
  glrenderer->SetPass(cameraP);
}

DrawView()

void G4VtkViewer::DrawView ( )

virtual

Implements G4VViewer.

Definition at line 243 of file G4VtkViewer.cc.

                           {
  // First, a view should decide when to re-visit the G4 kernel.
  // Sometimes it might not be necessary, e.g., if the scene is stored
  // in a graphical database (e.g., OpenGL's display lists) and only
  // the viewing angle has changed.  But graphics systems without a
  // graphical database will always need to visit the G4 kernel.
 
  NeedKernelVisit();  // Default is - always visit G4 kernel.
  // Note: this routine sets the fNeedKernelVisit flag of *all* the
  // views of the scene.
 
  ProcessView();  // The basic logic is here.
 
  // Add HUD
  DrawViewHUD();
 
  // ...before finally...
  FinishView();  // Flush streams and/or swap buffers.
}

DrawViewHUD()

void G4VtkViewer::DrawViewHUD

(

)

Definition at line 263 of file G4VtkViewer.cc.

{
  // make sure text is always visible
  G4Colour colour = fVP.GetBackgroundColour();
  infoTextActor->GetTextProperty()->SetColor(std::fmod(colour.GetRed() + 0.5, 1.0),
                                             std::fmod(colour.GetGreen() + 0.5, 1.0),
                                             std::fmod(colour.GetBlue() + 0.5, 1.0));
  infoTextActor->GetTextProperty()->SetFontSize(20);
  infoCallback->SetTextActor(infoTextActor);
  renderer->AddObserver(vtkCommand::EndEvent, infoCallback);
  renderer->AddActor(infoTextActor);
}

Referenced by DrawView().

ExportOBJScene()

void G4VtkViewer::ExportOBJScene

(

G4String

path

)

Definition at line 377 of file G4VtkViewer.cc.

{
  vtkSmartPointer<vtkRenderWindow> _rw1 = vtkSmartPointer<vtkRenderWindow>::New();
  _rw1->AddRenderer(_renderWindow->GetRenderers()->GetFirstRenderer());
  vtkSmartPointer<vtkOBJExporter> exporter = vtkSmartPointer<vtkOBJExporter>::New();
  exporter->SetRenderWindow(_rw1);
  exporter->SetFilePrefix(path.c_str());
  exporter->Write();
}

ExportScreenShot()

void G4VtkViewer::ExportScreenShot	(	G4String	path,
		G4String	format
	)

Definition at line 331 of file G4VtkViewer.cc.

{
 
  vtkImageWriter *imWriter = nullptr;
 
  if(format == "bmp") {
    imWriter = vtkBMPWriter::New();
  }
  else if (format == "jpg") {
    imWriter = vtkJPEGWriter::New();
  }
  else if (format == "pnm") {
    imWriter = vtkPNMWriter::New();
  }
  else if (format == "png") {
    imWriter = vtkPNGWriter::New();
  }
  else if (format == "tiff") {
    imWriter = vtkTIFFWriter::New();
  }
  else if (format == "ps") {
    imWriter = vtkPostScriptWriter::New();
  }
  else {
    imWriter = vtkPNGWriter::New();
  }
 
  _renderWindow->Render();
 
  vtkSmartPointer<vtkWindowToImageFilter> winToImage = vtkSmartPointer<vtkWindowToImageFilter>::New();
  winToImage->SetInput(_renderWindow);
  winToImage->SetScale(1);
  if(format == "ps")
  {
    winToImage->SetInputBufferTypeToRGB();
    winToImage->ReadFrontBufferOff();
    winToImage->Update();
  }
  else
  {winToImage->SetInputBufferTypeToRGBA();}
 
  imWriter->SetFileName((path+"."+format).c_str());
  imWriter->SetInputConnection(winToImage->GetOutputPort());
  imWriter->Write();
}

ExportView()

void G4VtkViewer::ExportView ( )

inline

Definition at line 178 of file G4VtkViewer.hh.

{};

ExportVRMLScene()

void G4VtkViewer::ExportVRMLScene

(

G4String

path

)

Definition at line 387 of file G4VtkViewer.cc.

{
  vtkSmartPointer<vtkRenderWindow> _rw1 = vtkSmartPointer<vtkRenderWindow>::New();
  _rw1->AddRenderer(_renderWindow->GetRenderers()->GetFirstRenderer());
  vtkSmartPointer<vtkVRMLExporter> exporter = vtkSmartPointer<vtkVRMLExporter>::New();
  exporter->SetRenderWindow(_rw1);
  exporter->SetFileName((path+".vrml").c_str());
  exporter->Write();
}

ExportVTPScene()

void G4VtkViewer::ExportVTPScene

(

G4String

path

)

Definition at line 397 of file G4VtkViewer.cc.

{
  vtkSmartPointer<vtkRenderWindow> _rw1 = vtkSmartPointer<vtkRenderWindow>::New();
  _rw1->AddRenderer(_renderWindow->GetRenderers()->GetFirstRenderer());
  vtkSmartPointer<vtkSingleVTPExporter> exporter = vtkSmartPointer<vtkSingleVTPExporter>::New();
  exporter->SetRenderWindow(_rw1);
  exporter->SetFileName((path+".vtp").c_str());
  exporter->Write();
}

FinishView()

void G4VtkViewer::FinishView ( void  )

virtual

Reimplemented from G4VViewer.

Definition at line 321 of file G4VtkViewer.cc.

{
  G4VtkSceneHandler& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  fVtkSceneHandler.Modified();
 
  _renderWindow->Render();
  _renderWindow->GetInteractor()->Initialize();
  _renderWindow->GetInteractor()->Start();
}

Referenced by DrawView(), and G4VtkQtViewer::FinishView().

Initialise()

void G4VtkViewer::Initialise ( )

virtual

Reimplemented from G4VViewer.

Definition at line 65 of file G4VtkViewer.cc.

{
  _renderWindow          = vtkRenderWindow::New();
  renderWindowInteractor = vtkRenderWindowInteractor::New();
 
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::G4VtkViewer" << G4endl;
  G4cout << "G4VtkViewer::G4VtkViewer> " << fVP.GetWindowSizeHintX() << " "
  << fVP.GetWindowSizeHintY() << G4endl;
  G4cout << "G4VtkViewer::G4VtkViewer> " << fVP.GetWindowLocationHintX() << " "
  << fVP.GetWindowLocationHintY() << G4endl;
#endif
 
  // Need windowSizeX/Y - obtain from _renderWindow?
  G4int screenSizeX = _renderWindow->GetScreenSize()[0];
  G4int screenSizeY = _renderWindow->GetScreenSize()[1];
  G4int positionX = fVP.GetWindowLocationHintX();
  if (fVP.IsWindowLocationHintXNegative()) {
    positionX = screenSizeX + positionX - fVP.GetWindowSizeHintX();
  }
  G4int positionY = fVP.GetWindowLocationHintY();
  if (!fVP.IsWindowLocationHintYNegative()) {
    positionY = screenSizeY + positionY - fVP.GetWindowSizeHintY();
  }
  _renderWindow->SetPosition(positionX, positionY);
#ifdef __APPLE__
  // Adjust window size for Apple to make it correspond to OpenGL.
  // Maybe it's OpenGL that shoud be adjusted.
  const G4double pixelFactor = 2.;
#else
  const G4double pixelFactor = 1.;
#endif
  _renderWindow->SetSize
  (pixelFactor*fVP.GetWindowSizeHintX(),pixelFactor*fVP.GetWindowSizeHintY());
  _renderWindow->SetWindowName("Vtk viewer");
 
  _renderWindow->AddRenderer(renderer);
  renderWindowInteractor->SetRenderWindow(_renderWindow);
 
  // TODO proper camera parameter settings
  camera->SetPosition(0, 0, 1000);
  camera->SetFocalPoint(0, 0, 0);
  renderer->SetActiveCamera(camera);
 
  //renderer->SetUseHiddenLineRemoval(1);  // TODO needs to be an option
  //renderer->SetUseShadows(1);            // TODO needs to be an option
 
  // Set callback to match VTK parameters to Geant4
  geant4Callback->SetGeant4ViewParameters(&fVP);
  renderer->AddObserver(vtkCommand::EndEvent, geant4Callback);
 
  vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
    vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
  renderWindowInteractor->SetInteractorStyle(style);
 
  // DrawShadows();
}

SetGeant4View()

void G4VtkViewer::SetGeant4View ( )

inline

Definition at line 179 of file G4VtkViewer.hh.

{};

SetView()

void G4VtkViewer::SetView ( )

virtual

Implements G4VViewer.

Definition at line 125 of file G4VtkViewer.cc.

                          {
 
  // background colour
  const G4Colour backgroundColour = fVP.GetBackgroundColour();
  renderer->SetBackground(backgroundColour.GetRed(), backgroundColour.GetGreen(), backgroundColour.GetBlue());
 
  // target and camera positions
  G4double radius = fSceneHandler.GetExtent().GetExtentRadius();
  if(radius <= 0.)
    {radius = 1.;}
  G4double cameraDistance      = fVP.GetCameraDistance(radius);
  G4Point3D viewpointDirection = fVP.GetViewpointDirection();
  G4Point3D targetPoint        = fVP.GetCurrentTargetPoint();
  G4Point3D cameraPosition =
    targetPoint + viewpointDirection.unit() * cameraDistance;
  renderer->GetActiveCamera()->SetFocalPoint(targetPoint.x(),
                                             targetPoint.y(),
                                             targetPoint.z());
  renderer->GetActiveCamera()->SetPosition(cameraPosition.x(),
                                           cameraPosition.y(),
                                           cameraPosition.z());
  renderer->GetActiveCamera()->SetParallelScale(cameraDistance);
 
  // need to set camera distance and parallel scale on first set view
  if(firstSetView)
  {
    geant4Callback->SetVtkInitialValues(cameraDistance, cameraDistance);
    firstSetView = false;
  }
 
  // projection type and view angle and zoom factor
  G4double      fieldHalfAngle = fVP.GetFieldHalfAngle();
  G4double          zoomFactor = fVP.GetZoomFactor();
  vtkCamera* activeCamera = renderer->GetActiveCamera();
  if(fieldHalfAngle == 0) {
    activeCamera->SetParallelProjection(1);
    activeCamera->SetParallelScale(activeCamera->GetParallelScale()/zoomFactor);
  }
  else {
    activeCamera->SetParallelProjection(0);
    activeCamera->SetViewAngle(2*fieldHalfAngle/M_PI*180);
    activeCamera->SetPosition(cameraPosition.x()/zoomFactor,
                                             cameraPosition.y()/zoomFactor,
                                             cameraPosition.z()/zoomFactor);
  }
 
  // camera roll
  // renderer->GetActiveCamera()->SetRoll(0);
 
  // camera up direction
  const G4Vector3D upVector = fVP.GetUpVector();
  renderer->GetActiveCamera()->SetViewUp(upVector.x(),
                                         upVector.y(),
                                         upVector.z());
 
  // Light
  const G4Vector3D lightDirection = fVP.GetLightpointDirection();
  G4bool lightsMoveWithCamera     = fVP.GetLightsMoveWithCamera();
  G4Vector3D lightPosition =
    targetPoint + lightDirection.unit() * cameraDistance;
 
  vtkLightCollection* currentLights = renderer->GetLights();
  if (currentLights->GetNumberOfItems() != 0)
  {
    auto currentLight = dynamic_cast<vtkLight*>(currentLights->GetItemAsObject(0));
    if (currentLight)
    {
      currentLight->SetPosition(lightPosition.x(),
                                lightPosition.y(),
                                lightPosition.z());
      if (lightsMoveWithCamera)
      {currentLight->SetLightTypeToCameraLight();}
      else
      {currentLight->SetLightTypeToSceneLight();}
    }
  }
 
  // Rotation style
#if 0
  G4ViewParameters::RotationStyle rotationStyle  = fVP.GetRotationStyle();
  if (rotationStyle == G4ViewParameters::RotationStyle::freeRotation) {
    vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
      vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
    _renderWindow->GetInteractor()->SetInteractorStyle(style);
  }
  else if(rotationStyle == G4ViewParameters::RotationStyle::constrainUpDirection) {
    // camera->SetViewUp(upVector.x(), upVector.y(), upVector.z());
    vtkSmartPointer<vtkInteractorStyleTerrain> style =
      vtkSmartPointer<vtkInteractorStyleTerrain>::New();
    _renderWindow->GetInteractor()->SetInteractorStyle(style);
  }
#endif
}

ShowView()

void G4VtkViewer::ShowView ( void  )

virtual

Reimplemented from G4VViewer.

Definition at line 296 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::ShowView() called." << G4endl;
  // static_cast<G4VtkSceneHandler&>(fSceneHandler).PrintStores();
#endif
 
  G4VtkSceneHandler& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  fVtkSceneHandler.Modified();
 
  infoTextActor->GetTextProperty()->SetFontSize(28);
  G4Colour colour = fVP.GetBackgroundColour();
 
  // make sure text is always visible
  infoTextActor->GetTextProperty()->SetColor(std::fmod(colour.GetRed() + 0.5, 1.0),
                                             std::fmod(colour.GetGreen() + 0.5, 1.0),
                                             std::fmod(colour.GetBlue() + 0.5, 1.0));
  infoTextActor->GetTextProperty()->SetFontSize(20);
  infoCallback->SetTextActor(infoTextActor);
  renderer->AddObserver(vtkCommand::EndEvent, infoCallback);
  geant4Callback->SetGeant4ViewParameters(&fVP);
  renderer->AddObserver(vtkCommand::EndEvent, geant4Callback);
  renderer->AddActor(infoTextActor);
}

Member Data Documentation

_renderWindow

vtkRenderWindow* G4VtkViewer::_renderWindow

Definition at line 187 of file G4VtkViewer.hh.

Referenced by DrawShadows(), ExportOBJScene(), ExportScreenShot(), ExportVRMLScene(), ExportVTPScene(), FinishView(), G4VtkQtViewer::Initialise(), Initialise(), and SetView().

camera

vtkNew<vtkCamera> G4VtkViewer::camera

Definition at line 185 of file G4VtkViewer.hh.

Referenced by Initialise().

geant4Callback

vtkNew<vtkGeant4Callback> G4VtkViewer::geant4Callback

Definition at line 183 of file G4VtkViewer.hh.

Referenced by G4VtkQtViewer::Initialise(), Initialise(), SetView(), and ShowView().

infoCallback

vtkNew<vtkInfoCallback> G4VtkViewer::infoCallback

Definition at line 182 of file G4VtkViewer.hh.

Referenced by DrawViewHUD(), and ShowView().

infoTextActor

vtkNew<vtkTextActor> G4VtkViewer::infoTextActor

Definition at line 181 of file G4VtkViewer.hh.

Referenced by DrawViewHUD(), and ShowView().

light

vtkSmartPointer<vtkLight> G4VtkViewer::light

Definition at line 184 of file G4VtkViewer.hh.

renderer

vtkNew<vtkRenderer> G4VtkViewer::renderer

Definition at line 186 of file G4VtkViewer.hh.

Referenced by G4VtkSceneHandler::AddCompound(), G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), ClearView(), DrawShadows(), DrawViewHUD(), G4VtkQtViewer::Initialise(), Initialise(), SetView(), and ShowView().

renderWindowInteractor

vtkRenderWindowInteractor* G4VtkViewer::renderWindowInteractor

Definition at line 188 of file G4VtkViewer.hh.

Referenced by G4VtkQtViewer::Initialise(), and Initialise().

---

The documentation for this class was generated from the following files:

• G4VtkViewer.hh
• G4VtkViewer.cc