G4VtkViewer Class Reference

#include <G4VtkViewer.hh>

Inheritance diagram for G4VtkViewer:

Public Member Functions
	G4VtkViewer (G4VSceneHandler &, const G4String &name)
void	Initialise () override
	~G4VtkViewer () override
void	SetView () override
void	ClearView () override
void	DrawView () override
void	ShowView () override
void	FinishView () override
void	ExportScreenShot (G4String, G4String)
void	ExportOBJScene (G4String)
void	ExportVRMLScene (G4String)
void	ExportVTPScene (G4String)
void	ExportGLTFScene (G4String)
void	ExportX3DScene (G4String)
void	ExportJSONRenderWindowScene (G4String)
void	ExportVTPCutter (G4String fileName)
void	ExportFormatStore (G4String fileName, G4String store)
void	DrawShadows ()
void	EnableShadows ()
void	DisableShadows ()
void	AddViewHUD ()
void	EnableHUD ()
void	DisableHUD ()
virtual void	AddClipperPlaneWidget (const G4Plane3D &plane)
void	EnableClipper (const G4Plane3D &plane, G4bool widget)
void	DisableClipper ()
virtual void	EnableClipperWidget ()
virtual void	DisableClipperWidget ()
virtual void	AddCutterPlaneWidget (const G4Plane3D &plane)
void	EnableCutter (const G4Plane3D &plane, G4bool bWidget)
void	DisableCutter (G4String name)
virtual void	EnableCutterWidget ()
virtual void	DisableCutterWidget ()
virtual void	AddCameraOrientationWidget ()
virtual void	EnableCameraOrientationWidget ()
virtual void	DisableCameraOrientationWidget ()
void	AddImageOverlay (const G4String &fileName, const G4double alpha, const G4double imageBottomLeft[2], const G4double worldBottomLeft[2], const G4double imageTopRight[2], const G4double worldTopRight[2], const G4double rot[3], const G4double trans[3])
void	AddGeometryOverlay (const G4String &fileName, const G4double colour[3], const G4double alpha, const G4String &representation, const G4double scale[3], const G4double rotation[3], const G4double translation[3])
void	Render ()
void	StartInteractor ()
void	Print ()
void	SetPolyhedronPipeline (const G4String &t)
virtual void	SetWidgetInteractor (vtkAbstractWidget *widget)
void	ExportView ()
void	SetGeant4View ()
Public Member Functions inherited from G4VViewer
	G4VViewer (G4VSceneHandler &, G4int id, const G4String &name="")
virtual	~G4VViewer ()
virtual void	ResetView ()
void	RefreshView ()
virtual G4bool	ReadyToDraw ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
virtual void	DoneWithMasterThread ()
virtual void	MovingToVisSubThread ()
virtual void	SwitchToVisSubThread ()
virtual void	DoneWithVisSubThread ()
virtual void	MovingToMasterThread ()
virtual void	SwitchToMasterThread ()
void	InsertModelInSceneTree (G4VModel *)
const G4SceneTreeItem &	GetSceneTree ()
G4SceneTreeItem &	AccessSceneTree ()
void	UpdateGUISceneTree ()
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
Public Attributes inherited from G4VViewer
const G4int	fMaxNTouchables = 10000
G4bool	fCurtailDescent = false

Protected Attributes
G4bool	firstSetView = true
G4bool	firstFinishView = true
G4double	cameraDistance
vtkNew< vtkImplicitPlaneRepresentation >	cutterPlaneRepresentation
vtkNew< vtkImplicitPlaneWidget2 >	cutterPlaneWidget
vtkNew< vtkImplicitPlaneRepresentation >	clipperPlaneRepresentation
vtkNew< vtkImplicitPlaneWidget2 >	clipperPlaneWidget
vtkNew< vtkCameraOrientationWidget >	camOrientWidget
bool	bCutter = false
bool	bClipper = false
bool	bHud = false
bool	bOrientation = false
Protected Attributes inherited from G4VViewer
G4VSceneHandler &	fSceneHandler
G4int	fViewId
G4String	fName
G4String	fShortName
G4ViewParameters	fVP
G4ViewParameters	fDefaultVP
G4double	fKernelVisitElapsedTimeSeconds = 999.
G4SceneTreeItem	fSceneTree
G4bool	fNeedKernelVisit

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 &)

