G4Qt3DViewer Class Reference

#include <G4Qt3DViewer.hh>

Inheritance diagram for G4Qt3DViewer:

Public Member Functions
	G4Qt3DViewer (G4Qt3DSceneHandler &, const G4String &name)
virtual	~G4Qt3DViewer ()
void	Initialise ()
void	SetView ()
void	ClearView ()
void	DrawView ()
void	ShowView ()
void	FinishView ()
void	MovingToVisSubThread ()
void	SwitchToVisSubThread ()
void	MovingToMasterThread ()
void	SwitchToMasterThread ()
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	DoneWithVisSubThread ()
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 ()

Protected Member Functions
virtual void	resizeEvent (QResizeEvent *)
void	KernelVisitDecision ()
G4bool	CompareForKernelVisit (G4ViewParameters &)
void	keyPressEvent (QKeyEvent *)
void	keyReleaseEvent (QKeyEvent *)
void	mouseDoubleClickEvent (QMouseEvent *)
void	mouseMoveEvent (QMouseEvent *)
void	mousePressEvent (QMouseEvent *)
void	mouseReleaseEvent (QMouseEvent *)
void	wheelEvent (QWheelEvent *)
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
G4ViewParameters	fLastVP
G4Qt3DSceneHandler &	fQt3DSceneHandler
QWidget *	fUIWidget
G4bool	fKeyPressed
int	fKey
G4bool	fMousePressed
G4double	fMousePressedX
G4double	fMousePressedY
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
Public Attributes inherited from G4VViewer
const G4int	fMaxNTouchables = 10000
G4bool	fCurtailDescent = false

Detailed Description

Definition at line 37 of file G4Qt3DViewer.hh.

Constructor & Destructor Documentation

G4Qt3DViewer()

G4Qt3DViewer::G4Qt3DViewer	(	G4Qt3DSceneHandler &	sceneHandler,
		const G4String &	name )

Definition at line 40 of file G4Qt3DViewer.cc.

: G4VViewer(sceneHandler, sceneHandler.IncrementViewCount(), name)
, fQt3DSceneHandler(sceneHandler)
, fKeyPressed(false)
, fMousePressed(false)
, fMousePressedX(0.)
, fMousePressedY(0.)
{}

~G4Qt3DViewer()

G4Qt3DViewer::~G4Qt3DViewer ( )

virtual

Definition at line 71 of file G4Qt3DViewer.cc.

{
  setRootEntity(nullptr);
}

Member Function Documentation

ClearView()

void G4Qt3DViewer::ClearView ( void )

virtual

Implements G4VViewer.

Definition at line 131 of file G4Qt3DViewer.cc.

{}

CompareForKernelVisit()

G4bool G4Qt3DViewer::CompareForKernelVisit ( G4ViewParameters & vp )

protected

Definition at line 291 of file G4Qt3DViewer.cc.

{
  // Typical comparison.  Taken from OpenInventor.
  if (
     (vp.GetDrawingStyle ()    != fVP.GetDrawingStyle ())    ||
     (vp.GetNumberOfCloudPoints()  != fVP.GetNumberOfCloudPoints())  ||
     (vp.IsAuxEdgeVisible ()   != fVP.IsAuxEdgeVisible ())   ||
     (vp.IsCulling ()          != fVP.IsCulling ())          ||
     (vp.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
     (vp.IsDensityCulling ()   != fVP.IsDensityCulling ())   ||
     (vp.IsCullingCovered ()   != fVP.IsCullingCovered ())   ||
     (vp.GetCBDAlgorithmNumber() !=
      fVP.GetCBDAlgorithmNumber())                           ||
     (vp.IsSection ()          != fVP.IsSection ())          ||
     (vp.IsCutaway ()          != fVP.IsCutaway ())          ||
     // This assumes use of generic clipping (sectioning, slicing,
     // DCUT, cutaway).  If a decision is made to implement locally,
     // this will need changing.  See G4OpenGLViewer::SetView,
     // G4OpenGLStoredViewer.cc::CompareForKernelVisit and
     // G4OpenGLStoredSceneHander::CreateSection/CutawayPolyhedron.
     (vp.IsExplode ()          != fVP.IsExplode ())          ||
     (vp.GetNoOfSides ()       != fVP.GetNoOfSides ())       ||
     (vp.GetGlobalMarkerScale()    != fVP.GetGlobalMarkerScale())    ||
     (vp.GetGlobalLineWidthScale() != fVP.GetGlobalLineWidthScale()) ||
     (vp.IsMarkerNotHidden ()  != fVP.IsMarkerNotHidden ())  ||
     (vp.GetDefaultVisAttributes()->GetColour() !=
      fVP.GetDefaultVisAttributes()->GetColour())            ||
     (vp.GetDefaultTextVisAttributes()->GetColour() !=
      fVP.GetDefaultTextVisAttributes()->GetColour())        ||
     (vp.GetBackgroundColour ()!= fVP.GetBackgroundColour ())||
     (vp.IsPicking ()          != fVP.IsPicking ())          ||
     // Scaling for Open Inventor is done by the scene handler so it
     // needs a kernel visit.  (In this respect, it differs from the
     // OpenGL drivers, where it's done in SetView.)
     (vp.GetScaleFactor ()     != fVP.GetScaleFactor ())     ||
     (vp.GetVisAttributesModifiers() !=
      fVP.GetVisAttributesModifiers())                       ||
     (vp.IsSpecialMeshRendering() !=
      fVP.IsSpecialMeshRendering())                          ||
     (vp.GetSpecialMeshRenderingOption() !=
      fVP.GetSpecialMeshRenderingOption())
     )
  return true;
 
  if (vp.IsDensityCulling () &&
      (vp.GetVisibleDensity () != fVP.GetVisibleDensity ()))
    return true;
 
  if (vp.GetCBDAlgorithmNumber() > 0) {
    if (vp.GetCBDParameters().size() != fVP.GetCBDParameters().size()) return true;
    else if (vp.GetCBDParameters() != fVP.GetCBDParameters()) return true;
  }
 
  if (vp.IsSection () &&
      (vp.GetSectionPlane () != fVP.GetSectionPlane ()))
    return true;
 
  if (vp.IsCutaway ()) {
    if (vp.GetCutawayMode() != fVP.GetCutawayMode()) return true;
    if (vp.GetCutawayPlanes ().size () !=
        fVP.GetCutawayPlanes ().size ()) return true;
    for (size_t i = 0; i < vp.GetCutawayPlanes().size(); ++i)
    if (vp.GetCutawayPlanes()[i] != fVP.GetCutawayPlanes()[i])
      return true;
  }
 
  if (vp.IsExplode () &&
      (vp.GetExplodeFactor () != fVP.GetExplodeFactor ()))
    return true;
 
  if (vp.IsSpecialMeshRendering() &&
      (vp.GetSpecialMeshVolumes() != fVP.GetSpecialMeshVolumes()))
    return true;
 
  return false;
}

Referenced by KernelVisitDecision().

DrawView()

void G4Qt3DViewer::DrawView ( )

virtual

Implements G4VViewer.

Definition at line 134 of file G4Qt3DViewer.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.
 
  // The fNeedKernelVisit flag might have been set by the user in
  // /vis/viewer/rebuild, but if not, make decision and set flag only
  // if necessary...
  if (!fNeedKernelVisit) KernelVisitDecision();
  G4bool kernelVisitWasNeeded = fNeedKernelVisit; // Keep (ProcessView resets).
  fLastVP = fVP;
 
  ProcessView ();  // Clears store and processes scene only if necessary.
 
  if (kernelVisitWasNeeded) {
    // We might need to do something if the kernel was visited.
  } else {
  }
 
  // ...before finally...
  FinishView ();       // Flush streams and/or swap buffers.
}

Referenced by mouseMoveEvent(), and wheelEvent().

FinishView()

void G4Qt3DViewer::FinishView ( void )

virtual

Reimplemented from G4VViewer.

Definition at line 172 of file G4Qt3DViewer.cc.

{
#if QT_VERSION < 0x060000
  if (G4Threading::IsMasterThread()) {
    show();
  }
#endif
}

Referenced by DrawView().

Initialise()

void G4Qt3DViewer::Initialise ( )

virtual

Reimplemented from G4VViewer.

Definition at line 50 of file G4Qt3DViewer.cc.

{
  setObjectName(fName.c_str());
 
  fVP.SetAutoRefresh(true);
  fDefaultVP.SetAutoRefresh(true);
 
  auto UI = G4UImanager::GetUIpointer();
  auto uiQt = dynamic_cast<G4UIQt*>(UI->GetG4UIWindow());
  if (!uiQt) {
    fViewId = -1;  // This flags an error.
    G4warn << "G4Qt3DViewer::G4Qt3DViewer requires G4UIQt"
         << G4endl;
    return;
  }
  fUIWidget = QWidget::createWindowContainer(this);
  uiQt->AddTabWidget(fUIWidget,QString(fName));
 
  setRootEntity(fQt3DSceneHandler.fpQt3DScene);
}