Detailed Description

Definition at line 214 of file G4VtkViewer.hh.

Constructor & Destructor Documentation

G4VtkViewer()

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

Definition at line 82 of file G4VtkViewer.cc.

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

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

~G4VtkViewer()

G4VtkViewer::~G4VtkViewer ( )

override

Definition at line 150 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::~G4VtkViewer()" << G4endl;
#endif
}

Member Function Documentation

AddCameraOrientationWidget()

void G4VtkViewer::AddCameraOrientationWidget ( )

virtual

Definition at line 687 of file G4VtkViewer.cc.

{
  camOrientWidget->SetParentRenderer(renderer);
  // Enable the widget.
  camOrientWidget->Off();
}

Referenced by DrawView().

AddClipperPlaneWidget()

void G4VtkViewer::AddClipperPlaneWidget ( const G4Plane3D & plane )

virtual

Definition at line 561 of file G4VtkViewer.cc.

{
  vtkNew<vtkIPWCallback> clipperCallback;
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& store = fVtkSceneHandler.GetStore();
  clipperCallback->SetStore(&store);
  clipperCallback->SetUpdatePipelineName("clipper", "clipper");
 
  G4double bounds[6];
  store.GetBounds(bounds);
  auto vplane = G4Plane3DToVtkPlane(plane);
  clipperPlaneRepresentation->SetPlaceFactor(
    1.25);  // This must be set prior to placing the widget.
  clipperPlaneRepresentation->PlaceWidget(bounds);
  clipperPlaneRepresentation->SetNormal(vplane->GetNormal());
 
  vtkNew<vtkPropCollection> planeRepActors;
  clipperPlaneRepresentation->GetActors(planeRepActors);
  planeRepActors->InitTraversal();
 
  SetWidgetInteractor(clipperPlaneWidget);
  clipperPlaneWidget->SetRepresentation(clipperPlaneRepresentation);
  clipperPlaneWidget->AddObserver(vtkCommand::InteractionEvent, clipperCallback);
 
  clipperPlaneWidget->SetEnabled(0);
}

Referenced by DrawView().

AddCutterPlaneWidget()

void G4VtkViewer::AddCutterPlaneWidget ( const G4Plane3D & plane )

virtual

Definition at line 588 of file G4VtkViewer.cc.

{
  vtkNew<vtkIPWCallback> cutterCallback;
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& store = fVtkSceneHandler.GetStore();
  cutterCallback->SetStore(&store);
  cutterCallback->SetUpdatePipelineName("cutter", "cutter");
 
  G4double bounds[6];
  store.GetBounds(bounds);
  auto vplane = G4Plane3DToVtkPlane(plane);
  cutterPlaneRepresentation->SetPlaceFactor(1.25);  // This must be set prior to placing the widget.
  cutterPlaneRepresentation->PlaceWidget(bounds);
  cutterPlaneRepresentation->SetNormal(vplane->GetNormal());
 
  SetWidgetInteractor(cutterPlaneWidget);
  cutterPlaneWidget->SetRepresentation(cutterPlaneRepresentation);
  cutterPlaneWidget->AddObserver(vtkCommand::InteractionEvent, cutterCallback);
 
  cutterPlaneWidget->SetEnabled(0);
}

Referenced by DrawView().

AddGeometryOverlay()

void G4VtkViewer::AddGeometryOverlay	(	const G4String &	fileName,
		const G4double	colour[3],
		const G4double	alpha,
		const G4String &	representation,
		const G4double	scale[3],
		const G4double	rotation[3],
		const G4double	translation[3] )

Definition at line 738 of file G4VtkViewer.cc.