KernelVisitDecision()

void G4Qt3DViewer::KernelVisitDecision ( )

protected

Definition at line 281 of file G4Qt3DViewer.cc.

                                        {
  
  // If there's a significant difference with the last view parameters
  // of either the scene handler or this viewer, trigger a rebuild.
 
  if (CompareForKernelVisit(fLastVP)) {
    NeedKernelVisit ();  // Sets fNeedKernelVisit.
  }
}

Referenced by DrawView().

keyPressEvent()

void G4Qt3DViewer::keyPressEvent ( QKeyEvent * ev )

protected

Definition at line 368 of file G4Qt3DViewer.cc.

{
  fKeyPressed = true;
  fKey = ev->key();
}

keyReleaseEvent()

void G4Qt3DViewer::keyReleaseEvent ( QKeyEvent * )

protected

Definition at line 374 of file G4Qt3DViewer.cc.

{
  fKeyPressed = false;
}

mouseDoubleClickEvent()

void G4Qt3DViewer::mouseDoubleClickEvent ( QMouseEvent * )

protected

Definition at line 379 of file G4Qt3DViewer.cc.

{}

mouseMoveEvent()

void G4Qt3DViewer::mouseMoveEvent ( QMouseEvent * ev )

protected

Definition at line 381 of file G4Qt3DViewer.cc.

{
  // I think we only want these if a mouse button is pressed.
  // But they come even when not pressed (on my MacBook Pro trackpad).
  // Documentation says:
  /* Mouse move events will occur only when a mouse button is pressed down,
   unless mouse tracking has been enabled with QWidget::setMouseTracking().*/
  // But this is a window not a widget.
  // As a workaround we maintain a flag changed by mousePress/ReleaseEvent.
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
  G4double x = ev->x();
  G4double y = ev->y();
#else
  G4double x = ev->position().x();
  G4double y = ev->position().y();
#endif
  G4double dx = x-fMousePressedX;
  G4double dy = y-fMousePressedY;
  fMousePressedX = x;
  fMousePressedY = y;
 
  if (fMousePressed) {
 
    if (fKeyPressed && fKey == Qt::Key_Shift) {  // Translation (pan)
 
      const G4double sceneRadius = fQt3DSceneHandler.fpScene->GetExtent().GetExtentRadius();
      const G4double scale = 300;  // Roughly pixels per window, empirically chosen
      const G4double dxScene = dx*sceneRadius/scale;
      const G4double dyScene = dy*sceneRadius/scale;
      fVP.IncrementPan(-dxScene,dyScene);
 
    } else {  // Rotation
 
      // Simple ad-hoc algorithms
      const G4Vector3D& x_prime = fVP.GetViewpointDirection().cross(fVP.GetUpVector());
      const G4Vector3D& y_prime = x_prime.cross(fVP.GetViewpointDirection());
      const G4double scale = 200;  // Roughly pixels per window, empirically chosen
      G4Vector3D newViewpointDirection = fVP.GetViewpointDirection();
      newViewpointDirection += dx*x_prime/scale;
      newViewpointDirection += dy*y_prime/scale;
      fVP.SetViewpointDirection(newViewpointDirection.unit());
 
      if (fVP.GetRotationStyle() == G4ViewParameters::freeRotation) {
        G4Vector3D newUpVector = fVP.GetUpVector();
        newUpVector += dx*x_prime/scale;
        newUpVector += dy*y_prime/scale;
        fVP.SetUpVector(newUpVector.unit());
      }
    }
  }
 
  SetView();
  DrawView();
}

mousePressEvent()

void G4Qt3DViewer::mousePressEvent ( QMouseEvent * ev )

protected

Definition at line 436 of file G4Qt3DViewer.cc.

{
  fMousePressed = true;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
  fMousePressedX = ev->x();
  fMousePressedY = ev->y();
#else
  fMousePressedX = ev->position().x();
  fMousePressedY = ev->position().y();
#endif
}

mouseReleaseEvent()

void G4Qt3DViewer::mouseReleaseEvent ( QMouseEvent * )

protected

Definition at line 448 of file G4Qt3DViewer.cc.

{
  fMousePressed = false;
}

MovingToMasterThread()

void G4Qt3DViewer::MovingToMasterThread ( )

virtual

Reimplemented from G4VViewer.

Definition at line 256 of file G4Qt3DViewer.cc.

{
  // Move relevant stuff to master QThread.
  auto p1 = fQt3DSceneHandler.fpQt3DScene->parent();
  if(p1) {
    auto p2 = p1->parent();
    if(p2) {
      p2->moveToThread(masterQThread);
    } else {
      p1->moveToThread(masterQThread);
    }
  }
 
  // Reset
  visSubThreadQThread = nullptr;
  qObjectsSwitched = false;
}

MovingToVisSubThread()

void G4Qt3DViewer::MovingToVisSubThread ( )

virtual

Reimplemented from G4VViewer.

Definition at line 206 of file G4Qt3DViewer.cc.

{
  // Make note of master QThread
  masterQThread = QThread::currentThread();
 
  // Wait until SwitchToVisSubThread has found vis sub-thread QThread
  {
  G4AutoLock lock(&visSubThreadMutex);
  G4CONDITIONWAITLAMBDA(&waitForVisSubThreadInitialized, &lock, []{return visSubThreadEstablished;})
  }
 
  // Move relevant stuff to vis sub-thread QThread
  auto p1 = fQt3DSceneHandler.fpQt3DScene->parent();
  if(p1) {
    auto p2 = p1->parent();
    if(p2) {
      p2->moveToThread(visSubThreadQThread);
    } else {
      p1->moveToThread(visSubThreadQThread);
    }
  }
 
  // Inform sub-thread
  G4AutoLock lock(&visSubThreadMutex);
  qObjectsSwitched = true;
  lock.unlock();
  G4CONDITIONBROADCAST(&waitForVisSubThreadInitialized);
}

resizeEvent()

void G4Qt3DViewer::resizeEvent ( QResizeEvent * )

protectedvirtual

Definition at line 76 of file G4Qt3DViewer.cc.

                                            {
  SetView();
}

SetView()

void G4Qt3DViewer::SetView ( )

virtual

Implements G4VViewer.

Definition at line 80 of file G4Qt3DViewer.cc.

{
  // Background colour
  defaultFrameGraph()->setClearColor(G4Qt3DUtils::ConvertToQColor(fVP.GetBackgroundColour()));
 
  // Get radius of scene, etc.
  // Note that this procedure properly takes into account zoom, dolly and pan.
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const G4Point3D cameraPosition =
    targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
  const GLdouble pnear  = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar   = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  const GLdouble right  = fVP.GetFrontHalfHeight (pnear, radius);
  const GLdouble left   = -right;
  const GLdouble top    = fVP.GetFrontHalfHeight (pnear, radius);
  const GLdouble bottom = -top;
 
  camera()->setObjectName((fName + " camera").c_str());
  camera()->setViewCenter(G4Qt3DUtils::ConvertToQVector3D(targetPoint));
  camera()->setPosition(G4Qt3DUtils::ConvertToQVector3D(cameraPosition));
  camera()->setUpVector(G4Qt3DUtils::ConvertToQVector3D(fVP.GetUpVector()));
 
//  auto lightEntity = new Qt3DCore::QEntity(fQt3DSceneHandler.fpQt3DScene);
//  auto directionalLight = new Qt3DRender::QDirectionalLight(lightEntity);
////  directionalLight->setColor("white");
////  directionalLight->setIntensity(1.);
//  directionalLight->setWorldDirection(G4Qt3DUtils::ConvertToQVector3D(fVP.GetActualLightpointDirection()));
//  lightEntity->addComponent(directionalLight);
 
  const auto& size = fUIWidget->size();
  G4double w = size.width();
  G4double h = size.height();
#ifdef G4QT3DDEBUG
  // Curiously w,h are wrong first time - 640,480 instead of (my Mac) 991,452.
  G4cout << "W,H: " << w << ',' << h << G4endl;
#endif
  const G4double aspectRatio = w/h;
  if (fVP.GetFieldHalfAngle() == 0.) {
    camera()->lens()->setOrthographicProjection
    (left*aspectRatio,right*aspectRatio,bottom,top,pnear,pfar);
  } else {
    camera()->lens()->setPerspectiveProjection
    (2.*fVP.GetFieldHalfAngle()/deg,aspectRatio,pnear,pfar);
  }
}

Referenced by mouseMoveEvent(), resizeEvent(), and wheelEvent().