{
  auto transformation = G4Transform3D::Identity;
  auto scal = G4Scale3D(scale[0], scale[1], scale[2]);
  auto rotx = G4RotateX3D(rotation[0]);
  auto roty = G4RotateY3D(rotation[1]);
  auto rotz = G4RotateZ3D(rotation[2]);
  auto tran = G4Translate3D(translation[0], translation[1], translation[2]);
 
  transformation = tran * rotz * roty * rotx * scal * transformation;
 
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& st = fVtkSceneHandler.GetTransientStore();
 
 
  G4VtkVisContext vc = G4VtkVisContext(this, nullptr, false, transformation);
  if (representation == "w")
    vc.fDrawingStyle = G4ViewParameters::wireframe;
  else if (representation == "s")
    vc.fDrawingStyle = G4ViewParameters::hlhsr;
  vc.alpha = alpha;
  vc.red = colour[0];
  vc.green = colour[1];
  vc.blue = colour[2];
  st.AddNonG4ObjectPolydata(fileName, vc);
}

AddImageOverlay()

void G4VtkViewer::AddImageOverlay	(	const G4String &	fileName,
		const G4double	alpha,
		const G4double	imageBottomLeft[2],
		const G4double	worldBottomLeft[2],
		const G4double	imageTopRight[2],
		const G4double	worldTopRight[2],
		const G4double	rot[3],
		const G4double	trans[3] )

Definition at line 704 of file G4VtkViewer.cc.

{
  auto xScale = (worldTopRight[0] - worldBottomLeft[0]) / (imageTopRight[0] - imageBottomLeft[0]);
  auto yScale = -(worldTopRight[1] - worldBottomLeft[1]) / (imageTopRight[1] - imageBottomLeft[1]);
 
  G4cout << xScale << " " << yScale << G4endl;
  auto transformation = G4Transform3D::Identity;
  auto scal = G4Scale3D(xScale, yScale, 1);
  auto rotx = G4RotateX3D(rotation[0]/180*CLHEP::pi);
  auto roty = G4RotateY3D(rotation[1]/180*CLHEP::pi);
  auto rotz = G4RotateZ3D(rotation[2]/180*CLHEP::pi);
  auto tranImg = G4Translate3D(  -std::fabs(imageBottomLeft[0] + imageTopRight[0]) / 2.0,
                                 -std::fabs(imageBottomLeft[1] + imageTopRight[1]) / 2.0,
                                 0);
  auto tran = G4Translate3D(translation[0],
                            translation[1],
                            translation[2]);
 
  G4cout << translation[0] << " " << translation[1] << " " << translation[2] << G4endl;
  transformation = tran * rotz * roty * rotx * scal * tranImg * transformation;
 
  G4cout << transformation.dx() << " " << transformation.dy() << " " << transformation.dz() << G4endl;
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& st = fVtkSceneHandler.GetTransientStore();
 
  G4VtkVisContext vc = G4VtkVisContext(this, nullptr, false, transformation);
  vc.alpha = alpha;
  st.AddNonG4ObjectImage(fileName, vc);
}

AddViewHUD()

void G4VtkViewer::AddViewHUD

(

)

Definition at line 547 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);
  infoTextActor->SetVisibility(0);
}

Referenced by DrawView().

ClearView()

void G4VtkViewer::ClearView ( void )

overridevirtual

Implements G4VViewer.

Definition at line 235 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::ClearView()" << G4endl;
#endif
 
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& ts = fVtkSceneHandler.GetTransientStore();
  ts.Clear();
 
  G4VtkStore& s = fVtkSceneHandler.GetStore();
  s.Clear();
}

DisableCameraOrientationWidget()

void G4VtkViewer::DisableCameraOrientationWidget ( )

virtual

Definition at line 699 of file G4VtkViewer.cc.

{
  camOrientWidget->Off();
}

DisableClipper()

void G4VtkViewer::DisableClipper

(

)

Definition at line 641 of file G4VtkViewer.cc.

{
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& s = fVtkSceneHandler.GetStore();
  s.RemoveClipper("clipper");
}

DisableClipperWidget()

void G4VtkViewer::DisableClipperWidget ( )

virtual

Definition at line 653 of file G4VtkViewer.cc.

{
  clipperPlaneWidget->SetEnabled(0);
}

DisableCutter()

void G4VtkViewer::DisableCutter

(

G4String

name

)

Definition at line 669 of file G4VtkViewer.cc.

{
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& s = fVtkSceneHandler.GetStore();
  s.RemoveCutter("cutter");
}

DisableCutterWidget()

void G4VtkViewer::DisableCutterWidget ( )

virtual

Definition at line 682 of file G4VtkViewer.cc.

{
  cutterPlaneWidget->SetEnabled(0);
}

DisableHUD()

void G4VtkViewer::DisableHUD

(

)

Definition at line 625 of file G4VtkViewer.cc.

{
  infoTextActor->SetVisibility(0);
}

DisableShadows()

void G4VtkViewer::DisableShadows

(

)

Definition at line 615 of file G4VtkViewer.cc.

{
  renderer->SetUseShadows(0);
}

DrawShadows()

void G4VtkViewer::DrawShadows

(

)

Definition at line 283 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
  auto glrenderer = dynamic_cast<vtkOpenGLRenderer*>(renderer.GetPointer());
  glrenderer->SetPass(cameraP);
}

DrawView()

void G4VtkViewer::DrawView ( )

overridevirtual

Implements G4VViewer.

Definition at line 249 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::DrawView()" << G4endl;
#endif
 
  // 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
  AddViewHUD();
 
  // Add clipper and cutter widgets
  auto g4p = G4Plane3D();
  AddCutterPlaneWidget(g4p);
  AddClipperPlaneWidget(g4p);
 
  // Add camera orientation widget
  AddCameraOrientationWidget();
 
  // ...before finally...
  FinishView();  // Flush streams and/or swap buffers.
}

EnableCameraOrientationWidget()

void G4VtkViewer::EnableCameraOrientationWidget ( )

virtual

Definition at line 694 of file G4VtkViewer.cc.

{
  camOrientWidget->On();
}

EnableClipper()

void G4VtkViewer::EnableClipper	(	const G4Plane3D &	plane,
		G4bool	widget )

Definition at line 630 of file G4VtkViewer.cc.

{
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& s = fVtkSceneHandler.GetStore();
  G4String name = G4String("clipper");
  s.AddClipper(name, plane);
  if (bWidget) {
    EnableClipperWidget();
  }
}

EnableClipperWidget()

void G4VtkViewer::EnableClipperWidget ( )

virtual

Reimplemented in G4VtkQtViewer.

Definition at line 648 of file G4VtkViewer.cc.

{
  clipperPlaneWidget->SetEnabled(1);
}

Referenced by EnableClipper(), and G4VtkQtViewer::EnableClipperWidget().

EnableCutter()

void G4VtkViewer::EnableCutter	(	const G4Plane3D &	plane,
		G4bool	bWidget )

Definition at line 658 of file G4VtkViewer.cc.

{
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& s = fVtkSceneHandler.GetStore();
  G4String name = G4String("cutter");
  s.AddCutter(name, plane);
  if (bWidget) {
    EnableCutterWidget();
  }
}

EnableCutterWidget()

void G4VtkViewer::EnableCutterWidget ( )

virtual

Definition at line 676 of file G4VtkViewer.cc.

{
  G4cout << "enable cutter widget" << G4endl;
  cutterPlaneWidget->SetEnabled(1);
}

Referenced by EnableCutter().

EnableHUD()

void G4VtkViewer::EnableHUD

(

)

Definition at line 620 of file G4VtkViewer.cc.

{
  infoTextActor->SetVisibility(1);
}

EnableShadows()

void G4VtkViewer::EnableShadows

(

)

Definition at line 610 of file G4VtkViewer.cc.

{
  renderer->SetUseShadows(1);
}

ExportFormatStore()

void G4VtkViewer::ExportFormatStore	(	G4String	fileName,
		G4String	store )

Definition at line 502 of file G4VtkViewer.cc.