ShowView()

void G4Qt3DViewer::ShowView ( void )

virtual

Reimplemented from G4VViewer.

Definition at line 160 of file G4Qt3DViewer.cc.

{
#if QT_VERSION < 0x060000
  // show() may only be called from master thread
  if (G4Threading::IsMasterThread()) {
    show();
  }
  // The way Qt seems to work, we don't seem to need a show() anyway, but
  // we'll leave it in - it seems not to have any effect, good or bad.
#endif
}

SwitchToMasterThread()

void G4Qt3DViewer::SwitchToMasterThread ( )

virtual

Reimplemented from G4VViewer.

Definition at line 275 of file G4Qt3DViewer.cc.

{
  visSubThreadEstablished = false;
}

SwitchToVisSubThread()

void G4Qt3DViewer::SwitchToVisSubThread ( )

virtual

Reimplemented from G4VViewer.

Definition at line 236 of file G4Qt3DViewer.cc.

{
  // Make note of vis-subthread QThread for MovingToVisSubThread
  visSubThreadQThread = QThread::currentThread();
 
  // Let MovingToVisSubThread know we have the QThread
  {
  G4AutoLock lock(&visSubThreadMutex);
  visSubThreadEstablished = true;
  G4CONDITIONBROADCAST(&waitForVisSubThreadInitialized);
  }
 
  // Wait until MovingToVisSubThread has moved stuff
  {
  G4AutoLock lock(&visSubThreadMutex);
  G4CONDITIONWAITLAMBDA(&waitForVisSubThreadInitialized, &lock, []{return qObjectsSwitched;})
  }
}

wheelEvent()

void G4Qt3DViewer::wheelEvent ( QWheelEvent * ev )

protected

Definition at line 453 of file G4Qt3DViewer.cc.

{
  // Take note of up-down motion only
  const G4double angleY = ev->angleDelta().y();
 
  if (fVP.GetFieldHalfAngle() == 0.) {  // Orthographic projection
    const G4double scale = 500;  // Empirically chosen
    fVP.MultiplyZoomFactor(1.+angleY/scale);
  } else {                              // Perspective projection
    const G4double delta = fSceneHandler.GetExtent().GetExtentRadius()/200.;  // Empirical
    fVP.SetDolly(fVP.GetDolly()+angleY*delta);
  }
  
  SetView();
  DrawView();
}

Member Data Documentation

fKey

int G4Qt3DViewer::fKey

protected

Definition at line 75 of file G4Qt3DViewer.hh.

Referenced by keyPressEvent(), and mouseMoveEvent().

fKeyPressed

G4bool G4Qt3DViewer::fKeyPressed

protected

Definition at line 74 of file G4Qt3DViewer.hh.

Referenced by G4Qt3DViewer(), keyPressEvent(), keyReleaseEvent(), and mouseMoveEvent().

fLastVP

G4ViewParameters G4Qt3DViewer::fLastVP

protected

Definition at line 69 of file G4Qt3DViewer.hh.

Referenced by DrawView(), and KernelVisitDecision().

fMousePressed

G4bool G4Qt3DViewer::fMousePressed

protected

Definition at line 76 of file G4Qt3DViewer.hh.

Referenced by G4Qt3DViewer(), mouseMoveEvent(), mousePressEvent(), and mouseReleaseEvent().

fMousePressedX

G4double G4Qt3DViewer::fMousePressedX

protected

Definition at line 77 of file G4Qt3DViewer.hh.

Referenced by G4Qt3DViewer(), mouseMoveEvent(), and mousePressEvent().

fMousePressedY

G4double G4Qt3DViewer::fMousePressedY

protected

Definition at line 77 of file G4Qt3DViewer.hh.

Referenced by G4Qt3DViewer(), mouseMoveEvent(), and mousePressEvent().

fQt3DSceneHandler

G4Qt3DSceneHandler& G4Qt3DViewer::fQt3DSceneHandler

protected

Definition at line 70 of file G4Qt3DViewer.hh.

Referenced by G4Qt3DViewer(), Initialise(), mouseMoveEvent(), MovingToMasterThread(), and MovingToVisSubThread().

fUIWidget

QWidget* G4Qt3DViewer::fUIWidget

protected

Definition at line 72 of file G4Qt3DViewer.hh.

Referenced by Initialise(), and SetView().

---

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

• G4Qt3DViewer.hh
• G4Qt3DViewer.cc