{
  vtkSmartPointer<vtkRenderWindow> tempRenderWindow;
  vtkNew<vtkRenderer> tempRenderer;
  tempRenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
  tempRenderWindow->AddRenderer(tempRenderer);
 
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
 
  if (storeName == "transient") {
    G4VtkStore& store = fVtkSceneHandler.GetTransientStore();
    store.AddToRenderer(tempRenderer);
  }
  else {
    G4VtkStore& store = fVtkSceneHandler.GetStore();
    store.AddToRenderer(tempRenderer);
  }
 
  if (fileName.find("obj") != std::string::npos) {
    vtkNew<vtkOBJExporter> exporter;
    exporter->SetRenderWindow(tempRenderWindow);
    exporter->SetFilePrefix(fileName.c_str());
    exporter->Write();
  }
  else if (fileName.find("vrml") != std::string::npos) {
    vtkNew<vtkVRMLExporter> exporter;
    exporter->SetRenderWindow(tempRenderWindow);
    exporter->SetFileName(fileName.c_str());
    exporter->Write();
  }
  else if (fileName.find("vtp") != std::string::npos) {
    vtkNew<vtkSingleVTPExporter> exporter;
    exporter->SetRenderWindow(tempRenderWindow);
    exporter->SetFileName(fileName.c_str());
    exporter->Write();
  }
  else if (fileName.find("gltf") != std::string::npos) {
    vtkNew<vtkGLTFExporter> exporter;
    exporter->SetRenderWindow(tempRenderWindow);
    exporter->SetFileName(fileName.c_str());
    exporter->InlineDataOn();
    exporter->Write();
  }
}

ExportGLTFScene()

void G4VtkViewer::ExportGLTFScene

(

G4String

fileName

)

Definition at line 413 of file G4VtkViewer.cc.

                                                   {
  vtkSmartPointer<vtkGLTFExporter> exporter = vtkSmartPointer<vtkGLTFExporter>::New();
  exporter->SetRenderWindow(_renderWindow);
  exporter->SetFileName((fileName+".gltf").c_str());
  exporter->InlineDataOn();
  exporter->Write();
}

ExportJSONRenderWindowScene()

void G4VtkViewer::ExportJSONRenderWindowScene

(

G4String

)

Definition at line 429 of file G4VtkViewer.cc.

                                                        {
  vtkSmartPointer<vtkJSONRenderWindowExporter> exporter = vtkSmartPointer<vtkJSONRenderWindowExporter>::New();
  vtkSmartPointer<vtkVtkJSSceneGraphSerializer> serializer = vtkSmartPointer<vtkVtkJSSceneGraphSerializer>::New();
  exporter->SetRenderWindow(_renderWindow);
  exporter->SetSerializer(serializer);
  exporter->Write();
}

ExportOBJScene()

void G4VtkViewer::ExportOBJScene

(

G4String

path

)

Definition at line 389 of file G4VtkViewer.cc.

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

ExportScreenShot()

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

Definition at line 343 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 {
    return;
  }
 
  _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 282 of file G4VtkViewer.hh.

{};

ExportVRMLScene()

void G4VtkViewer::ExportVRMLScene

(

G4String

path

)

Definition at line 397 of file G4VtkViewer.cc.

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

ExportVTPCutter()

void G4VtkViewer::ExportVTPCutter

(

G4String

fileName

)

Definition at line 437 of file G4VtkViewer.cc.

{
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& s = fVtkSceneHandler.GetStore();
 
  // create new renderer
  vtkNew<vtkRenderer> tempRenderer;
 
  // loop over pipelines
  auto separate = s.GetSeparatePipeMap();
  for (const auto& i : separate) {
    i.second->GetActor();
    auto children = i.second->GetChildPipelines();
    for (auto child : children) {
      if (child->GetTypeName() == "G4VtkCutterPipeline") {
        auto childCutter = dynamic_cast<G4VtkCutterPipeline*>(child);
        tempRenderer->AddActor(childCutter->GetActor());
      }
    }
  }
 
  auto tensor = s.GetTensorPipeMap();
  for (const auto& i : tensor) {
    i.second->GetActor();
    auto children = i.second->GetChildPipelines();
    for (auto child : children) {
      if (child->GetTypeName() == "G4VtkCutterPipeline") {
        auto childCutter = dynamic_cast<G4VtkCutterPipeline*>(child);
        tempRenderer->AddActor(childCutter->GetActor());
      }
    }
  }
 
  auto append = s.GetAppendPipeMap();
  for (const auto& i : append) {
    i.second->GetActor();
    auto children = i.second->GetChildPipelines();
    for (auto child : children) {
      if (child->GetTypeName() == "G4VtkCutterPipeline") {
        auto childCutter = dynamic_cast<G4VtkCutterPipeline*>(child);
        tempRenderer->AddActor(childCutter->GetActor());
      }
    }
  }
 
  auto baked = s.GetBakePipeMap();
  for (const auto& i : baked) {
    i.second->GetActor();
    auto children = i.second->GetChildPipelines();
    for (auto child : children) {
      if (child->GetTypeName() == "G4VtkCutterPipeline") {
        auto childCutter = dynamic_cast<G4VtkCutterPipeline*>(child);
        tempRenderer->AddActor(childCutter->GetActor());
      }
    }
  }
 
  vtkNew<vtkRenderWindow> tempRenderWindow;
  tempRenderWindow->AddRenderer(tempRenderer);
  vtkNew<vtkSingleVTPExporter> exporter;
  exporter->SetRenderWindow(tempRenderWindow);
  exporter->SetFileName(fileName.c_str());
  exporter->Write();
}

ExportVTPScene()

void G4VtkViewer::ExportVTPScene

(

G4String

path

)

Definition at line 405 of file G4VtkViewer.cc.

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

ExportX3DScene()

void G4VtkViewer::ExportX3DScene

(

G4String

fileName

)

Definition at line 421 of file G4VtkViewer.cc.

                                                  {
  vtkSmartPointer<vtkX3DExporter> exporter = vtkSmartPointer<vtkX3DExporter>::New();
  exporter->SetRenderWindow(_renderWindow);
  exporter->SetFileName((fileName+".x3d").c_str());
  exporter->Write();
}

FinishView()

void G4VtkViewer::FinishView ( void )

overridevirtual

Reimplemented from G4VViewer.

Definition at line 323 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::FinishView()" << G4endl;
#endif
 
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  fVtkSceneHandler.Modified();
 
  _renderWindow->GetInteractor()->Initialize();
  _renderWindow->Render();
 
  if (firstFinishView) {
    firstFinishView = false;
  }
  else {
    _renderWindow->GetInteractor()->Start();
  }
}

Referenced by DrawView().

Initialise()

void G4VtkViewer::Initialise ( )

overridevirtual

Reimplemented from G4VViewer.

Definition at line 92 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);
 
  // Hidden line removal
  renderer->SetUseHiddenLineRemoval(0);
 
  // Shadows
  renderer->SetUseShadows(0);
 
  // Set callback to match VTK parameters to Geant4
  geant4Callback->SetGeant4ViewParameters(&fVP);
  renderer->AddObserver(vtkCommand::EndEvent, geant4Callback);
 
  vtkSmartPointer<G4VtkInteractorStyle> style = vtkSmartPointer<G4VtkInteractorStyle>::New();
  renderWindowInteractor->SetInteractorStyle(style);
}

Referenced by G4VtkOffscreenViewer::Initialise().

Print()

void G4VtkViewer::Print

(

)

Definition at line 768 of file G4VtkViewer.cc.

{
  cutterPlaneRepresentation->VisibilityOff();
 
  G4cout << "Number of VTK props>  " << renderer->GetNumberOfPropsRendered() << G4endl;
  G4cout << "Number of VTK actors> " << renderer->GetActors()->GetNumberOfItems() << G4endl;
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  G4VtkStore& s = fVtkSceneHandler.GetStore();
  G4VtkStore& st = fVtkSceneHandler.GetTransientStore();
  s.Print();
  st.Print();
}

Render()

void G4VtkViewer::Render ( )

inline

Definition at line 271 of file G4VtkViewer.hh.

{_renderWindow->Render();}

SetGeant4View()

void G4VtkViewer::SetGeant4View ( )

inline

Definition at line 283 of file G4VtkViewer.hh.

{};

SetPolyhedronPipeline()

void G4VtkViewer::SetPolyhedronPipeline

(

const G4String &

t

)

Definition at line 781 of file G4VtkViewer.cc.

{
  // Get the scene handler
  auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
  fVtkSceneHandler.SetPolyhedronPipeline(type);
}

SetView()

void G4VtkViewer::SetView ( )

overridevirtual

Implements G4VViewer.

Definition at line 157 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::SetView()" << G4endl;
#endif
  // 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.;
  }
 
  if (firstSetView) cameraDistance = fVP.GetCameraDistance(radius);
  G4Point3D viewpointDirection = fVP.GetViewpointDirection();
  G4Point3D targetPosition = fVP.GetCurrentTargetPoint();
  G4double zoomFactor = fVP.GetZoomFactor();
  G4double fieldHalfAngle = fVP.GetFieldHalfAngle();
 
  G4Point3D cameraPosition = targetPosition + viewpointDirection.unit() /zoomFactor  * cameraDistance;
 
  vtkCamera* activeCamera = renderer->GetActiveCamera();
  activeCamera->SetFocalPoint(targetPosition.x(), targetPosition.y(), targetPosition.z());
  activeCamera->SetViewAngle(2*fieldHalfAngle / CLHEP::pi * 180);
  activeCamera->SetPosition(cameraPosition.x(), cameraPosition.y(), cameraPosition.z());
  activeCamera->SetParallelScale(cameraDistance / zoomFactor);
 
  if (fieldHalfAngle == 0) {
    activeCamera->SetParallelProjection(1);
  }
  else {
    activeCamera->SetParallelProjection(0);
  }
 
  // need to set camera distance and parallel scale on first set view
  if (firstSetView) {
    geant4Callback->SetVtkInitialValues(cameraDistance, cameraDistance);
    activeCamera->SetParallelScale(cameraDistance);
    firstSetView = false;
  }
 
  // 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 = targetPosition + lightDirection.unit() * cameraDistance;
 
  vtkLightCollection* currentLights = renderer->GetLights();
  if (currentLights->GetNumberOfItems() != 0) {
    auto currentLight = dynamic_cast<vtkLight*>(currentLights->GetItemAsObject(0));
    if (currentLight != nullptr) {
      currentLight->SetPosition(lightPosition.x(), lightPosition.y(), lightPosition.z());
      if (lightsMoveWithCamera) {
        currentLight->SetLightTypeToCameraLight();
      }
      else {
        currentLight->SetLightTypeToSceneLight();
      }
    }
  }
 
  // cut away
  if (fVP.IsCutaway()) {
    G4cout << "Add cutaway planes" << G4endl;
  }
 
  // section
  if (fVP.IsSection()) {
    G4cout << "Add section" << G4endl;
  }
}

SetWidgetInteractor()

void G4VtkViewer::SetWidgetInteractor ( vtkAbstractWidget * widget )

virtual

Reimplemented in G4VtkQtViewer.

Definition at line 788 of file G4VtkViewer.cc.

{
  widget->SetInteractor(_renderWindow->GetInteractor());
}

Referenced by AddClipperPlaneWidget(), and AddCutterPlaneWidget().

ShowView()

void G4VtkViewer::ShowView ( void )

overridevirtual

Reimplemented from G4VViewer.

Definition at line 303 of file G4VtkViewer.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkViewer::ShowView()" << G4endl;
#endif
 
  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);
}

StartInteractor()

void G4VtkViewer::StartInteractor ( )

inline

Definition at line 272 of file G4VtkViewer.hh.

                           {
      G4cout << "StartInteractor" << G4endl;
      _renderWindow->GetInteractor()->Start();}

Member Data Documentation

_renderWindow

vtkRenderWindow* G4VtkViewer::_renderWindow

Definition at line 291 of file G4VtkViewer.hh.

Referenced by DrawShadows(), ExportGLTFScene(), ExportJSONRenderWindowScene(), ExportOBJScene(), ExportScreenShot(), ExportVRMLScene(), ExportVTPScene(), ExportX3DScene(), G4VtkOffscreenViewer::FinishView(), G4VtkQtViewer::FinishView(), FinishView(), G4VtkOffscreenViewer::Initialise(), G4VtkQtViewer::Initialise(), Initialise(), Render(), SetWidgetInteractor(), and StartInteractor().

bClipper

bool G4VtkViewer::bClipper = false

protected

Definition at line 308 of file G4VtkViewer.hh.

bCutter

bool G4VtkViewer::bCutter = false

protected

Definition at line 307 of file G4VtkViewer.hh.

bHud

bool G4VtkViewer::bHud = false

protected

Definition at line 309 of file G4VtkViewer.hh.

bOrientation

bool G4VtkViewer::bOrientation = false

protected

Definition at line 310 of file G4VtkViewer.hh.

camera

vtkNew<vtkCamera> G4VtkViewer::camera

Definition at line 289 of file G4VtkViewer.hh.

Referenced by Initialise().

cameraDistance

G4double G4VtkViewer::cameraDistance

protected

Definition at line 297 of file G4VtkViewer.hh.

Referenced by SetView().

camOrientWidget

vtkNew<vtkCameraOrientationWidget> G4VtkViewer::camOrientWidget

protected

Definition at line 305 of file G4VtkViewer.hh.

Referenced by AddCameraOrientationWidget(), DisableCameraOrientationWidget(), and EnableCameraOrientationWidget().

clipperPlaneRepresentation

vtkNew<vtkImplicitPlaneRepresentation> G4VtkViewer::clipperPlaneRepresentation

protected

Definition at line 302 of file G4VtkViewer.hh.

Referenced by AddClipperPlaneWidget().

clipperPlaneWidget

vtkNew<vtkImplicitPlaneWidget2> G4VtkViewer::clipperPlaneWidget

protected

Definition at line 303 of file G4VtkViewer.hh.

Referenced by AddClipperPlaneWidget(), DisableClipperWidget(), and EnableClipperWidget().

cutterPlaneRepresentation

vtkNew<vtkImplicitPlaneRepresentation> G4VtkViewer::cutterPlaneRepresentation

protected

Definition at line 299 of file G4VtkViewer.hh.

Referenced by AddCutterPlaneWidget(), and Print().

cutterPlaneWidget

vtkNew<vtkImplicitPlaneWidget2> G4VtkViewer::cutterPlaneWidget

protected

Definition at line 300 of file G4VtkViewer.hh.

Referenced by AddCutterPlaneWidget(), DisableCutterWidget(), and EnableCutterWidget().

firstFinishView

G4bool G4VtkViewer::firstFinishView = true

protected

Definition at line 296 of file G4VtkViewer.hh.

Referenced by FinishView().

firstSetView

G4bool G4VtkViewer::firstSetView = true

protected

Definition at line 295 of file G4VtkViewer.hh.

Referenced by SetView().

geant4Callback

vtkNew<vtkGeant4Callback> G4VtkViewer::geant4Callback

Definition at line 287 of file G4VtkViewer.hh.

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

infoCallback

vtkNew<vtkInfoCallback> G4VtkViewer::infoCallback

Definition at line 286 of file G4VtkViewer.hh.

Referenced by AddViewHUD(), and ShowView().

infoTextActor

vtkNew<vtkTextActor> G4VtkViewer::infoTextActor

Definition at line 285 of file G4VtkViewer.hh.

Referenced by AddViewHUD(), DisableHUD(), EnableHUD(), and ShowView().

light

vtkSmartPointer<vtkLight> G4VtkViewer::light

Definition at line 288 of file G4VtkViewer.hh.

renderer

vtkNew<vtkRenderer> G4VtkViewer::renderer

Definition at line 290 of file G4VtkViewer.hh.

Referenced by AddCameraOrientationWidget(), AddViewHUD(), DisableShadows(), DrawShadows(), EnableShadows(), G4VtkQtViewer::Initialise(), Initialise(), Print(), SetView(), and ShowView().

renderWindowInteractor

vtkRenderWindowInteractor* G4VtkViewer::renderWindowInteractor

Definition at line 292 of file G4VtkViewer.hh.

Referenced by Initialise().

---

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

• G4VtkViewer.hh
• G4VtkViewer.cc