Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Classes | Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Friends | List of all members
G4OpenInventorQtExaminerViewer Class Reference

#include <G4OpenInventorQtExaminerViewer.hh>

+ Inheritance diagram for G4OpenInventorQtExaminerViewer:

Classes

struct  elementForSorting
 
struct  sceneElement
 
struct  viewPtData
 

Public Member Functions

 G4OpenInventorQtExaminerViewer (QWidget *parent=NULL, const char *name=NULL, SbBool embed=TRUE, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER)
 
 ~G4OpenInventorQtExaminerViewer ()
 
template<class T>
void parseString (T &t, const std::string &s, bool &error)
 
G4UIQt * GetUIQt ()
 
void setOrigWindowSize (int w, int h)
 
QMenuBar * getMenubar ()
 
QMenu * getFileMenu ()
 
QMenu * getEtcMenu ()
 
QFont * getFont ()
 
void setExternalQtApp ()
 
void addEscapeCallback (void(*cb)())
 

Public Attributes

std::string saveScenegraphFileName
 
std::string saveRefCoordsFileName
 
bool abbrOutputFlag
 
bool pickRefPathFlag
 
bool viewingBeforePickRef
 

Protected Types

enum  CameraType { PERSPECTIVE , ORTHOGRAPHIC }
 
enum  State {
  GENERAL , BEAMLINE , VIEWPOINT , ANIMATION ,
  REVERSED_ANIMATION , PAUSED_ANIMATION , ROTATING
}
 

Protected Member Functions

void construct (const SbBool build)
 
void buildWidget (QWidget *parent)
 
virtual void afterRealizeHook ()
 
SbBool processSoEvent (const SoEvent *const event)
 
void saveViewPt (char *name)
 
bool loadViewPts ()
 
void addViewPoints ()
 
void setViewPt ()
 
void writeViewPtIdx ()
 
void cleanUpAfterPrevFile ()
 
void deleteViewPt (char *vpName=NULL)
 
void renameViewPt (char *vpName)
 
void sortViewPts (std::vector< std::string >)
 
void zoom (const float)
 
void moveCamera (float dist=0, bool lookdown=false)
 
void rotateCamera ()
 
void updateViewParams (SoKeyboardEvent::Key)
 
void animateRefParticle ()
 
void saveCurCamera ()
 
void restoreCamera ()
 
void incSpeed ()
 
void decSpeed ()
 
void setReferencePath (SoLineSet *, SoCoordinate3 *, bool append=false)
 
void setReferencePathZPos ()
 
void findAndSetRefPath ()
 
SoCoordinate3 * getCoordsNode (SoFullPath *path)
 
void getSceneElements ()
 
float sqrlen (const SbVec3f &)
 
void distanceToTrajectory (const SbVec3f &, float &, SbVec3f &, int &)
 
void sortElements ()
 
void createElementsList ()
 
void evenOutRefParticlePts ()
 
void gotoRefPathStart ()
 
void invertRefPath ()
 
void setStartingPtForAnimation ()
 
std::string viewPtAutoName ()
 
SoNode * getSuperimpositionNode (SoNode *, const char *name)
 
void superimpositionEvent (SoAction *action)
 
virtual void actualRedraw (void)
 
void updateSpeedIndicator (void)
 

Static Protected Member Functions

static void sceneChangeCB (void *, SoSensor *)
 
static void mouseoverCB (void *aThis, SoEventCallback *eventCB)
 
static void pickingCB (void *aThis, SoEventCallback *eventCB)
 
static void animateRefParticleCB ()
 
static void animateSensorCB (void *, SoSensor *)
 
static void animateSensorRotationCB (void *, SoSensor *)
 
static void superimpositionCB (void *closure, SoAction *action)
 

Protected Attributes

HookEventProcState * hookBeamOn
 
bool newEvents
 
std::string curEltName
 
SbVec3f camUpVec
 
SbVec3f camDir
 
double animateBtwPtsPeriod
 
double speedStep
 
SoTimerSensor * animateSensor
 
SoTimerSensor * animateSensorRotation
 
SoNodeSensor * sceneChangeSensor
 
SbVec3f camStartPos
 
SbVec3f camEndPos
 
SbRotation camStartOrient
 
SbRotation camEndOrient
 
bool zcoordSetFlag
 
std::vector< sceneElement > sceneElements
 
std::vector< viewPtData > viewPtList
 
std::string fileName
 
std::ifstream fileIn
 
std::ofstream fileOut
 
int viewPtIdx
 
int MAX_VP_IDX
 
int MAX_VP_NAME
 
std::vector< SbVec3f > refParticleTrajectory
 
std::vector< float > refZPositions
 
int refParticleIdx
 
int prevRefIdx
 
float distance
 
State currentState
 
State prevState
 
State beforePausing
 
char * curViewPtName
 
int step
 
SbVec3f prevPt
 
SbVec3f prevParticleDir
 
void * prevColorField
 
viewPtData camB4Animation
 
bool returnToSaveVP
 
bool returnToAnim
 
SoCamera * myCam
 
float left_right
 
float up_down
 
SbVec3f rotAxis
 
int rotCnt
 
SoSearchAction * searcher
 
SoNode * superimposition
 
SoCoordinate3 * sgeometry
 
SoScale * sscale
 
SoTranslation * stranslation
 
SoTranslation * curInfoTrans
 
SoTranslation * mouseOverTransSolid
 
SoTranslation * mouseOverTransMaterial
 
SoTranslation * mouseOverTransLogName
 
SoTranslation * mouseOverTransZPos
 
SoText2 * curInfoText
 
SoText2 * mouseOverTextSolid
 
SoText2 * mouseOverTextMaterial
 
SoText2 * mouseOverTextLogName
 
SoText2 * mouseOverTextZPos
 
SoFont * curInfoFont
 
SoFont * mouseOverFontSolid
 
SoFont * mouseOverFontMaterial
 
SoFont * mouseOverFontLogName
 
SoFont * mouseOverFontZPos
 
SoSwitch * axisSwitch
 
SoSwitch * animSpeedOutlineSwitch
 
SoSwitch * animSpeedSwitch
 
SoSwitch * curInfoSwitch
 
float maxSpeed
 
float defaultHeight
 
float defaultHeightAngle
 
G4int pathLookahead
 
SbVec3f upVector
 
SbVec3f offsetFromCenter
 
SbVec3f center
 
bool rotUpVec
 
SoSeparator * newSceneGraph
 

Friends

class G4OpenInventorQtViewer
 
class HookEventProcState
 

Detailed Description

Definition at line 87 of file G4OpenInventorQtExaminerViewer.hh.

Member Enumeration Documentation

◆ CameraType

enum G4OpenInventorQtExaminerViewer::CameraType
protected
Enumerator
PERSPECTIVE 
ORTHOGRAPHIC 

Definition at line 325 of file G4OpenInventorQtExaminerViewer.hh.

325 {
326 PERSPECTIVE,
327 ORTHOGRAPHIC
328 };

◆ State

enum G4OpenInventorQtExaminerViewer::State
protected
Enumerator
GENERAL 
BEAMLINE 
VIEWPOINT 
ANIMATION 
REVERSED_ANIMATION 
PAUSED_ANIMATION 
ROTATING 

Definition at line 329 of file G4OpenInventorQtExaminerViewer.hh.

329 {
330 GENERAL,
331 BEAMLINE,
332 VIEWPOINT,
333 ANIMATION,
334 REVERSED_ANIMATION,
335 PAUSED_ANIMATION,
336 ROTATING
337 };

Constructor & Destructor Documentation

◆ G4OpenInventorQtExaminerViewer()

G4OpenInventorQtExaminerViewer::G4OpenInventorQtExaminerViewer ( QWidget * parent = NULL,
const char * name = NULL,
SbBool embed = TRUE,
SoQtFullViewer::BuildFlag flag = BUILD_ALL,
SoQtViewer::Type type = BROWSER )

Definition at line 123 of file G4OpenInventorQtExaminerViewer.cc.

127 : SoQtExaminerViewer(parent, name, embed, flag, type),
128#if 0x060000 <= QT_VERSION
129 fName(name),
130#endif
131 externalQtApp(0), processSoEventCount(0)
132{
133 // FWJ DEBUG
134 // G4cout << "G4OpenInventorQtExaminerViewer CONSTRUCTOR CALLED" << G4endl;
135 // G4cout << "G4OpenInventorQtExaminerViewer parent=" << parent << G4endl;
136
137 // FWJ THIS DOESN'T WORK APPARENTLY NO MAINWINDOW
138 // QMenuBar* menubar = ((QMainWindow*)parent)->menuBar();
139
140#if QT_VERSION < 0x060000
141 fName = new QString(name);
142 viewer = this;
143#endif
144 construct(TRUE);
145}
TRUE
#define TRUE
Definition globals.hh:41

Referenced by animateSensorCB(), animateSensorRotationCB(), G4OpenInventorQtViewer, mouseoverCB(), pickingCB(), sceneChangeCB(), and superimpositionCB().

◆ ~G4OpenInventorQtExaminerViewer()

G4OpenInventorQtExaminerViewer::~G4OpenInventorQtExaminerViewer ( )

Definition at line 148 of file G4OpenInventorQtExaminerViewer.cc.

149{
150 // if (superimposition != NULL) {
151 // removeSuperimposition(superimposition);
152 // superimposition->unref();
153 // superimposition = NULL;
154 // }
155 // if (animateSensor->isScheduled())
156 // animateSensor->unschedule();
157 // delete animateSensor;
158 // delete sceneChangeSensor;
159 // delete[] curViewPtName;
160 // delete searcher;
161
162#if QT_VERSION < 0x060000
163 viewer = 0;
164#else
165 delete hookBeamOn;
166#endif
167}

Member Function Documentation

◆ actualRedraw()

void G4OpenInventorQtExaminerViewer::actualRedraw ( void )
protectedvirtual

Definition at line 1597 of file G4OpenInventorQtExaminerViewer.cc.

1597 {
1598 switch (currentState) {
1599 case ANIMATION:
1600 case REVERSED_ANIMATION:
1601 case PAUSED_ANIMATION:
1602 updateSpeedIndicator();
1603 SoQtExaminerViewer::actualRedraw();
1604 break;
1605 default:
1606 SoQtExaminerViewer::actualRedraw();
1607 break;
1608 }
1609}

◆ addEscapeCallback()

void G4OpenInventorQtExaminerViewer::addEscapeCallback ( void(* cb )())

Definition at line 2647 of file G4OpenInventorQtExaminerViewer.cc.

2648{
2649 escapeCallback = callback;
2650}

◆ addViewPoints()

void G4OpenInventorQtExaminerViewer::addViewPoints ( )
protected

Definition at line 2672 of file G4OpenInventorQtExaminerViewer.cc.

2673{
2674 std::size_t size = viewPtList.size();
2675 if (!size) return;
2676
2677 for (std::size_t i = 0; i < size; ++i) {
2678#if QT_VERSION < 0x060000
2679 new QListWidgetItem(viewPtList[i].viewPtName,
2680 AuxWindowDialog->listWidget);
2681#else
2682 new QListWidgetItem(viewPtList[i].viewPtName.c_str(),
2683 AuxWindowDialog->listWidget);
2684#endif
2685 }
2686}

Referenced by afterRealizeHook().

◆ afterRealizeHook()

void G4OpenInventorQtExaminerViewer::afterRealizeHook ( )
protectedvirtual

Definition at line 693 of file G4OpenInventorQtExaminerViewer.cc.

694{
695 SoQtExaminerViewer::afterRealizeHook();
696#else
697void G4OpenInventorQtExaminerViewer::setupSceneGraph()
698{
699#endif
700 // Default height is used when selecting and viewing scene elements
701 // FWJ Added defaultHeight for Ortho camera
702 SoCamera *cam = getCamera();
703 if (cam) {
704 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
705 defaultHeightAngle =
706 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
707 toggleCameraType();
708 defaultHeight =
709 ((SoOrthographicCamera *) cam)->height.getValue();
710 toggleCameraType();
711 } else {
712 defaultHeight =
713 ((SoOrthographicCamera *) cam)->height.getValue();
714 toggleCameraType();
715 cam = getCamera();
716 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
717 defaultHeightAngle =
718 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
719 toggleCameraType();
720 }
721 }
722
723 // Open the default bookmark file
724 fileIn.open(fileName.c_str());
725 if (!fileIn.fail()) {
726 if (!loadViewPts()) {
727 QMessageBox msgbox;
728 msgbox.setFont(*font);
729 QString messagetxt = "Error reading bookmark file ";
730 messagetxt.append(QString(fileName.c_str()));
731 msgbox.setText(messagetxt);
732 msgbox.exec();
733 } else {
734 // Opens a file without erasing it
735 fileOut.open(fileName.c_str(), std::ios::in);
736 fileOut.seekp(0, std::ios::end); // For appending new data to the end
737 // FWJ DEBUG
738 // G4cout << "afterRealizeHook: opened EXISTING bookmark file"
739 // << G4endl;
740 if (viewPtList.size()) {
741 // FWJ disabled auto-selection of first viewpoint.
742 // Initial view should be user-controllable & not forced
743 // setViewPt();
744 addViewPoints();
745 }
746 }
747 fileIn.close();
748 } else {
749 // Creates a new default bookmark file
750 fileOut.open(fileName.c_str());
751 // FWJ DEBUG
752 // G4cout << "afterRealizeHook: Opened a NEW bookmark file" << G4endl;
753 }
754
755 fileIn.clear();
756
757 SoSeparator* root = (SoSeparator*) (getSceneManager()->getSceneGraph());
758 if (root == NULL)
759 SoDebugError::post("G4OpenInventorQtExaminerViewer::afterRealizeHook", "Root is null.");
760 else {
761 root->addChild(myCam); // For position/orientation calculation during animation
762 }
763
764#if 0x060000 <= QT_VERSION
765 if(root!=nullptr) {
766#endif
767 sceneChangeSensor = new SoNodeSensor;
768 sceneChangeSensor->setFunction(sceneChangeCB);
769 sceneChangeSensor->attach(root);
770 sceneChangeSensor->setData(this);
771
772 ///////////////////////////// MOUSEOVER & PICK /////////////////////
773
774 // Monitor mouseover events for displaying the name of scene elements
775 // An SoEventCallback is needed instead of using the default processSoEvent
776 // because that last one does not provide us with an SoPath to the object
777 // that was picked
778 SoEventCallback *moCB = new SoEventCallback;
779 moCB->addEventCallback(
780 SoLocation2Event::getClassTypeId(),
781 mouseoverCB, static_cast<void *>(this));
782 root->addChild(moCB);
783
784 // Override the default picking mechanism present in G4OpenInventorViewer
785 // because we want abbreviated output when picking a trajectory
786 SoEventCallback *pickCB = new SoEventCallback;
787 pickCB->addEventCallback(
788 SoMouseButtonEvent::getClassTypeId(),
789 pickingCB, static_cast<void *>(this));
790 root->addChild(pickCB);
791#if 0x060000 <= QT_VERSION
792 }
793#endif
794
795 ///////////////////////////// MOUSEOVER & PICK /////////////////////
796
797#if QT_VERSION < 0x060000
798 AuxWindow->show();
799 AuxWindow->raise();
800 AuxWindow->activateWindow();
801
802 auto UI = G4UImanager::GetUIpointer();
803 uiQt = dynamic_cast<G4UIQt*>(UI->GetG4UIWindow());
804 // This explicitly sets the TabWidget as parent before addTab():
805 if (uiQt) {
806 viewerParent = getParentWidget();
807 viewerParent2 = viewerParent->parentWidget();
808 uiQt->AddTabWidget(getParentWidget(), *fName);
809 uiQtTabIndex = uiQt->GetViewerTabWidget()->currentIndex();
810 // attached = TRUE;
811 addAppPushButton(detachButton);
812 }
813#else
814 //G.Barrand: map the AuxWindow "at need", it is done in the SaveViewPtCB.
815 // Having one appearing for each viewer creation is cumbersome.
816 // Also, if "closing" the AuxWindow with the mouse, we have no
817 // way to map it again. Moreover, if done here, on macOS at sartup,
818 // it inactivates the Apple menu bar. An idea: since there is one
819 // AuxWindow per viewer, why not having them as tabs in the UI
820 // tab widget? It will go toward a more compact GUI.
821#endif
822}
G4OpenInventorQtExaminerViewer::mouseoverCB
static void mouseoverCB(void *aThis, SoEventCallback *eventCB)
Definition G4OpenInventorQtExaminerViewer.cc:1335
G4OpenInventorQtExaminerViewer::pickingCB
static void pickingCB(void *aThis, SoEventCallback *eventCB)
Definition G4OpenInventorQtExaminerViewer.cc:1195
G4OpenInventorQtExaminerViewer::sceneChangeCB
static void sceneChangeCB(void *, SoSensor *)
Definition G4OpenInventorQtExaminerViewer.cc:2653
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition G4UImanager.cc:76

◆ animateRefParticle()

void G4OpenInventorQtExaminerViewer::animateRefParticle ( )
protected

Definition at line 2623 of file G4OpenInventorQtExaminerViewer.cc.

2624{
2625 SoCamera *cam = getCamera();
2626
2627 camStartPos = cam->position.getValue();
2628 camStartOrient = cam->orientation.getValue();
2629
2630 if (currentState != BEAMLINE)
2631 setStartingPtForAnimation();
2632
2633 camEndPos = myCam->position.getValue();
2634 camEndOrient = myCam->orientation.getValue();
2635
2636 if (animateSensor->isScheduled())
2637 animateSensor->unschedule();
2638
2639 animateSensor->setBaseTime(SbTime::getTimeOfDay());
2640 animateSensor->setInterval(SbTime(0.02));
2641
2642 animateSensor->schedule();
2643}

Referenced by animateSensorCB(), incSpeed(), and processSoEvent().

◆ animateRefParticleCB()

static void G4OpenInventorQtExaminerViewer::animateRefParticleCB ( )
staticprotected

◆ animateSensorCB()

void G4OpenInventorQtExaminerViewer::animateSensorCB ( void * data,
SoSensor * sensor )
staticprotected

Definition at line 2449 of file G4OpenInventorQtExaminerViewer.cc.

2451{
2452 SbTime curTime = SbTime::getTimeOfDay();
2453 G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*) data;
2454 SoCamera *cam = This->getCamera();
2455 SoTimerSensor* s = (SoTimerSensor*) sensor;
2456
2457 float t = float((curTime - s->getBaseTime()).getValue())
2458 / This->animateBtwPtsPeriod;
2459
2460 if ((t > 1.0f) || (t + s->getInterval().getValue() > 1.0f))
2461 t = 1.0f;
2462 SbBool end = (t == 1.0f);
2463
2464 cam->orientation = SbRotation::slerp(This->camStartOrient, This->camEndOrient, t);
2465 cam->position = This->camStartPos + (This->camEndPos - This->camStartPos) * t;
2466
2467 if (end) {
2468 This->animateSensor->unschedule();
2469
2470 if (This->currentState == ANIMATION) {
2471 if (This->refParticleIdx < (int) (This->refParticleTrajectory.size() - 1))
2472 This->animateRefParticle();
2473 else {
2474 This->animateBtwPtsPeriod = MIN_SPEED;
2475 This->speedStep = START_STEP;
2476 }
2477 }
2478 if (This->currentState == REVERSED_ANIMATION) {
2479 if (This->refParticleIdx >= 1)
2480 This->animateRefParticle();
2481 else {
2482 This->animateBtwPtsPeriod = MIN_SPEED;
2483 This->speedStep = START_STEP;
2484 }
2485 }
2486 }
2487}
G4OpenInventorQtExaminerViewer::G4OpenInventorQtExaminerViewer
G4OpenInventorQtExaminerViewer(QWidget *parent=NULL, const char *name=NULL, SbBool embed=TRUE, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER)
Definition G4OpenInventorQtExaminerViewer.cc:124

Referenced by construct().

◆ animateSensorRotationCB()

void G4OpenInventorQtExaminerViewer::animateSensorRotationCB ( void * data,
SoSensor * sensor )
staticprotected

Definition at line 2416 of file G4OpenInventorQtExaminerViewer.cc.

2418{
2419 SbTime curTime = SbTime::getTimeOfDay();
2420 G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*) data;
2421
2422 SoTimerSensor* s = (SoTimerSensor*) sensor;
2423
2424 float t = float((curTime - s->getBaseTime()).getValue())
2425 / This->animateBtwPtsPeriod;
2426
2427 if ((t > 1.0f) || (t + s->getInterval().getValue() > 1.0f))
2428 t = 1.0f;
2429 SbBool end = (t == 1.0f);
2430
2431 if (end) {
2432 This->animateSensorRotation->unschedule();
2433 if(This->rotCnt) {
2434 // rotations left
2435 This->rotateCamera();
2436 }
2437 else {
2438 // rotation over
2439 This->currentState = This->prevState;
2440 return;
2441 }
2442 }
2443
2444}

Referenced by construct().

◆ buildWidget()

void G4OpenInventorQtExaminerViewer::buildWidget ( QWidget * parent)
protected

Definition at line 449 of file G4OpenInventorQtExaminerViewer.cc.

450{
451 if (!parent)
452 SoDebugError::post("G4OpenInventorQtExaminerViewer::buildWidget",
453 "Error: Parent is null.");
454
455 // Common font for (almost) all widgets
456 font = new QFont;
457 font->setPointSize(12);
458 // This font setting does not propagate to added child widgets - Why?
459 parent->setFont(*font);
460 // This propagates everywhere but would affect UIQt!
461 // QApplication::setFont(*font);
462
463// MENU BAR
464
465#if QT_VERSION < 0x060000
466 menubar = new QMenuBar(getRenderAreaWidget());
467#else
468 menubar = new QMenuBar();
469 menubar->setNativeMenuBar(false);
470 addAppPushButton(menubar);
471#endif
472 // FWJ DEBUG
473 // G4cout << "G4OpenInventorQtExaminerViewer: GOT A menubar=" <<
474 // menubar << G4endl;
475
476 filemenu = new QMenu("File");
477 menubar->addMenu(filemenu);
478
479 FileOpenBookmark = new QAction("Open Bookmark File", this);
480 FileOpenBookmark->setFont(*font);
481 connect(FileOpenBookmark, SIGNAL(triggered()), this,
482 SLOT(FileOpenBookmarkCB()));
483 filemenu->addAction(FileOpenBookmark);
484
485 FileNewBookmark = new QAction("New Bookmark File", this);
486 FileNewBookmark->setFont(*font);
487 connect(FileNewBookmark, SIGNAL(triggered()), this,
488 SLOT(FileNewBookmarkCB()));
489 filemenu->addAction(FileNewBookmark);
490
491 FileLoadRefPath = new QAction("Load Reference Path", this);
492 FileLoadRefPath->setFont(*font);
493 connect(FileLoadRefPath, SIGNAL(triggered()), this,
494 SLOT(FileLoadRefPathCB()));
495 filemenu->addAction(FileLoadRefPath);
496
497 FileSaveRefPath = new QAction("Save Reference Path", this);
498 FileSaveRefPath->setFont(*font);
499 connect(FileSaveRefPath, SIGNAL(triggered()), this,
500 SLOT(FileSaveRefPathCB()));
501 filemenu->addAction(FileSaveRefPath);
502
503 FileLoadSceneGraph = new QAction("Load scene graph", this);
504 FileLoadSceneGraph->setFont(*font);
505 connect(FileLoadSceneGraph, SIGNAL(triggered()), this,
506 SLOT(FileLoadSceneGraphCB()));
507 filemenu->addAction(FileLoadSceneGraph);
508
509 FileSaveSceneGraph = new QAction("Save scene graph", this);
510 FileSaveSceneGraph->setFont(*font);
511 connect(FileSaveSceneGraph, SIGNAL(triggered()), this,
512 SLOT(FileSaveSceneGraphCB()));
513 filemenu->addAction(FileSaveSceneGraph);
514
515 // Rest of File menu is done in G4OpenInventorQtViewer
516
517 toolsmenu = new QMenu("Tools");
518 menubar->addMenu(toolsmenu);
519
520 ToolsAnimateRefParticle = new QAction("Fly on Ref Path", this);
521 ToolsAnimateRefParticle->setFont(*font);
522 connect(ToolsAnimateRefParticle, SIGNAL(triggered()), this,
523 SLOT(ToolsAnimateRefParticleCB()));
524 toolsmenu->addAction(ToolsAnimateRefParticle);
525
526 ToolsRefPathStart = new QAction("Go to start of Ref Path", this);
527 ToolsRefPathStart->setFont(*font);
528 connect(ToolsRefPathStart, SIGNAL(triggered()), this,
529 SLOT(ToolsRefPathStartCB()));
530 toolsmenu->addAction(ToolsRefPathStart);
531
532 ToolsRefPathInvert = new QAction("Invert Ref Path", this);
533 ToolsRefPathInvert->setFont(*font);
534 connect(ToolsRefPathInvert, SIGNAL(triggered()), this,
535 SLOT(ToolsRefPathInvertCB()));
536 toolsmenu->addAction(ToolsRefPathInvert);
537
538 etcmenu = new QMenu("Etc");
539 menubar->addMenu(etcmenu);
540
541 // All Etc menu items are done in G4OpenInventorQtViewer
542
543 helpmenu = new QMenu("Help");
544 menubar->addMenu(helpmenu);
545
546 HelpControls = new QAction("Controls", this);
547 HelpControls->setFont(*font);
548 connect(HelpControls, SIGNAL(triggered()), this, SLOT(HelpControlsCB()));
549 helpmenu->addAction(HelpControls);
550
551#if QT_VERSION < 0x060000
552 menubar->show();
553#endif
554
555 // SoQtExaminerViewer::buildWidget(parent);
556
557 // APP VIEWER BUTTONS have their own box on upper left
558 // The built in viewer button list is PRIVATE
559
560 saveViewPtButton = new QPushButton;
561 saveViewPtButton->setIcon(QPixmap((const char **)saveViewPt_xpm));
562 saveViewPtButton->setIconSize(QSize(24,24));
563 saveViewPtButton->setToolTip("Bookmark this view");
564 connect(saveViewPtButton, SIGNAL(clicked()), this,
565 SLOT(SaveViewPtCB()));
566 addAppPushButton(saveViewPtButton);
567
568 nextViewPtButton = new QPushButton;
569 nextViewPtButton->setIconSize(QSize(24,24));
570 QCommonStyle style;
571 nextViewPtButton->setIcon(style.standardIcon(QStyle::SP_ArrowRight));
572 nextViewPtButton->setToolTip("Next bookmark");
573 connect(nextViewPtButton, SIGNAL(clicked()), this,
574 SLOT(NextViewPtCB()));
575 addAppPushButton(nextViewPtButton);
576
577 prevViewPtButton = new QPushButton;
578 prevViewPtButton->setIconSize(QSize(24,24));
579 prevViewPtButton->setIcon(style.standardIcon(QStyle::SP_ArrowLeft));
580 prevViewPtButton->setToolTip("Previous bookmark");
581 connect(prevViewPtButton, SIGNAL(clicked()), this,
582 SLOT(PrevViewPtCB()));
583 addAppPushButton(prevViewPtButton);
584
585 abbrOutputButton = new QPushButton;
586 abbrOutputButton->setCheckable(true);
587 abbrOutputButton->setIconSize(QSize(24,24));
588 abbrOutputButton->setIcon(QPixmap((const char **)pickext_xpm));
589 abbrOutputButton->setToolTip("Extended picking & readout");
590 connect(abbrOutputButton, SIGNAL(toggled(bool)), this,
591 SLOT(AbbrOutputCB(bool)));
592 addAppPushButton(abbrOutputButton);
593
594 pickRefPathButton = new QPushButton;
595 pickRefPathButton->setIconSize(QSize(24,24));
596 pickRefPathButton->setIcon(QPixmap((const char **)pickref_xpm));
597 pickRefPathButton->setToolTip("Pick ref trajectory");
598 connect(pickRefPathButton, SIGNAL(clicked()), this,
599 SLOT(PickRefPathCB()));
600 addAppPushButton(pickRefPathButton);
601
602 switchWireFrameButton = new QPushButton;
603 switchWireFrameButton->setCheckable(true);
604 switchWireFrameButton->setIconSize(QSize(24,24));
605 switchWireFrameButton->setIcon(QPixmap((const char **)wireframe_xpm));
606 switchWireFrameButton->setToolTip("Switch wireframe/solid");
607 connect(switchWireFrameButton, SIGNAL(toggled(bool)), this,
608 SLOT(SwitchWireFrameCB(bool)));
609 addAppPushButton(switchWireFrameButton);
610
611 switchAxesButton = new QPushButton;
612 switchAxesButton->setCheckable(true);
613 switchAxesButton->setText(QString("A"));
614 switchAxesButton->setToolTip("Axes on/off");
615 connect(switchAxesButton, SIGNAL(toggled(bool)), this,
616 SLOT(SwitchAxesCB(bool)));
617 addAppPushButton(switchAxesButton);
618
619 detachButton = new QPushButton;
620 detachButton->setIconSize(QSize(24,24));
621 detachButton->setIcon(style.standardIcon(QStyle::SP_CommandLink));
622 detachButton->setToolTip("Detach viewer window");
623 connect(detachButton, SIGNAL(clicked()), this,
624 SLOT(DetachCB()));
625 // Used for UIQt only so check and add later
626 // addAppPushButton(detachButton);
627
628 // HELP WINDOW
629
630 helpmsgbox = new QMessageBox(getParentWidget());
631 helpmsgbox->setWindowTitle("OIQt Controls");
632 helpmsgbox->setFont(*font);
633 QString messagetxt =
634"\nVIEWING mode (Hand cursor):\n\n\
635 Left-button + pointer move: rotate\n\
636 Shift+Left-button + pointer move: pan\n\
637 Middle-button + pointer move: pan\n\
638 Ctrl+Shift+Left-button + pointer move: zoom\n\
639 Mouse wheel: zoom\n\
640 Right-button: popup menu\n\n\
641PICKING mode (Arrow cursor):\n\n\
642 Click on a volume: geometry readout\n\
643 Click on a trajectory: particle & trajectory readout\n\
644 Ctrl + click on a volume: see daughters.\n\
645 Shift + click on a volume: see mother.\n\n\
646EXTENDED PICKING mode (Arrow+ viewer button):\n\n\
647 Hover the mouse over a volume or trajectory for\n\
648 overlayed readout.\n\n\
649ELEMENT NAVIGATION (requires Reference Path):\n\n\
650 Click on element in list: centers view on element\n\
651 Arrow keys: rotate in 90 degree steps around element \n\
652 Shift + Right Arrow: move to next element\n\
653 Shift + Left Arrow: move to previous element\n\n\
654FLY mode (requires Reference Path):\n\n\
655 Page Up: Increase speed\n\
656 Page Down: Decrease speed (& reverse if wanted)\n\
657 Up Arrow: raise camera above path\n\
658 Down Arror: lower camera below path\n\
659 Escape: Exit fly mode";
660 helpmsgbox->setText(messagetxt);
661 helpmsgbox->setModal(false);
662 // helpmsgbox->setWindowModality(Qt::NonModal);
663
664 // AUXILIARY LISTS WINDOW
665
666 // Bypass the namespace in order to make a persistent object
667 AuxWindowDialog = new Ui_Dialog;
668 AuxWindow = new QDialog(parent);
669 AuxWindowDialog->setupUi(AuxWindow);
670
671 // SIGNALS
672 connect(AuxWindowDialog->listWidget, SIGNAL(itemClicked(QListWidgetItem*)),
673 this, SLOT(LoadBookmarkCB(QListWidgetItem*)));
674 connect(AuxWindowDialog->listWidget1, SIGNAL(itemClicked(QListWidgetItem*)),
675 this, SLOT(LookAtSceneElementCB(QListWidgetItem*)));
676 connect(AuxWindowDialog->pushButton_2, SIGNAL(clicked()),
677 this, SLOT(DeleteBookmarkCB()));
678 connect(AuxWindowDialog->pushButton_3, SIGNAL(clicked()),
679 this, SLOT(RenameBookmarkCB()));
680 connect(AuxWindowDialog->pushButton, SIGNAL(clicked()),
681 this, SLOT(SortBookmarksCB()));
682
683 // FWJ Better to do this after viewer window is realized
684 // AuxWindow->show();
685 // AuxWindow->raise();
686 // AuxWindow->activateWindow();
687}

Referenced by construct().

◆ cleanUpAfterPrevFile()

void G4OpenInventorQtExaminerViewer::cleanUpAfterPrevFile ( )
protected

Definition at line 2756 of file G4OpenInventorQtExaminerViewer.cc.

2757{
2758 viewPtIdx = -1;
2759 viewPtList.clear();
2760 // setSuperimpositionEnabled(superimposition, FALSE);
2761 // scheduleRedraw();
2762 currentState = GENERAL;
2763 if (fileOut.is_open()) fileOut.close();
2764
2765 AuxWindowDialog->listWidget->clear();
2766 AuxWindowDialog->lineEdit->setText(QString(""));
2767}

◆ construct()

void G4OpenInventorQtExaminerViewer::construct ( const SbBool build)
protected

Definition at line 170 of file G4OpenInventorQtExaminerViewer.cc.

171{
172 setFeedbackSize(40);
173
174 hookBeamOn = new HookEventProcState(this);
175 newEvents = false;
176
177 buildWidget(getParentWidget());
178
179 fileName = "bookmarkFile"; // Default viewpoint file name
180 viewPtIdx = -1; // index of the most recent viewpoint in viewPtList vector
181
182 animateSensor = new SoTimerSensor(animateSensorCB, this);
183 animateSensorRotation = new SoTimerSensor(animateSensorRotationCB, this);
184 animateBtwPtsPeriod = MIN_SPEED;
185
186 currentState = GENERAL;
187 myCam = new SoPerspectiveCamera;
188 MAX_VP_IDX = 3;
189 MAX_VP_NAME = 35; // Max length of a viewpoint name, padded with spaces
190#if QT_VERSION < 0x060000
191 curViewPtName = new char[MAX_VP_NAME + 1];
192#else
193 curViewPtName.clear();
194#endif
195 left_right = up_down = 0; // For movements around the beam during animation
196 speedStep = START_STEP; // For smoother animation speed increase/decrease
197 rotUpVec = false; // Used during scene element rotations
198 step = 1; //By default
199 // Used for moving along the beam with the
200 // mouse instead of rotating the view
201 lshiftdown = rshiftdown = false;
202 // Used for rotating the view with the camera
203 // staying in place
204 lctrldown = rctrldown = false;
205 // Used to send abbreviated output to the console when
206 abbrOutputFlag = false;
207 pickRefPathFlag = false;
208 prevColorField = NULL;
209 // warningFlag = false; // We come from the warning dialog
210 // myElementList = NULL;
211 // FWJ default path look-ahead
212 pathLookahead = 5;
213
214 newSceneGraph = NULL;
215 zcoordSetFlag = false;
216
217 //////////////////////////SUPERIMPOSED SCENE//////////////////////////
218 searcher = NULL;
219 // Used in animation; progressively scaled for gradual speed change
220 maxSpeed = 0.0f;
221
222 static const char * superimposed[] = {
223 "#Inventor V2.1 ascii", "",
224 "Separator ",
225 "{",
226 " MaterialBinding ",
227 " {",
228 " value OVERALL",
229 " }",
230 " OrthographicCamera ",
231 " {",
232 " height 1",
233 " nearDistance 0",
234 " farDistance 1",
235 " }",
236 " DEF soxt->callback Callback { }",
237 " Separator ",
238 " {",
239 " DEF soxt->translation Translation ",
240 " {",
241 " translation 0 0 0",
242 " }",
243 " DEF soxt->scale Scale ",
244 " {",
245 " scaleFactor 1 1 1",
246 " }",
247 " DEF soxt->geometry Coordinate3 ",
248 " {",
249 " point ",
250 " [",
251 " -0.81 -0.04 0, -0.81 0 0,",
252 " -0.81 0.04 0, 0 -0.04 0,",
253 " 0 0 0, 0 0.04 0,",
254 " 0.81 -0.04 0, 0.81 0 0,",
255 " 0.81 0.04 0,",
256 " 0 0.02 0,", // idx 9
257 " 0.81 0.02 0, 0.81 -0.02 0,",
258 " 0 -0.02 0,",
259 " 0 0.01 0,", // idx 13
260 " 0.4 0.01 0, 0.4 -0.01 0,",
261 " 0 -0.01 0",
262 " ]",
263 " }",
264 // current speed indicator (outline)
265 " DEF soxt->animSpeedOutlineSwitch Switch ",
266 " {",
267 " whichChild -3",
268 " Material ",
269 " {",
270 " emissiveColor 0 0 0",
271 " }",
272 " IndexedFaceSet ",
273 " {",
274 " coordIndex ",
275 " [",
276 " 12, 11, 10, 9, -1",
277 " ]",
278 " }",
279 " }",
280 // the coordinate system
281 " DEF soxt->axisSwitch Switch ",
282 " {",
283 " whichChild -3",
284 " BaseColor ",
285 " {",
286 " rgb 1 1 1",
287 " }",
288 " IndexedLineSet ",
289 " {",
290 " coordIndex ",
291 " [",
292 " 0, 2, -1,",
293 " 3, 5, -1,",
294 " 6, 8, -1,",
295 " 1, 7, -1",
296 " ]",
297 " }",
298 " }",
299 // current speed indicator
300 " DEF soxt->animSpeedSwitch Switch ",
301 " {",
302 " whichChild -3",
303 " Material ",
304 " {",
305 " emissiveColor 0 1 0",
306 " }",
307 " IndexedFaceSet ",
308 " {",
309 " coordIndex ",
310 " [",
311 " 16, 15, 14, 13, -1",
312 " ]",
313 " }",
314 " }",
315 " }",
316 // For displaying either z position (during animation) or current viewpoint name
317 " DEF soxt->curInfoSwitch Switch ",
318 " {",
319 " whichChild -3",
320 " DEF soxt->curInfoTrans Translation ",
321 " {",
322 " translation 0 0 0 ",
323 // " translation 10 20 30 ",
324 " }",
325 " DEF soxt->curInfoFont Font ",
326 " {",
327 " name defaultFont:Bold",
328 " size 16",
329 " }",
330 " DEF soxt->curInfoText Text2 ",
331 " {",
332 " string Hello",
333 " }",
334 " }",
335 // Need to use different fields for mouseover
336 // because newlines are ignored when the scene is rendered
337 " Separator ",
338 " {",
339 " DEF soxt->mouseOverTransLogName Translation ",
340 " {",
341 " translation 0 0 0 ",
342 " }",
343 " DEF soxt->mouseOverFontLogName Font ",
344 " {",
345 " name defaultFont:Bold",
346 " size 16",
347 " }",
348 " DEF soxt->mouseOverTextLogName Text2 { } ",
349 " }",
350 " Separator ",
351 " {",
352 " DEF soxt->mouseOverTransSolid Translation ",
353 " {",
354 " translation 0 0 0 ",
355 " }",
356 " DEF soxt->mouseOverFontSolid Font ",
357 " {",
358 " name defaultFont:Bold",
359 " size 16",
360 " }",
361 " DEF soxt->mouseOverTextSolid Text2 { } ",
362 " }",
363 " Separator ",
364 " {",
365 " DEF soxt->mouseOverTransMaterial Translation ",
366 " {",
367 " translation 0 0 0 ",
368 " }",
369 " DEF soxt->mouseOverFontMaterial Font ",
370 " {",
371 " name defaultFont:Bold",
372 " size 16",
373 " }",
374 " DEF soxt->mouseOverTextMaterial Text2 { } ",
375 " }",
376 " Separator ",
377 " {",
378 " DEF soxt->mouseOverTransZPos Translation ",
379 " {",
380 " translation 0 0 0 ",
381 " }",
382 " DEF soxt->mouseOverFontZPos Font ",
383 " {",
384 " name defaultFont:Bold",
385 " size 16",
386 " }",
387 " DEF soxt->mouseOverTextZPos Text2 { } ",
388 " }",
389 "}", NULL
390 };
391
392 int i, bufsize;
393 for (i = bufsize = 0; superimposed[i]; i++)
394 bufsize += strlen(superimposed[i]) + 1;
395 char * buf = new char[bufsize + 1];
396 for (i = bufsize = 0; superimposed[i]; i++) {
397 strcpy(buf + bufsize, superimposed[i]);
398 bufsize += strlen(superimposed[i]);
399 buf[bufsize] = '\n';
400 bufsize++;
401 }
402 SoInput * input = new SoInput;
403 input->setBuffer(buf, bufsize);
404 SbBool ok = SoDB::read(input, superimposition);
405 (void)ok; // FWJ added to avoid compiler warning
406 assert(ok);
407 delete input;
408 delete[] buf;
409 superimposition->ref();
410
411 sscale = (SoScale *) getSuperimpositionNode(superimposition, "soxt->scale");
412 stranslation = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->translation");
413 sgeometry = (SoCoordinate3 *) getSuperimpositionNode(superimposition, "soxt->geometry");
414 axisSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->axisSwitch");
415 animSpeedOutlineSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->animSpeedOutlineSwitch");
416 animSpeedSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->animSpeedSwitch");
417 curInfoSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->curInfoSwitch");
418 curInfoTrans = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->curInfoTrans");
419 curInfoFont = (SoFont *) getSuperimpositionNode(superimposition, "soxt->curInfoFont");
420 curInfoText = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->curInfoText");
421 mouseOverTransLogName = (SoTranslation*)getSuperimpositionNode(superimposition, "soxt->mouseOverTransLogName");
422 mouseOverFontLogName = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontLogName");
423 mouseOverTextLogName = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextLogName");
424 mouseOverTransSolid = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->mouseOverTransSolid");
425 mouseOverFontSolid = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontSolid");
426 mouseOverTextSolid = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextSolid");
427 mouseOverTransMaterial = (SoTranslation*)getSuperimpositionNode(superimposition, "soxt->mouseOverTransMaterial");
428 mouseOverFontMaterial = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontMaterial");
429 mouseOverTextMaterial = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextMaterial");
430 mouseOverTransZPos = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->mouseOverTransZPos");
431 mouseOverFontZPos = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontZPos");
432 mouseOverTextZPos = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextZPos");
433
434 SoCallback * cb = (SoCallback *) getSuperimpositionNode(superimposition, "soxt->callback");
435 cb->setCallback(superimpositionCB, this);
436
437 addSuperimposition(superimposition);
438 setSuperimpositionEnabled(superimposition, FALSE);
439 axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
440 animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
441 animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
442
443 /////////////////////\SUPERIMPOSED SCENE///////////////////////////////////
444
445}
G4OpenInventorQtExaminerViewer::superimpositionCB
static void superimpositionCB(void *closure, SoAction *action)
Definition G4OpenInventorQtExaminerViewer.cc:855
G4OpenInventorQtExaminerViewer::animateSensorRotationCB
static void animateSensorRotationCB(void *, SoSensor *)
Definition G4OpenInventorQtExaminerViewer.cc:2416
G4OpenInventorQtExaminerViewer::getSuperimpositionNode
SoNode * getSuperimpositionNode(SoNode *, const char *name)
Definition G4OpenInventorQtExaminerViewer.cc:838
G4OpenInventorQtExaminerViewer::animateSensorCB
static void animateSensorCB(void *, SoSensor *)
Definition G4OpenInventorQtExaminerViewer.cc:2449
FALSE
#define FALSE
Definition globals.hh:38

Referenced by G4OpenInventorQtExaminerViewer().

◆ createElementsList()

void G4OpenInventorQtExaminerViewer::createElementsList ( )
protected

Definition at line 2050 of file G4OpenInventorQtExaminerViewer.cc.

2051{
2052 // FWJ DEBUG
2053 // G4cout << "Populating ELEMENT LIST..." << G4endl;
2054
2055 AuxWindowDialog->listWidget1->clear();
2056 // int size = sceneElements.size();
2057
2058 std::vector<sceneElement>::const_iterator it;
2059 std::stringstream ss;
2060
2061 for(it=sceneElements.begin(); it!=sceneElements.end(); ++it) {
2062 ss << it->name;
2063 if(zcoordSetFlag)
2064 ss << " [" << it->closestPointZCoord << "]";
2065
2066 new QListWidgetItem(ss.str().c_str(), AuxWindowDialog->listWidget1);
2067 ss.str("");
2068 }
2069}

Referenced by sortElements().

◆ decSpeed()

void G4OpenInventorQtExaminerViewer::decSpeed ( )
protected

Definition at line 1555 of file G4OpenInventorQtExaminerViewer.cc.

1555 {
1556 animateBtwPtsPeriod += speedStep;
1557 if (animateBtwPtsPeriod < MIN_SPEED) {
1558 if (std::floor(animateBtwPtsPeriod * 100) == 12) { // Errors in double representation
1559 speedStep = 0.08;
1560 } else if (animateBtwPtsPeriod > 0.12)
1561 speedStep += 0.02;
1562 } else {
1563 animateBtwPtsPeriod = MIN_SPEED;
1564 speedStep = START_STEP;
1565 maxSpeed = 0.0f;
1566 if (animateSensor->isScheduled())
1567 animateSensor->unschedule();
1568 }
1569}

Referenced by processSoEvent().

◆ deleteViewPt()

void G4OpenInventorQtExaminerViewer::deleteViewPt ( char * vpName = NULL)
protected

Definition at line 3317 of file G4OpenInventorQtExaminerViewer.cc.

3318{
3319 std::string line;
3320 std::size_t end;
3321 fileIn.open(fileName.c_str());
3322 std::ofstream out("temporaryFile.txt");
3323
3324#if QT_VERSION < 0x060000
3325 if (!vpName)
3326 vpName = viewPtList[viewPtIdx].viewPtName;
3327#endif
3328
3329 getline(fileIn, line); // Printing the viewpoint idx
3330 out << line << "\n";
3331
3332 while (getline(fileIn, line)) {
3333 end = line.find_last_not_of(' ');
3334 line = line.substr(0, end + 1);
3335 if (!strcmp(line.c_str(), vpName)) { // Equal
3336 while (line.size()) {
3337 getline(fileIn, line);
3338 }
3339
3340 while (getline(fileIn, line))
3341 out << line << "\n";
3342 } else {
3343 while (line.size()) {
3344 out << line << "\n";
3345 getline(fileIn, line);
3346 }
3347 out << "\n";
3348 }
3349 }
3350
3351 std::size_t idx = 0; // Remove viewpoint from the vector
3352 std::size_t size = viewPtList.size();
3353 while (idx < size) {
3354#if QT_VERSION < 0x060000
3355 if (!strcmp(viewPtList[idx].viewPtName, vpName)) {
3356#else
3357 if (!strcmp(viewPtList[idx].viewPtName.c_str(), vpName)) {
3358#endif
3359 viewPtList.erase(viewPtList.begin() + idx);
3360 break;
3361 }
3362 idx++;
3363 }
3364
3365 out.close();
3366 fileOut.close();
3367 fileIn.clear();
3368 fileIn.close();
3369
3370 // FWJ check return status: error popups needed here
3371 int istat = remove(fileName.c_str());
3372 if (istat == -1) {
3373 QMessageBox msgbox;
3374 msgbox.setFont(*font);
3375 QString messagetxt = "Error removing bookmarks file";
3376 // messagetxt.append(filenamein);
3377 msgbox.setText(messagetxt);
3378 msgbox.exec();
3379 // G4cout << "Error removing bookmarks file" << G4endl;
3380 }
3381 istat = rename("temporaryFile.txt", fileName.c_str());
3382 if (istat == -1) {
3383 QMessageBox msgbox;
3384 msgbox.setFont(*font);
3385 QString messagetxt = "Error renaming bookmarks file";
3386 // messagetxt.append(filenamein);
3387 msgbox.setText(messagetxt);
3388 msgbox.exec();
3389 // G4cout << "Error renaming bookmarks file" << G4endl;
3390 }
3391 fileOut.open(fileName.c_str(), std::ios::in);
3392 fileOut.seekp(0, std::ios::end);
3393
3394 if (!viewPtList.size()) { // viewPtList is empty
3395#if QT_VERSION < 0x060000
3396 curViewPtName = (char *) empty.c_str();
3397#else
3398 curViewPtName.clear();
3399#endif
3400 scheduleRedraw();
3401 } else {
3402 if (viewPtIdx >= (int) viewPtList.size())
3403 viewPtIdx--;
3404 writeViewPtIdx();
3405 setViewPt();
3406 }
3407}

◆ distanceToTrajectory()

void G4OpenInventorQtExaminerViewer::distanceToTrajectory ( const SbVec3f & q,
float & dist,
SbVec3f & closestPoint,
int & index )
protected

Definition at line 1885 of file G4OpenInventorQtExaminerViewer.cc.

1889{
1890 // a : Previous point on trajectory
1891 // b : Next point on trajectory
1892 // q : the point in space
1893 // dab, daq, dbq: distance between a & b, a & q, b & q
1894 //
1895 // Theory: A point p on a line ab is defined as:
1896 //
1897 // p(t) = a+t?(b?a)
1898 //
1899 // note: All are vectors except the parameter t
1900 //
1901 // When t is between 0 and 1 the point p is situated between a and b on ab.
1902 // The point p is defined in terms of the parameter t, subsequently so does
1903 // the distance from the query point q to the point p. To find the minimum
1904 // of that distance we differentiate it and set equal to zero:
1905 //
1906 // diff(Norm(p(t)- q)) = 0
1907 //
1908 // note: diff means taking the derivative with regard to t
1909 //
1910 // The resulting t is given in the code below. The square of the distance
1911 // between p and q is given by:
1912 //
1913 // d^2 = (Norm(p(t)-q))^2
1914 //
1915 // The expression found is given in the code below (current_dist)
1916 //
1917 // Ref: http://programmizm.sourceforge.net/blog/2012/
1918 // distance-from-a-point-to-a-polyline
1919 //
1920 // --PLG
1921
1922 const std::size_t count = refParticleTrajectory.size();
1923 assert(count>0);
1924
1925 SbVec3f b = refParticleTrajectory[0];
1926 SbVec3f dbq = b - q;
1927 float sqrDist = sqrlen(dbq);
1928 closestPoint = b;
1929 index = 0;
1930 for (std::size_t i = 1; i < count; ++i) {
1931 const SbVec3f a = b;
1932 const SbVec3f daq = dbq;
1933 b = refParticleTrajectory[i];
1934 dbq = b - q;
1935 const SbVec3f dab = a - b;
1936
1937 float dab_x, dab_y, dab_z;
1938 dab.getValue(dab_x,dab_y,dab_z);
1939 float daq_x, daq_y, daq_z;
1940 daq.getValue(daq_x, daq_y, daq_z);
1941 float dbq_x, dbq_y, dbq_z;
1942 dbq.getValue(dbq_x, dbq_y, dbq_z);
1943
1944 const float inv_sqrlen = 1./sqrlen(dab);
1945 const float t = (dab_x*daq_x + dab_y*daq_y + dab_z*daq_z)*inv_sqrlen;
1946
1947 if (t<0.) {
1948 // The trajectory point occurs before point a
1949 // Go to the next point
1950 continue;
1951 }
1952 float current_dist;
1953 if (t<=1.) {
1954 // The trajectory point occurs between a and b.
1955 // Compute the distance to that point
1956 current_dist = daq_x*daq_x + daq_y*daq_y + daq_z*daq_z
1957 - t*(daq_x*dab_x + daq_y*dab_y + daq_z*dab_z)
1958 + t*t*(dab_x*dab_x + dab_y*dab_y + dab_z*dab_z);
1959 }
1960 else { //t>1.
1961 // The trajectory point occurs after b.
1962 // Get the distance to point b
1963 current_dist = sqrlen(dbq);
1964 }
1965
1966 if (current_dist < sqrDist) {
1967 sqrDist = current_dist;
1968 closestPoint = a + t*(b-a);
1969 index = (int) i;
1970 }
1971 }
1972
1973 dist = std::sqrt(sqrDist);
1974}

Referenced by sortElements().

◆ evenOutRefParticlePts()

void G4OpenInventorQtExaminerViewer::evenOutRefParticlePts ( )
protected

Definition at line 2303 of file G4OpenInventorQtExaminerViewer.cc.

2304{
2305 if(refParticleTrajectory.empty())
2306 return;
2307
2308 SbVec3f p1, p2, p3, dirNow, dirNxt, dir, p2_tmp, p_start, p_corner, p_nxt;
2309 float avgDistBtwPts = 0;
2310 float totalDistBtwPts = 0;
2311 std::vector<SbVec3f> newRefParticleTrajectory;
2312 SbVec3f refPoint;
2313 std::size_t size = refParticleTrajectory.size() - 1;
2314 int numOfPts = 0;
2315 for (std::size_t i = 0; i < size; ++i) {
2316 p1 = refParticleTrajectory[i];
2317 p2 = refParticleTrajectory[i + 1];
2318 if (p1 == p2)
2319 continue;
2320 numOfPts++;
2321 totalDistBtwPts += (p2 - p1).length();
2322 }
2323 // Nothing useful to do (and fix Coverity)
2324 if (numOfPts <= 2) return;
2325
2326 avgDistBtwPts = totalDistBtwPts / numOfPts;
2327 float minDistAllowed = 0.75 * avgDistBtwPts;
2328 // float maxDistAllowed = 1.25 * avgDistBtwPts; // Pts tend to be close not far
2329
2330 float x, y, z;
2331 std::size_t i = 0, j = 0;
2332 while (i < size) {
2333 p1 = refParticleTrajectory[i];
2334 p2 = refParticleTrajectory[i + 1];
2335
2336 refPoint = p1;
2337 p1.getValue(x, y, z);
2338
2339 newRefParticleTrajectory.push_back(refPoint);
2340
2341 j = i;
2342 while ((p2 - p1).length() < minDistAllowed && j < (size - 1)) {
2343 j++;
2344
2345 p1 = refParticleTrajectory[j];
2346 p2 = refParticleTrajectory[j + 1];
2347 }
2348 if (j != i)
2349 i = j + 1;
2350 else
2351 i++;
2352 }
2353
2354 refParticleTrajectory.clear();
2355 refParticleTrajectory = newRefParticleTrajectory;
2356}

Referenced by setReferencePath().

◆ findAndSetRefPath()

void G4OpenInventorQtExaminerViewer::findAndSetRefPath ( )
protected

Definition at line 1656 of file G4OpenInventorQtExaminerViewer.cc.

1657{
1658 SoSearchAction action;
1659 action.setType(SoLineSet::getClassTypeId(),false);
1660 action.setInterest(SoSearchAction::ALL);
1661 action.apply(getSceneGraph());
1662
1663 SoPathList &pathList = action.getPaths();
1664
1665 if(pathList.getLength() != 0) {
1666
1667 SoCoordinate3 * coords = NULL;
1668 std::vector<SoCoordinate3 *> coordvec;
1669 std::vector<SoLineSet *> linevec;
1670
1671 bool refPathFound = false;
1672 for(int i = 0; i < pathList.getLength(); ++i) {
1673 SoFullPath *path = (SoFullPath *)pathList[i];
1674
1675 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(path->getTail());
1676 if(attHolder != nullptr)
1677 {
1678 for (std::size_t j = 0; j < attHolder->GetAttDefs().size(); ++j) {
1679 std::ostringstream oss;
1680 oss << G4AttCheck(attHolder->GetAttValues()[j],
1681 attHolder->GetAttDefs()[j]);
1682
1683 std::string findStr = "Type of trajectory (Type): ";
1684 std::string compareValue = "REFERENCE";
1685 std::size_t idx = oss.str().find(findStr);
1686
1687 if(idx != std::string::npos) {
1688 if(oss.str().substr(idx + findStr.size(),
1689 compareValue.size()) == compareValue) {
1690 coords = getCoordsNode(path);
1691 if(coords != NULL) {
1692 refPathFound = true;
1693 coordvec.push_back(coords);
1694 linevec.push_back((SoLineSet *)path->getTail());
1695 }
1696 break;
1697 }
1698 }
1699
1700 findStr = "Track ID (ID): ";
1701 idx = oss.str().find(findStr);
1702 if(idx != std::string::npos) {
1703 //index all primary tracks
1704 std::string tmpstr = oss.str().substr(idx + findStr.size(),1);
1705 std::istringstream buffer(tmpstr);
1706 int num;
1707 buffer >> num;
1708 if(num == 1) {
1709
1710 // Check if next character is a number,
1711 // in which case we don't have Track ID 1
1712 // FWJ attempt to fix Coverity issue.
1713 char nextChar = oss.str().at(idx+findStr.size()+1);
1714 // const char * nextChar =
1715 // oss.str().substr(idx + findStr.size() + 1,1).c_str();
1716 if(std::isdigit(nextChar))
1717 break; //Not a primary track, continue with next track
1718
1719 coords = getCoordsNode(path);
1720 if(coords != NULL) {
1721 coordvec.push_back(coords);
1722 linevec.push_back((SoLineSet *)path->getTail());
1723 break; //Found coords node, continue with next track
1724 }
1725 }
1726 else
1727 break; //Not a primary track, continue with next track
1728 }
1729 else{
1730 //Not a Track ID attribute, fall through
1731 }
1732 }
1733 }
1734
1735 if(refPathFound)
1736 break;
1737 }
1738
1739 if(coordvec.empty())
1740 return; //No track with a Coordinate3 node found
1741
1742 if(refPathFound) {
1743 //set ref path to last traj, coord in the vecs
1744 setReferencePath(linevec.back(), coordvec.back());
1745 return;
1746 }
1747 //else
1748
1749 int longestIdx = 0;
1750 float longestLength = 0.0;
1751 // For all paths
1752 for(unsigned int i=0;i < linevec.size(); ++i) {
1753
1754 //First generate a vector with all the points in this lineset
1755 std::vector<SbVec3f> trajectory;
1756 // For all lines in the i path
1757 for(int j=0; j < linevec[i]->numVertices.getNum(); ++j) {
1758 // For all points in line j
1759 for(int k=0; k < linevec[i]->numVertices[j]; ++k) {
1760 trajectory.push_back(coordvec[i]->point[k]);
1761 }
1762 }
1763
1764 // Then calculate the total length
1765 float tmpLength=0.0;
1766 for(unsigned int j=0; j < trajectory.size() - 1; ++j) {
1767 tmpLength += (trajectory[j] - trajectory[j + 1]).length();
1768 }
1769
1770 if(tmpLength > longestLength) {
1771 longestIdx = i;
1772 longestLength = tmpLength;
1773 }
1774 }
1775
1776 // Set the longest path as the reference path
1777 setReferencePath(linevec[longestIdx], coordvec[longestIdx]);
1778 }
1779}
G4AttHolder::GetAttValues
const std::vector< const std::vector< G4AttValue > * > & GetAttValues() const
Definition G4AttHolder.hh:61
G4AttHolder::GetAttDefs
const std::vector< const std::map< G4String, G4AttDef > * > & GetAttDefs() const
Definition G4AttHolder.hh:63
G4OpenInventorQtExaminerViewer::getCoordsNode
SoCoordinate3 * getCoordsNode(SoFullPath *path)
Definition G4OpenInventorQtExaminerViewer.cc:1782
G4OpenInventorQtExaminerViewer::setReferencePath
void setReferencePath(SoLineSet *, SoCoordinate3 *, bool append=false)
Definition G4OpenInventorQtExaminerViewer.cc:1612

Referenced by sceneChangeCB().

◆ getCoordsNode()

SoCoordinate3 * G4OpenInventorQtExaminerViewer::getCoordsNode ( SoFullPath * path)
protected

Definition at line 1782 of file G4OpenInventorQtExaminerViewer.cc.

1783{
1784 SoLineSet *trajectory = (SoLineSet *)path->getTail();
1785 SoSeparator * grpNode = (SoSeparator*)(((SoFullPath*)path)->getNodeFromTail(1));
1786 int nodeIndex = grpNode->findChild(trajectory);
1787 SoNode * tmpNode;
1788
1789 // We allow only 100 iterations, in case the node isn't found
1790 // (should take only a few iterations)
1791 for (int i = 0; i < 100; ++i) {
1792 --nodeIndex;
1793
1794 tmpNode = grpNode->getChild(nodeIndex);
1795 if(tmpNode->getTypeId() == SoCoordinate3::getClassTypeId()) {
1796 //node found
1797 return (SoCoordinate3 *)tmpNode;
1798 }
1799 }
1800 return NULL; //coords node not found
1801}

Referenced by findAndSetRefPath().

◆ getEtcMenu()

QMenu * G4OpenInventorQtExaminerViewer::getEtcMenu ( )
inline

Definition at line 220 of file G4OpenInventorQtExaminerViewer.hh.

220{ return etcmenu; }

◆ getFileMenu()

QMenu * G4OpenInventorQtExaminerViewer::getFileMenu ( )
inline

Definition at line 219 of file G4OpenInventorQtExaminerViewer.hh.

219{ return filemenu; }

◆ getFont()

QFont * G4OpenInventorQtExaminerViewer::getFont ( )
inline

Definition at line 221 of file G4OpenInventorQtExaminerViewer.hh.

221{ return font; };

◆ getMenubar()

QMenuBar * G4OpenInventorQtExaminerViewer::getMenubar ( )
inline

Definition at line 218 of file G4OpenInventorQtExaminerViewer.hh.

218{ return menubar; }

◆ getSceneElements()

void G4OpenInventorQtExaminerViewer::getSceneElements ( )
protected

Definition at line 1806 of file G4OpenInventorQtExaminerViewer.cc.

1807{
1808 std::string field, eltName;
1809
1810 std::map<std::string, int> duplicates;
1811 std::map<std::string, int> sceneElts;
1812 SoSearchAction search;
1813 Geant4_SoPolyhedron *node;
1814 SoGroup *root = (SoGroup *)getSceneManager()->getSceneGraph();
1815
1816 SoBaseKit::setSearchingChildren(TRUE);
1817
1818 search.reset();
1819 search.setSearchingAll(TRUE);
1820 search.setInterest(SoSearchAction::ALL);
1821 search.setType(Geant4_SoPolyhedron::getClassTypeId(), 0);
1822
1823 // FWJ DEBUG
1824 // G4cout << "Searching for elements....." << G4endl;
1825 search.apply(root);
1826
1827 SoPathList &pl = search.getPaths();
1828
1829
1830 // First find which names occur more than once so we can append a counter to them
1831 for (int i = 0; i < pl.getLength(); i++) {
1832 SoFullPath *path = (SoFullPath *)pl[i];
1833 node = (Geant4_SoPolyhedron *)path->getTail();
1834 eltName = node->getName();
1835 // G4cout << " FOUND " << i << " " << eltName << G4endl;
1836 if(duplicates.count(eltName))
1837 duplicates[eltName]++;
1838 else
1839 duplicates[eltName] = 1;
1840 }
1841
1842 for(int i = 0; i < pl.getLength(); i++) {
1843 float x,y,z;
1844 std::stringstream ssCount;
1845 SoFullPath *path = (SoFullPath *)pl[i];
1846 node = (Geant4_SoPolyhedron *)path->getTail();
1847 eltName = node->getName();
1848 field = eltName;
1849 if(duplicates[eltName] == 1)
1850 ssCount << "";//duplicates[field]
1851 else {
1852 if(sceneElts.count(eltName))
1853 sceneElts[eltName]++;
1854 else
1855 sceneElts[eltName] = 1;
1856
1857 ssCount << sceneElts[eltName];
1858 field += "_";
1859 }
1860
1861 field += ssCount.str();
1862
1863 SoGetBoundingBoxAction bAction(getViewportRegion());
1864 bAction.apply(path);
1865 SbBox3f bBox = bAction.getBoundingBox();
1866
1867 SbVec3f centr = bBox.getCenter();
1868 centr.getValue(x,y,z);
1869
1870 path->ref();
1871 sceneElement el = { field, path, centr, 0.0 };
1872 sceneElements.push_back(el);
1873 }
1874}

Referenced by setReferencePath().

◆ getSuperimpositionNode()

SoNode * G4OpenInventorQtExaminerViewer::getSuperimpositionNode ( SoNode * root,
const char * name )
protected

Definition at line 838 of file G4OpenInventorQtExaminerViewer.cc.

840{
841 if (!searcher)
842 searcher = new SoSearchAction;
843 searcher->reset();
844 searcher->setName(SbName(name));
845 searcher->setInterest(SoSearchAction::FIRST);
846 searcher->setSearchingAll(TRUE);
847 searcher->apply(root);
848 assert(searcher->getPath());
849 return searcher->getPath()->getTail();
850}

Referenced by construct().

◆ GetUIQt()

G4UIQt * G4OpenInventorQtExaminerViewer::GetUIQt ( )
inline

Definition at line 210 of file G4OpenInventorQtExaminerViewer.hh.

210{return uiQt;}

◆ gotoRefPathStart()

void G4OpenInventorQtExaminerViewer::gotoRefPathStart ( )
protected

Definition at line 2545 of file G4OpenInventorQtExaminerViewer.cc.

2546{
2547 G4OpenInventorQtExaminerViewer::ToolsRefPathStartCB();
2548}

◆ incSpeed()

void G4OpenInventorQtExaminerViewer::incSpeed ( )
protected

Definition at line 1537 of file G4OpenInventorQtExaminerViewer.cc.

1537 {
1538 if (std::ceil(animateBtwPtsPeriod * 100) >= 4) {
1539 if (speedStep > 0.08)
1540 speedStep -= 0.02;
1541 else
1542 speedStep = 0.02;
1543 animateBtwPtsPeriod -= speedStep;
1544 } else
1545 animateBtwPtsPeriod = 0.0;
1546
1547 if (currentState != PAUSED_ANIMATION) {
1548 int lastIdx = (int) refParticleTrajectory.size() - 1;
1549 if (refParticleIdx < lastIdx && !animateSensor->isScheduled())
1550 animateRefParticle();
1551 }
1552}

Referenced by processSoEvent().

◆ invertRefPath()

void G4OpenInventorQtExaminerViewer::invertRefPath ( )
protected

Definition at line 2614 of file G4OpenInventorQtExaminerViewer.cc.

2615{
2616 std::reverse(refParticleTrajectory.begin(),
2617 refParticleTrajectory.end());
2618 setReferencePathZPos();
2619 sortElements();
2620}

◆ loadViewPts()

bool G4OpenInventorQtExaminerViewer::loadViewPts ( )
protected

Definition at line 970 of file G4OpenInventorQtExaminerViewer.cc.

971{
972 bool error = false;
973 viewPtData tmp;
974 std::string token;
975 SbVec3f axis;
976 SbRotation orient;
977 float x{0.0}, y{0.0}, z{0.0}, angle{0.0};
978
979 // Gets the last view point accessed, stored in the first line of the data file.
980 fileIn >> token;
981 parseString<int>(viewPtIdx, token, error);
982 getline(fileIn, token); // Remove "\n"
983 // Converts data from string type into necessary types
984 while (getline(fileIn, token)) {
985
986 std::size_t end = token.find_last_not_of(' '); // Remove padded spaces
987 token = token.substr(0, end + 1);
988
989#if QT_VERSION < 0x060000
990 char *vpName = new char[token.size() + 1];
991 strcpy(vpName, token.c_str());
992 tmp.viewPtName = vpName;
993#else
994 tmp.viewPtName = token;
995#endif
996 fileIn >> token;
997
998 parseString<float>(x, token, error);
999 fileIn >> token;
1000 parseString<float>(y, token, error);
1001 fileIn >> token;
1002 parseString<float>(z, token, error);
1003 fileIn >> token;
1004 tmp.position = axis.setValue(x, y, z);
1005
1006 parseString<float>(x, token, error);
1007 fileIn >> token;
1008 parseString<float>(y, token, error);
1009 fileIn >> token;
1010 parseString<float>(z, token, error);
1011 fileIn >> token;
1012 parseString<float>(angle, token, error);
1013 fileIn >> token;
1014 orient.setValue(axis.setValue(x, y, z), angle);
1015 tmp.orientation = orient.getValue();
1016
1017 int camType{0};
1018 parseString<int>(camType, token, error);
1019 fileIn >> token;
1020 tmp.camType = (CameraType) camType;
1021
1022 parseString<float>(tmp.height, token, error);
1023 fileIn >> token;
1024 parseString<float>(tmp.focalDistance, token, error);
1025 fileIn >> token;
1026 parseString<float>(tmp.nearDistance, token, error);
1027 fileIn >> token;
1028 parseString<float>(tmp.farDistance, token, error);
1029 fileIn >> token;
1030 parseString<int>(tmp.viewportMapping, token, error);
1031 fileIn >> token;
1032 parseString<float>(tmp.aspectRatio, token, error);
1033
1034 getline(fileIn, token); // To remove "\n" characters
1035 getline(fileIn, token);
1036
1037 if (error) {
1038#if QT_VERSION < 0x060000
1039 viewPtIdx = 0;
1040#else
1041 viewPtIdx = -1;
1042#endif
1043 viewPtList.clear();
1044 return false;
1045 }
1046 viewPtList.push_back(tmp);
1047 }
1048
1049 return true;
1050}
G4OpenInventorQtExaminerViewer::parseString
void parseString(T &t, const std::string &s, bool &error)
Definition G4OpenInventorQtExaminerViewer.cc:2692

Referenced by afterRealizeHook().

◆ mouseoverCB()

void G4OpenInventorQtExaminerViewer::mouseoverCB ( void * aThis,
SoEventCallback * eventCB )
staticprotected

Definition at line 1335 of file G4OpenInventorQtExaminerViewer.cc.

1336{
1337 SoHandleEventAction* action = eventCB->getAction();
1338 const SoPickedPoint* pp = action->getPickedPoint();
1339 G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*)aThis;
1340
1341 if(!This->abbrOutputFlag)
1342 return;
1343
1344 if(pp != NULL) {
1345
1346 const SbViewportRegion & viewportRegion = action->getViewportRegion();
1347
1348 std::string sLogName;
1349 float x,y,z;
1350 std::stringstream ssZPos;
1351 std::stringstream ssSolids;
1352 std::stringstream ssMaterials;
1353 SoPath * path = pp->getPath();
1354 SoNode* node = ((SoFullPath*)path)->getTail();
1355
1356 if(node->getTypeId() == Geant4_SoPolyhedron::getClassTypeId()) {
1357
1358 sLogName = "Logical Volume: ";
1359 sLogName += ((Geant4_SoPolyhedron *)node)->getName().getString();
1360
1361 SoGetBoundingBoxAction bAction(viewportRegion);
1362 bAction.apply((SoFullPath*)path);
1363 SbBox3f bBox = bAction.getBoundingBox();
1364 SbVec3f centr = bBox.getCenter();
1365 centr.getValue(x,y,z);
1366 ssZPos << "Pos: " << x << " " << y << " " << z;
1367
1368 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1369 if(attHolder && attHolder->GetAttDefs().size()) {
1370
1371 std::vector<const std::map<G4String,G4AttDef>*> vecDefs =
1372 attHolder->GetAttDefs();
1373 std::vector<const std::vector<G4AttValue>*> vecVals =
1374 attHolder->GetAttValues();
1375 for (std::size_t i = 0; i < vecDefs.size(); ++i) {
1376 const std::vector<G4AttValue> * vals = vecVals[i];
1377
1378 std::vector<G4AttValue>::const_iterator iValue;
1379
1380 for (iValue = vals->begin(); iValue != vals->end(); ++iValue) {
1381 const G4String& valueName = iValue->GetName();
1382 const G4String& value = iValue->GetValue();
1383
1384 if(valueName == "Solid") {
1385 if(ssSolids.str() == "")
1386 ssSolids << "Solid Name: " << value;
1387 else
1388 ssSolids << ", " << value;
1389 }
1390
1391 if(valueName == "Material") {
1392 if(ssMaterials.str() == "")
1393 ssMaterials << "Material Name: " << value;
1394 else
1395 ssMaterials << ", " << value;
1396 }
1397 }
1398 }
1399 }
1400 }
1401 // FWJ Mouseover for trajectories
1402 else if(node->getTypeId() == SoLineSet::getClassTypeId()) {
1403 // G4cout << "Trajectory!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
1404 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1405 if(attHolder && attHolder->GetAttDefs().size()) {
1406 std::string strTrajPoint = "G4TrajectoryPoint:";
1407 std::ostringstream oss;
1408 G4String t1, t1Ch, t2, t3, t4;
1409 for (std::size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
1410 // G4cout << "Getting index " << i << " from attHolder" << G4endl;
1411 // No, returns a vector!
1412 // G4AttValue* attValue = attHolder->GetAttValues()[i];
1413 const std::vector<G4AttValue>* vals = attHolder->GetAttValues()[i];
1414 std::vector<G4AttValue>::const_iterator iValue;
1415 for (iValue = vals->begin(); iValue != vals->end(); ++iValue) {
1416 const G4String& valueName = iValue->GetName();
1417 const G4String& value = iValue->GetValue();
1418 // G4cout << " valueName = " << valueName << G4endl;
1419 // G4cout << " value = " << value << G4endl;
1420 // LINE 1
1421 if (valueName == "PN") t1 = value;
1422 if (valueName == "Ch") {
1423 if (atof(value.c_str()) > 0)
1424 t1Ch = " +";
1425 else
1426 t1Ch = " ";
1427 t1Ch += value;
1428 }
1429 if (valueName == "PDG") {
1430 t1 += " ";
1431 t1 += value;
1432 t1 += t1Ch;
1433 This->mouseOverTextLogName->string.setValue(t1);
1434 }
1435 // G4cout << " t1 = " << t1 << G4endl;
1436 // LINE 2
1437 if (valueName == "EventID") t2 = "Evt " + value;
1438 if (valueName == "ID") t2 += " Trk " + value;
1439 if (valueName == "PID") {
1440 t2 += " Prt " + value;
1441 This->mouseOverTextSolid->string.setValue(t2);
1442 }
1443 // LINE 3
1444 if (valueName == "IKE") t3 = "KE " + value;
1445 if (valueName == "IMom") {
1446 // Remove units
1447 std::size_t ipos = value.rfind(" ");
1448 G4String value1 = value;
1449 value1.erase(ipos);
1450 t3 += " P (" + value1 + ")";
1451 }
1452 if (valueName == "IMag") {
1453 t3 += " " + value + "/c";
1454 // t3 += " " + value;
1455 This->mouseOverTextMaterial->string.setValue(t3);
1456 }
1457 // LINE 4
1458 if (valueName == "NTP") {
1459 std::ostringstream t4oss;
1460 t4oss << "TrjPts " << value;
1461 t4oss << " Pos " << pp->getPoint()[0] << " " << pp->getPoint()[1] <<
1462 " " << pp->getPoint()[2];
1463 This->mouseOverTextZPos->string.setValue(SbString(t4oss.str().c_str()));
1464 }
1465 }
1466// G4cout << " NOW CALLING G4AttCheck" << G4endl;
1467// G4cout << G4AttCheck(attHolder->GetAttValues()[i],
1468// attHolder->GetAttDefs()[i]);
1469// oss << G4AttCheck(attHolder->GetAttValues()[i],
1470// attHolder->GetAttDefs()[i]);
1471// if(oss.str().find(strTrajPoint) != std::string::npos) {
1472// // Last attribute displayed was a trajectory point. Since we
1473// // want abbreviated output, display the last one and exit
1474// // (unless we're already at the last (and only) trajectory point)
1475// if(i != attHolder->GetAttDefs().size()-1) {
1476// G4cout << G4AttCheck(
1477// attHolder->GetAttValues()[attHolder->GetAttDefs().size()-1],
1478// attHolder->GetAttDefs()[attHolder->GetAttDefs().size()-1]);
1479// }
1480// break;
1481// }
1482 }
1483 }
1484 This->setSuperimpositionEnabled(This->superimposition, TRUE);
1485 This->scheduleRedraw();
1486 eventCB->setHandled();
1487 return;
1488 }
1489
1490 bool redraw = false;
1491 if(std::string(This->mouseOverTextLogName->string.getValues(0)->getString()) != sLogName) {
1492 This->mouseOverTextLogName->string.setValue(SbString(sLogName.c_str()));
1493 redraw = true;
1494 }
1495 if(std::string(This->mouseOverTextSolid->string.getValues(0)->getString()) != ssSolids.str()) {
1496 This->mouseOverTextSolid->string.setValue(SbString(ssSolids.str().c_str()));
1497 redraw = true;
1498 }
1499 if(std::string(This->mouseOverTextMaterial->string.getValues(0)->getString()) != ssMaterials.str()) {
1500 This->mouseOverTextMaterial->string.setValue(SbString(ssMaterials.str().c_str()));
1501 redraw = true;
1502 }
1503 if(std::string(This->mouseOverTextZPos->string.getValues(0)->getString()) != ssZPos.str()) {
1504 This->mouseOverTextZPos->string.setValue(SbString(ssZPos.str().c_str()));
1505 redraw = true;
1506 }
1507
1508 if(redraw) {
1509 This->setSuperimpositionEnabled(This->superimposition, TRUE);
1510 This->scheduleRedraw();
1511 }
1512
1513 eventCB->setHandled();
1514 }
1515 else {
1516 if(std::string(This->mouseOverTextLogName->string.getValues(0)->getString()) != "") {
1517 This->mouseOverTextLogName->string.setValue(SbString(""));
1518 This->scheduleRedraw();
1519 }
1520 if(std::string(This->mouseOverTextSolid->string.getValues(0)->getString()) != "") {
1521 This->mouseOverTextSolid->string.setValue(SbString(""));
1522 This->scheduleRedraw();
1523 }
1524 if(std::string(This->mouseOverTextMaterial->string.getValues(0)->getString()) != "") {
1525 This->mouseOverTextMaterial->string.setValue(SbString(""));
1526 This->scheduleRedraw();
1527 }
1528 if(std::string(This->mouseOverTextZPos->string.getValues(0)->getString()) != "") {
1529 This->mouseOverTextZPos->string.setValue(SbString(""));
1530 This->scheduleRedraw();
1531 }
1532 }
1533}

Referenced by afterRealizeHook().

◆ moveCamera()

void G4OpenInventorQtExaminerViewer::moveCamera ( float dist = 0,
bool lookdown = false )
protected

Definition at line 1082 of file G4OpenInventorQtExaminerViewer.cc.

1083{
1084
1085 SoCamera *cam = getCamera();
1086 SbVec3f p1, p2; // The particle moves from p1 to p2
1087 SbVec3f particleDir; // Direction vector from p1 to p2
1088 SbVec3f camPosNew{0.0f, 0.0f, 0.0f}; // New position of the camera
1089
1090 if(refParticleTrajectory.size() == 0) {
1091 //refParticleTrajectory hasn't been set yet
1092 if(dist)
1093 distance = dist;
1094 else
1095 distance = (cam->position.getValue() - center).length();
1096
1097 cam->position.setValue(center + offsetFromCenter*distance);
1098 cam->focalDistance = (cam->position.getValue() - center).length();
1099 cam->pointAt(center, upVector);
1100 }
1101 else {
1102
1103 // If we move forward past the last trajectory point,
1104 // go back to the beginning
1105 if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
1106 prevPt = refParticleTrajectory[refParticleIdx - step];
1107 dist = (prevPt - cam->position.getValue()).length();
1108 refParticleIdx = 0;
1109 }
1110 // If we move backward past the beginning,
1111 // go to the last trajectory point
1112 if (refParticleIdx < 0) {
1113 prevPt = refParticleTrajectory[refParticleIdx + step];
1114 dist = (prevPt - cam->position.getValue()).length();
1115 refParticleIdx = (int) refParticleTrajectory.size() - 2;
1116 }
1117
1118 // Set start and end points
1119 p1 = refParticleTrajectory[refParticleIdx];
1120 p2 = refParticleTrajectory[refParticleIdx + step];
1121
1122 // Get the direction from p1 to p2
1123 particleDir = p2 - p1;
1124 particleDir.normalize();
1125
1126 if(prevParticleDir == SbVec3f(0,0,0)) {
1127 // First time entering BEAMLINE mode, look at
1128 // the element from the front, with camera upright
1129 if(lookdown)
1130 camDir = SbVec3f(0,0,1);
1131 else
1132 camDir = SbVec3f(1,0,0);
1133 camUpVec = SbVec3f(0,1,0);
1134
1135 // In case the start of the goes in a
1136 // direction other than +z, rotate the camera accordingly
1137 SbRotation rot(SbVec3f(0,0,1), particleDir);
1138 rot.multVec(camDir, camDir);
1139 rot.multVec(camUpVec, camUpVec);
1140
1141 }
1142 else if(particleDir != prevParticleDir) {
1143 // The beamline has changed direction
1144
1145 SbRotation rot(prevParticleDir, particleDir);
1146 rot.multVec(camDir, camDir);
1147 rot.multVec(camUpVec, camUpVec);
1148
1149 }
1150
1151 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1152 if (!dist)
1153 distance = (prevPt - cam->position.getValue()).length();
1154 else
1155 distance = dist;
1156 }
1157
1158 // FWJ distance not relevant -- use focalDistance
1159 // if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
1160 // if (!dist)
1161 // distance = (prevPt - cam->position.getValue()).length();
1162 // else
1163 // distance = dist;
1164 // }
1165
1166
1167 float x,y,z;
1168 prevPt.getValue(x,y,z);
1169
1170
1171 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
1172 camPosNew = p2 - (camDir*distance);
1173 }
1174 if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
1175 // FWJ maintain focal distance
1176 camPosNew = p2 - (camDir*cam->focalDistance.getValue());
1177 // camPosNew = p2 - (camDir);
1178 }
1179
1180 cam->position = camPosNew;
1181 cam->pointAt(p2, camUpVec);
1182 cam->focalDistance = (p2 - camPosNew).length();
1183
1184 p2.getValue(x,y,z);
1185 camPosNew.getValue(x,y,z);
1186
1187 prevParticleDir = particleDir;
1188 prevPt = p1; // For accurate distance calculation
1189
1190 }
1191
1192}

Referenced by processSoEvent().

◆ parseString()

template<class T>
void G4OpenInventorQtExaminerViewer::parseString ( T & t,
const std::string & s,
bool & error )

Definition at line 2692 of file G4OpenInventorQtExaminerViewer.cc.

2694{
2695 std::istringstream str(s);
2696 if ((str >> t).fail())
2697 error = true;
2698}

Referenced by loadViewPts().

◆ pickingCB()

void G4OpenInventorQtExaminerViewer::pickingCB ( void * aThis,
SoEventCallback * eventCB )
staticprotected

Definition at line 1195 of file G4OpenInventorQtExaminerViewer.cc.

1197{
1198 SoHandleEventAction* action = eventCB->getAction();
1199 const SoPickedPoint *pp = action->getPickedPoint();
1200 G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*)aThis;
1201
1202 if(pp != NULL) {
1203
1204 SoPath* path = pp->getPath();
1205 SoNode* node = ((SoFullPath*)path)->getTail();
1206
1207 if(node->getTypeId() == SoLineSet::getClassTypeId()) {
1208
1209 if(This->pickRefPathFlag) {
1210 This->pickRefPathFlag = false;
1211 if(This->viewingBeforePickRef != This->isViewing())
1212 This->setViewing(This->viewingBeforePickRef);
1213 else
1214 This->setComponentCursor(SoQtCursor(SoQtCursor::DEFAULT));
1215
1216 // The trajectory is a set of lines stored in a LineSet
1217 SoLineSet * trajectory = (SoLineSet *)node;
1218 // FWJ DEBUG
1219 // G4cout << "FOUND trajectory LineSet" << trajectory << G4endl;
1220
1221 // The set of all trajectories is stored in a Seperator group node
1222 // one level above the LineSet that was picked. The nodes under that
1223 // seperator are as follows (in this order): Material, LightModel,
1224 // ResetTransform, MatrixTransform, Coordinate3, DrawStyle, LineSet
1225 SoSeparator * grpNode =
1226 (SoSeparator*)(((SoFullPath*)path)->getNodeFromTail(1));
1227
1228 // The node that contains the coordinates for the trajectory is a
1229 // Coordinate3 node which occurs before the LineSet node. We iterate
1230 // back through the nodes in the group until we find the Coordinate3 node
1231 int nodeIndex = grpNode->findChild(trajectory);
1232 SoNode * tmpNode;
1233 // FWJ needs initialization
1234 SoCoordinate3 * coords = 0;
1235 // SoCoordinate3 * coords;
1236 // We allow only 100 iterations, in case the node isn't found
1237 // (should take only a few iterations)
1238 for(int i = 0; i < 100; ++i) {
1239 --nodeIndex;
1240
1241 tmpNode = grpNode->getChild(nodeIndex);
1242 if(tmpNode->getTypeId() == SoCoordinate3::getClassTypeId()) {
1243 //node found
1244 coords = (SoCoordinate3 *)tmpNode;
1245 break;
1246 }
1247 }
1248
1249 if(coords == NULL) {
1250 G4warn << "Could not find the coordinates node"
1251 " for the picked trajectory." << G4endl;
1252 G4warn << " Reference trajectory not set" << G4endl;
1253 return;
1254 }
1255 // FWJ DEBUG
1256 // G4cout << "FOUND SoCoordinate3 node " << coords << G4endl;
1257
1258
1259 if ((This->lshiftdown) || (This->rshiftdown))
1260 This->setReferencePath(trajectory, coords, true); //APPENDING
1261 else
1262 This->setReferencePath(trajectory, coords, false);
1263
1264 return;
1265
1266 }
1267 else if(This->abbrOutputFlag) {
1268
1269 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1270 if(attHolder && attHolder->GetAttDefs().size()) {
1271
1272 std::string strTrajPoint = "G4TrajectoryPoint:";
1273 std::ostringstream oss;
1274 for (std::size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
1275 G4cout << G4AttCheck(attHolder->GetAttValues()[i],
1276 attHolder->GetAttDefs()[i]);
1277 oss << G4AttCheck(attHolder->GetAttValues()[i],
1278 attHolder->GetAttDefs()[i]);
1279 if(oss.str().find(strTrajPoint) != std::string::npos) {
1280
1281 // Last attribute displayed was a trajectory point. Since we
1282 // want abbreviated output, display the last one and exit
1283 // (unless we're already at the last (and only) trajectory point)
1284 if(i != attHolder->GetAttDefs().size()-1) {
1285 G4cout << G4AttCheck(
1286 attHolder->GetAttValues()[attHolder->GetAttDefs().size()-1],
1287 attHolder->GetAttDefs()[attHolder->GetAttDefs().size()-1]);
1288 }
1289 break;
1290 }
1291 }
1292 } else {
1293 G4String name((char*)node->getName().getString());
1294 G4String cls((char*)node->getTypeId().getName().getString());
1295 G4warn << "SoNode : " << node
1296 << " SoType : " << cls
1297 << " name : " << name
1298 << G4endl;
1299 G4warn << "No attributes attached." << G4endl;
1300 }
1301
1302 return;
1303 }
1304 else{
1305 //Go to default behavior
1306 }
1307 }
1308 else {
1309 //Go to default behavior
1310 }
1311
1312 // Default behavior in G4OpenInventorViewer::SelectionCB
1313 G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
1314 if(attHolder && attHolder->GetAttDefs().size()) {
1315 for (std::size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
1316 G4cout << G4AttCheck(attHolder->GetAttValues()[i],
1317 attHolder->GetAttDefs()[i]);
1318 }
1319 } else {
1320 G4String name((char*)node->getName().getString());
1321 G4String cls((char*)node->getTypeId().getName().getString());
1322 G4warn << "SoNode : " << node
1323 << " SoType : " << cls
1324 << " name : " << name
1325 << G4endl;
1326 G4warn << "No attributes attached." << G4endl;
1327 }
1328
1329 //Suppress other event handlers
1330 eventCB->setHandled();
1331 }
1332}
G4warn
#define G4warn
Definition G4Scene.cc:41
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition G4InuclParticleNames.hh:76

Referenced by afterRealizeHook().

◆ processSoEvent()

SbBool G4OpenInventorQtExaminerViewer::processSoEvent ( const SoEvent *const event)
protected

Definition at line 3640 of file G4OpenInventorQtExaminerViewer.cc.

3641{
3642
3643 // FWJ DEBUG
3644 // G4cout << "processSoEvent ############" << ++processSoEventCount << G4endl;
3645
3646 SoCamera *cam = getCamera();
3647 const SoType type(ev->getTypeId());
3648
3649// Needed to implement mouse wheel zoom direction change.
3650// Does not work with MacOS trackpad: use Coin3d default handler.
3651#ifndef __APPLE__
3652 if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
3653 SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
3654
3655 // if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
3656 // || currentState == PAUSED_ANIMATION) {
3657
3658 switch (me->getButton()) {
3659
3660 case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
3661 if (me->getState() == SoButtonEvent::DOWN) {
3662 // G4cout << "SCROLL WHEEL UP" << G4endl;
3663 zoom(-0.1f);
3664 return TRUE;
3665 }
3666 break;
3667
3668 case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
3669 if (me->getState() == SoButtonEvent::DOWN) {
3670 // G4cout << "SCROLL WHEEL DOWN" << G4endl;
3671 zoom(0.1f);
3672 return TRUE;
3673 }
3674 break;
3675
3676 default:
3677 break;
3678 }
3679 // }
3680 if (currentState == GENERAL) {
3681
3682 }
3683 }
3684#endif
3685
3686 if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
3687 SoKeyboardEvent* ke = (SoKeyboardEvent*)ev;
3688
3689 if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
3690 switch (ke->getKey()) {
3691 case SoKeyboardEvent::E:
3692 if (externalQtApp) {
3693 // G4cout << "E KEY PRESSED" << G4endl;
3694 return TRUE;
3695 } else {
3696 G4cout <<
3697 "E KEY PRESSED, EXITING OIQT VIEWER SECONDARY LOOP" <<
3698 G4endl;
3699 SoQt::exitMainLoop();
3700 // escapeCallback();
3701 return TRUE;
3702 }
3703 case SoKeyboardEvent::LEFT_SHIFT:
3704 this->lshiftdown = true;
3705 return TRUE;
3706 case SoKeyboardEvent::RIGHT_SHIFT:
3707 this->rshiftdown = true;
3708 return TRUE;
3709 case SoKeyboardEvent::LEFT_CONTROL:
3710 this->lctrldown = true;
3711 return TRUE;
3712 case SoKeyboardEvent::RIGHT_CONTROL:
3713 this->rctrldown = true;
3714 return TRUE;
3715 case SoKeyboardEvent::SPACE:
3716 if (currentState == ANIMATION
3717 || currentState == REVERSED_ANIMATION) {
3718 beforePausing = currentState;
3719 currentState = PAUSED_ANIMATION;
3720 if (animateSensor->isScheduled())
3721 animateSensor->unschedule();
3722 return TRUE;
3723 } else if (currentState == PAUSED_ANIMATION) {
3724 if (maxSpeed) {
3725 if ((beforePausing == ANIMATION
3726 && refParticleIdx
3727 < (int) refParticleTrajectory.size() - 1)
3728 || (beforePausing == REVERSED_ANIMATION
3729 && refParticleIdx > 0)) {
3730 currentState = beforePausing;
3731 animateRefParticle();
3732 }
3733 }
3734 return TRUE;
3735 }
3736 break;
3737 case SoKeyboardEvent::ESCAPE:
3738 if (currentState == ANIMATION
3739 || currentState == REVERSED_ANIMATION
3740 || currentState == PAUSED_ANIMATION) {
3741
3742 if (animateSensor->isScheduled())
3743 animateSensor->unschedule();
3744 currentState = prevState;
3745 refParticleIdx = prevRefIdx;
3746 setSuperimpositionEnabled(superimposition, FALSE);
3747 maxSpeed = 0.0f;
3748 step = 1;
3749
3750 scheduleRedraw();
3751 if (currentState == VIEWPOINT) {
3752 setSuperimpositionEnabled(superimposition, TRUE);
3753 axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
3754 animSpeedOutlineSwitch->whichChild.setValue(
3755 SO_SWITCH_NONE);
3756 animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
3757
3758 scheduleRedraw();
3759 }
3760 restoreCamera();
3761 return TRUE;
3762 }
3763 break;
3764 case SoKeyboardEvent::DELETE:
3765 if (viewPtList.size()
3766 && (currentState != ANIMATION
3767 && currentState != REVERSED_ANIMATION
3768 && currentState != PAUSED_ANIMATION)) {
3769 // FWJ IMPLEMENT LATER
3770 // String dialogName = (char *) "Delete Viewpoint";
3771 // std::string msg = "Are you sure you want to delete current viewpoint?";
3772 // warningMsgDialog(msg, dialogName, deleteViewPtCB);
3773 return TRUE;
3774 }
3775 break;
3776 case SoKeyboardEvent::LEFT_ARROW:
3777 switch (currentState) {
3778 case BEAMLINE:
3779 if ((this->lshiftdown) || (this->rshiftdown)) {
3780 refParticleIdx -= step;
3781 moveCamera();
3782 }
3783 else if ((this->lctrldown) || (this->rctrldown)) {
3784 if (SoQtExaminerViewer::isAnimating())
3785 stopAnimating();
3786 prevState = currentState;
3787 currentState = ROTATING;
3788 animateBtwPtsPeriod = 0.08f;
3789
3790 SbVec3f tmp = camDir;
3791 tmp.negate();
3792 rotAxis = tmp;
3793
3794 rotCnt = ROT_CNT;
3795 moveCamera(); // To make sure camera is perpendicular to the beamline
3796 rotateCamera();
3797 }
3798 else {
3799 if (SoQtExaminerViewer::isAnimating())
3800 stopAnimating();
3801 prevState = currentState;
3802 currentState = ROTATING;
3803 animateBtwPtsPeriod = 0.08f;
3804
3805 SbVec3f tmp = camUpVec;
3806 tmp.negate();
3807 rotAxis = tmp;
3808
3809 rotCnt = ROT_CNT;
3810 moveCamera(); // To make sure camera is perpendicular to the beamline
3811 rotateCamera();
3812
3813 }
3814 return TRUE;
3815
3816 case ANIMATION:
3817 case REVERSED_ANIMATION:
3818 left_right -= 1.5f;
3819 return TRUE;
3820 case PAUSED_ANIMATION:
3821 left_right -= 1.5f;
3822 setStartingPtForAnimation();
3823 cam->position = myCam->position;
3824 return TRUE;
3825 case GENERAL:
3826 case VIEWPOINT:
3827 if ((!this->lshiftdown) && (!this->rshiftdown)) {
3828 // Using this allows us to look around without
3829 // changing the camera parameters (camDir, camUpVec)
3830 this->bottomWheelMotion(
3831 this->getBottomWheelValue() + 0.1f);
3832
3833 return TRUE;
3834 }
3835 break;
3836 case ROTATING:
3837 // For this state, let the keyboard event
3838 // be handled by superclass
3839 break;
3840 default:
3841 SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
3842 "Unhandled viewer state");
3843 break;
3844 }
3845 break;
3846
3847 case SoKeyboardEvent::RIGHT_ARROW:
3848 switch(currentState) {
3849 case BEAMLINE:
3850 if ((this->lshiftdown) || (this->rshiftdown)) {
3851 refParticleIdx += step;
3852 moveCamera();
3853 }
3854 else if ((this->lctrldown) || (this->rctrldown)) {
3855 if (SoQtExaminerViewer::isAnimating())
3856 stopAnimating();
3857 prevState = currentState;
3858 currentState = ROTATING;
3859 animateBtwPtsPeriod = 0.08f;
3860
3861 rotAxis = camDir;
3862
3863 rotCnt = ROT_CNT;
3864 moveCamera(); // To make sure camera is perpendicular to the beamline
3865 rotateCamera();
3866 }
3867 else{
3868 if (SoQtExaminerViewer::isAnimating())
3869 stopAnimating();
3870 prevState = currentState;
3871 currentState = ROTATING;
3872 animateBtwPtsPeriod = 0.08f;
3873
3874 rotAxis = camUpVec;
3875
3876 rotCnt = ROT_CNT;
3877 moveCamera(); // To make sure camera is perpendicular to the beamline
3878 rotateCamera();
3879 }
3880 return TRUE;
3881
3882 case ANIMATION:
3883 case REVERSED_ANIMATION:
3884 left_right += 1.5f;
3885 return TRUE;
3886 case PAUSED_ANIMATION:
3887 left_right += 1.5f;
3888 setStartingPtForAnimation();
3889 cam->position = myCam->position;
3890 return TRUE;
3891 case GENERAL:
3892 case VIEWPOINT:
3893 if ((!this->lshiftdown) && (!this->rshiftdown)) {
3894 // Using this allows us to look around without
3895 // changing the camera parameters (camDir, camUpVec)
3896 this->bottomWheelMotion(
3897 this->getBottomWheelValue() - 0.1f);
3898 return TRUE;
3899 }
3900 break;
3901 case ROTATING:
3902 // For this state, let the keyboard event
3903 // be handled by superclass
3904 break;
3905 default:
3906 SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
3907 "Unhandled viewer state");
3908 break;
3909 }
3910 break;
3911
3912 case SoKeyboardEvent::DOWN_ARROW:
3913 switch(currentState) {
3914 case BEAMLINE:
3915
3916 if ((this->lshiftdown) || (this->rshiftdown)) {
3917 refParticleIdx -= step;
3918 moveCamera();
3919 }
3920 else{
3921 if (SoQtExaminerViewer::isAnimating())
3922 stopAnimating();
3923 prevState = currentState;
3924 currentState = ROTATING;
3925 animateBtwPtsPeriod = 0.08f;
3926
3927 rotAxis = camDir.cross(camUpVec);
3928
3929 rotCnt = ROT_CNT;
3930 moveCamera(); // To make sure camera is perpendicular to the beamline
3931 rotateCamera();
3932
3933 }
3934 return TRUE;
3935
3936 case ANIMATION:
3937 case REVERSED_ANIMATION:
3938 up_down -= 1.5f;
3939 return TRUE;
3940 case PAUSED_ANIMATION:
3941 up_down -= 1.5f;
3942 setStartingPtForAnimation();
3943 cam->position = myCam->position;
3944 return TRUE;
3945 case GENERAL:
3946 case VIEWPOINT:
3947 // Using this allows us to look around without
3948 // changing the camera parameters (camDir, camUpVec)
3949 if ((!this->lshiftdown) && (!this->rshiftdown)) {
3950 this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
3951 return TRUE;
3952 }
3953 break;
3954 case ROTATING:
3955 // For this state, let the keyboard event
3956 // be handled by superclass
3957 break;
3958 default:
3959 SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
3960 "Unhandled viewer state");
3961 break;
3962 }
3963 break;
3964
3965 case SoKeyboardEvent::UP_ARROW:
3966 switch(currentState) {
3967 case BEAMLINE:
3968 if ((this->lshiftdown) || (this->rshiftdown)) {
3969 refParticleIdx -= step;
3970 moveCamera();
3971 }
3972 else{
3973 if (SoQtExaminerViewer::isAnimating())
3974 stopAnimating();
3975 prevState = currentState;
3976 currentState = ROTATING;
3977 animateBtwPtsPeriod = 0.08f;
3978
3979 rotAxis = camUpVec.cross(camDir);
3980
3981 rotCnt = ROT_CNT;
3982 moveCamera();
3983
3984 rotateCamera();
3985
3986
3987 }
3988 return TRUE;
3989 case ANIMATION:
3990 case REVERSED_ANIMATION:
3991 up_down += 1.5f;
3992 return TRUE;
3993 case PAUSED_ANIMATION:
3994 up_down += 1.5f;
3995 setStartingPtForAnimation();
3996 cam->position = myCam->position;
3997 return TRUE;
3998 case GENERAL:
3999 case VIEWPOINT:
4000 // Using this allows us to look around without
4001 // changing the camera parameters (camDir, camUpVec)
4002 if ((!this->lshiftdown) && (!this->rshiftdown)) {
4003 this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
4004 return TRUE;
4005 }
4006 break;
4007 case ROTATING:
4008 // For this state, let the keyboard event
4009 // be handled by superclass
4010 break;
4011 default:
4012 SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
4013 "Unhandled viewer state");
4014 break;
4015 }
4016 break;
4017
4018 case SoKeyboardEvent::PAGE_UP:
4019 switch(currentState) {
4020 case BEAMLINE:
4021 if (step < (int) refParticleTrajectory.size() / 5) // Magic number
4022 step++;
4023 return TRUE;
4024 case ANIMATION:
4025 incSpeed();
4026 maxSpeed += SPEED_INDICATOR_STEP;
4027 if (maxSpeed > 0.8)
4028 maxSpeed = MAX_SPEED_INDICATOR;
4029 scheduleRedraw();
4030
4031 return TRUE;
4032 case REVERSED_ANIMATION:
4033 if(!animateSensor->isScheduled()) {
4034 currentState = ANIMATION;
4035 if (refParticleIdx
4036 < (int) refParticleTrajectory.size() - 1) {
4037 refParticleIdx++;
4038 maxSpeed = SPEED_INDICATOR_STEP;
4039 scheduleRedraw();
4040 animateRefParticle();
4041 }
4042 }
4043 else{
4044 maxSpeed += SPEED_INDICATOR_STEP;
4045 decSpeed();
4046 scheduleRedraw();
4047 }
4048 return TRUE;
4049 case PAUSED_ANIMATION:
4050 maxSpeed += SPEED_INDICATOR_STEP;
4051 if (maxSpeed > 0.8)
4052 maxSpeed = MAX_SPEED_INDICATOR;
4053
4054 if (beforePausing == ANIMATION) {
4055 incSpeed();
4056 } else {
4057 decSpeed();
4058 if (animateBtwPtsPeriod >= MIN_SPEED)
4059 beforePausing = ANIMATION;
4060 }
4061
4062 scheduleRedraw();
4063 return TRUE;
4064 default: //fall through
4065 break;
4066 }
4067 break;
4068
4069 case SoKeyboardEvent::PAGE_DOWN:
4070 switch(currentState) {
4071 case BEAMLINE:
4072 if (step > 1)
4073 step--;
4074 return TRUE;
4075 case ANIMATION:
4076 if(!animateSensor->isScheduled()) {
4077 currentState = REVERSED_ANIMATION;
4078 if (refParticleIdx > 1) {
4079 refParticleIdx--;
4080 maxSpeed = -SPEED_INDICATOR_STEP;
4081 scheduleRedraw();
4082 animateRefParticle();
4083 }
4084 }
4085 else{
4086 maxSpeed -= SPEED_INDICATOR_STEP;
4087 decSpeed();
4088 scheduleRedraw();
4089 }
4090 return TRUE;
4091 case REVERSED_ANIMATION:
4092 incSpeed();
4093 maxSpeed -= SPEED_INDICATOR_STEP;
4094 if (maxSpeed < -0.8)
4095 maxSpeed = -MAX_SPEED_INDICATOR;
4096 scheduleRedraw();
4097 return TRUE;
4098 case PAUSED_ANIMATION:
4099 maxSpeed -= SPEED_INDICATOR_STEP;
4100 if (maxSpeed < -0.8)
4101 maxSpeed = -MAX_SPEED_INDICATOR;
4102 if (beforePausing == REVERSED_ANIMATION) {
4103 incSpeed();
4104 } else {
4105 decSpeed();
4106 if (animateBtwPtsPeriod >= MIN_SPEED)
4107 beforePausing = REVERSED_ANIMATION;
4108 }
4109 scheduleRedraw();
4110 return TRUE;
4111 default:
4112 //fall through
4113 break;
4114 }
4115 break;
4116
4117 // FROM XT VIEWER
4118 // case SoKeyboardEvent::E:
4119 // this->escapeCallback(this->examinerObject);
4120 // break;
4121
4122 default:
4123 break; // To get rid of compiler warnings
4124 }
4125 }
4126 if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
4127 switch (ke->getKey()) {
4128 case SoKeyboardEvent::LEFT_SHIFT:
4129 this->lshiftdown = false;
4130 return TRUE;
4131 case SoKeyboardEvent::RIGHT_SHIFT:
4132 this->rshiftdown = false;
4133 return TRUE;
4134 case SoKeyboardEvent::LEFT_CONTROL:
4135 this->lctrldown = false;
4136 return TRUE;
4137 case SoKeyboardEvent::RIGHT_CONTROL:
4138 this->rctrldown = false;
4139 return TRUE;
4140 default:
4141 break;
4142 }
4143 }
4144 }
4145
4146 // Pass the event on to the viewer
4147 // Need some checks here as in Xt viewer?
4148
4149 if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
4150 || currentState == ROTATING)
4151 return FALSE;
4152 else
4153 return SoQtExaminerViewer::processSoEvent(ev);
4154}
MAX_SPEED_INDICATOR
#define MAX_SPEED_INDICATOR
Definition G4OpenInventorQtExaminerViewer.cc:117
SPEED_INDICATOR_STEP
#define SPEED_INDICATOR_STEP
Definition G4OpenInventorQtExaminerViewer.cc:116
G4OpenInventorQtExaminerViewer::moveCamera
void moveCamera(float dist=0, bool lookdown=false)
Definition G4OpenInventorQtExaminerViewer.cc:1082

◆ renameViewPt()

void G4OpenInventorQtExaminerViewer::renameViewPt ( char * vpName)
protected

Definition at line 3461 of file G4OpenInventorQtExaminerViewer.cc.

3462{
3463 std::size_t idx = 0, end, pos;
3464 std::size_t size = viewPtList.size();
3465 std::string line, newName;
3466 fileIn.open(fileName.c_str());
3467
3468 newName = vpName;
3469 while ((int) newName.size() < MAX_VP_NAME)
3470 newName += " ";
3471
3472 getline(fileIn, line);
3473 pos = fileIn.tellg();
3474 while (getline(fileIn, line)) {
3475 end = line.find_last_not_of(' ');
3476 line = line.substr(0, end + 1);
3477#if QT_VERSION < 0x060000
3478 if (!strcmp(line.c_str(), curViewPtName)) {
3479#else
3480 if (!strcmp(line.c_str(), curViewPtName.c_str())) {
3481#endif
3482 fileOut.seekp(pos);
3483 fileOut << newName;
3484 fileOut.seekp(0, std::ios::end); // Set the file pointer to the end of the file
3485 break;
3486 }
3487 while (line.size())
3488 getline(fileIn, line);
3489 pos = fileIn.tellg();
3490 }
3491
3492 fileIn.close();
3493 fileIn.clear();
3494
3495 while (idx < size) {
3496#if QT_VERSION < 0x060000
3497 if (!strcmp(viewPtList[idx].viewPtName, curViewPtName)) {
3498 strcpy(viewPtList[idx].viewPtName, vpName);
3499#else
3500 if (!strcmp(viewPtList[idx].viewPtName.c_str(), curViewPtName.c_str())) {
3501 viewPtList[idx].viewPtName = std::string(vpName);
3502#endif
3503 break;
3504 }
3505 idx++;
3506 }
3507}

Referenced by deleteViewPt().

◆ restoreCamera()

void G4OpenInventorQtExaminerViewer::restoreCamera ( )
protected

Definition at line 2382 of file G4OpenInventorQtExaminerViewer.cc.

2383{
2384 SoCamera *cam = getCamera();
2385
2386 cam->viewportMapping = camB4Animation.viewportMapping;
2387 cam->position = camB4Animation.position;
2388 cam->orientation = camB4Animation.orientation;
2389 cam->aspectRatio = camB4Animation.aspectRatio;
2390 cam->nearDistance = camB4Animation.nearDistance;
2391 cam->farDistance = camB4Animation.farDistance;
2392 cam->focalDistance = camB4Animation.focalDistance;
2393
2394 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
2395 if (camB4Animation.camType == ORTHOGRAPHIC) {
2396 toggleCameraType();
2397 cam = getCamera();
2398 ((SoOrthographicCamera *) cam)->height.setValue(
2399 camB4Animation.height);
2400 } else
2401 ((SoPerspectiveCamera *) cam)->heightAngle.setValue(
2402 camB4Animation.height);
2403 } else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
2404 if (camB4Animation.camType == PERSPECTIVE) {
2405 toggleCameraType();
2406 cam = getCamera();
2407 ((SoPerspectiveCamera *) cam)->heightAngle.setValue(
2408 camB4Animation.height);
2409 } else
2410 ((SoOrthographicCamera *) cam)->height.setValue(
2411 camB4Animation.height);
2412 }
2413}

Referenced by processSoEvent().

◆ rotateCamera()

void G4OpenInventorQtExaminerViewer::rotateCamera ( )
protected

Definition at line 1055 of file G4OpenInventorQtExaminerViewer.cc.

1056{
1057 SoCamera *cam = getCamera();
1058
1059 SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
1060 rot.multVec(camDir, camDir);
1061 rot.multVec(camUpVec, camUpVec);
1062
1063 SbVec3f camPosNew = prevPt - (camDir*distance);
1064 cam->position = camPosNew;
1065 cam->pointAt(prevPt, camUpVec);
1066 cam->focalDistance = (prevPt - camPosNew).length();
1067
1068 rotCnt--;
1069
1070 if (animateSensorRotation->isScheduled()) {
1071 animateSensorRotation->unschedule();
1072 }
1073
1074 animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
1075 animateSensorRotation->setInterval(SbTime(0.02));
1076 animateSensorRotation->schedule();
1077
1078}
M_PI
#define M_PI
Definition SbMath.h:33

Referenced by animateSensorRotationCB(), and processSoEvent().

◆ saveCurCamera()

void G4OpenInventorQtExaminerViewer::saveCurCamera ( )
protected

Definition at line 2359 of file G4OpenInventorQtExaminerViewer.cc.

2360{
2361 SoCamera *cam = getCamera();
2362 camB4Animation.viewportMapping = cam->viewportMapping.getValue();
2363 camB4Animation.position = cam->position.getValue();
2364 camB4Animation.orientation = cam->orientation.getValue();
2365 camB4Animation.aspectRatio = cam->aspectRatio.getValue();
2366 camB4Animation.nearDistance = cam->nearDistance.getValue();
2367 camB4Animation.farDistance = cam->farDistance.getValue();
2368 camB4Animation.focalDistance = cam->focalDistance.getValue();
2369
2370 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
2371 camB4Animation.height =
2372 ((SoPerspectiveCamera *) cam)->heightAngle.getValue();
2373 camB4Animation.camType = PERSPECTIVE;
2374 } else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
2375 camB4Animation.height =
2376 ((SoOrthographicCamera *) cam)->height.getValue();
2377 camB4Animation.camType = ORTHOGRAPHIC;
2378 }
2379}

◆ saveViewPt()

void G4OpenInventorQtExaminerViewer::saveViewPt ( char * name)
protected

Definition at line 2929 of file G4OpenInventorQtExaminerViewer.cc.

2930{
2931 SbVec3f axis;
2932 viewPtData tmp;
2933 float x, y, z, angle;
2934 SoCamera* camera = getCamera();
2935
2936 // NOTE: Xt VSN increments this at end of procedure
2937 // viewPtIdx++;
2938
2939 // FWJ DEBUG
2940 // G4cout << "saveViewPt: saving bookmark " << viewPtIdx << " " << name
2941 // << G4endl;
2942
2943 if (viewPtList.size() == 0) {
2944 writeViewPtIdx();
2945 }
2946
2947#if QT_VERSION < 0x060000
2948 tmp.viewPtName = name;
2949#else
2950 tmp.viewPtName = std::string(name);
2951#endif
2952 tmp.viewportMapping = camera->viewportMapping.getValue();
2953 tmp.position = camera->position.getValue();
2954 tmp.orientation = camera->orientation.getValue();
2955 tmp.aspectRatio = camera->aspectRatio.getValue();
2956 tmp.nearDistance = camera->nearDistance.getValue();
2957 tmp.farDistance = camera->farDistance.getValue();
2958 tmp.focalDistance = camera->focalDistance.getValue();
2959
2960 // Save camera height (changed by zooming)
2961 if (camera->isOfType(SoPerspectiveCamera::getClassTypeId())) {
2962 tmp.height = ((SoPerspectiveCamera *) camera)->heightAngle.getValue();
2963 tmp.camType = PERSPECTIVE;
2964 } else if (camera->isOfType(SoOrthographicCamera::getClassTypeId())) {
2965 tmp.height = ((SoOrthographicCamera *) camera)->height.getValue();
2966 tmp.camType = ORTHOGRAPHIC;
2967 } else {
2968 SoDebugError::post("G4OpenInventorQtExaminerViewer::saveViewPtCB",
2969 "Only Perspective and Orthographic cameras are supported.");
2970 return;
2971 }
2972
2973 viewPtList.push_back(tmp);
2974
2975 // Now save the view point to a .txt file
2976 // FWJ DEBUG
2977 // G4cout << "saveViewPt: writing to Bookmark file " << fileName << G4endl;
2978
2979 std::string vpName = name;
2980
2981 while ((int) vpName.size() <= MAX_VP_NAME)
2982 vpName += " ";
2983
2984 fileOut << vpName << std::endl;
2985 tmp.position.getValue(x, y, z);
2986 fileOut << x << " " << y << " " << z << std::endl;
2987
2988 // Reusing x, y and z for storing the axis
2989 tmp.orientation.getValue(axis, angle);
2990 axis.getValue(x, y, z);
2991 fileOut << x << " " << y << " " << z << " " << angle << std::endl;
2992
2993 fileOut << tmp.camType << " " << tmp.height << std::endl;
2994 fileOut << tmp.focalDistance << " ";
2995 fileOut << tmp.nearDistance << " ";
2996 fileOut << tmp.farDistance << std::endl;
2997 fileOut << tmp.viewportMapping << " ";
2998 fileOut << tmp.aspectRatio << "\n" << std::endl;
2999 fileOut.flush();
3000
3001 viewPtIdx++;
3002
3003 // FWJ DEBUG
3004 // G4cout << "saveViewPt: finished writing to file" << G4endl <<
3005 // " Next viewPtIdx is " << viewPtIdx << G4endl;
3006}

◆ sceneChangeCB()

void G4OpenInventorQtExaminerViewer::sceneChangeCB ( void * userData,
SoSensor *  )
staticprotected

Definition at line 2653 of file G4OpenInventorQtExaminerViewer.cc.

2654{
2655 // FWJ DEBUG
2656 // G4cout << "SCENE CHANGE callback" << G4endl;
2657 // NOTE: could/should be disabled during animation
2658
2659 G4OpenInventorQtExaminerViewer* This =
2660 (G4OpenInventorQtExaminerViewer*)userData;
2661 if(This->newEvents) {
2662 This->findAndSetRefPath();
2663 This->newEvents = false;
2664 }
2665}

Referenced by afterRealizeHook().

◆ setExternalQtApp()

void G4OpenInventorQtExaminerViewer::setExternalQtApp ( )
inline

Definition at line 223 of file G4OpenInventorQtExaminerViewer.hh.

223{ externalQtApp = TRUE; }

◆ setOrigWindowSize()

void G4OpenInventorQtExaminerViewer::setOrigWindowSize ( int w,
int h )
inline

Definition at line 213 of file G4OpenInventorQtExaminerViewer.hh.

213{ OWwidth = w; OWheight = h; }

◆ setReferencePath()

void G4OpenInventorQtExaminerViewer::setReferencePath ( SoLineSet * lineset,
SoCoordinate3 * coords,
bool append = false )
protected

Definition at line 1612 of file G4OpenInventorQtExaminerViewer.cc.

1614{
1615 // TODO: Color the reference path
1616 // Disable the color stuff for now: changes all trajectories
1617 // FWJ See G4OpenInventorXtExaminerViewer.cc for test code
1618
1619 // The trajectory is composed of all the polyline segments in the
1620 // multiple value field (SoMFInt32) numVertices.
1621 // For each of the numVertices.getNum()* polyline segments,
1622 // retrieve the points from the SoCoordinate3 node
1623
1624 SbVec3f refParticlePt;
1625
1626 if(!append)
1627 refParticleTrajectory.clear();
1628
1629 for(int i = 0; i < lineset->numVertices.getNum(); ++i) {
1630 for(int j = 0; j < lineset->numVertices[i]; ++j) {
1631 refParticlePt = coords->point[j];
1632 refParticleTrajectory.push_back(refParticlePt);
1633 }
1634 }
1635 // Remove points that are too close to each other
1636 evenOutRefParticlePts();
1637 setReferencePathZPos();
1638 getSceneElements();
1639 sortElements();
1640}

Referenced by findAndSetRefPath(), and pickingCB().

◆ setReferencePathZPos()

void G4OpenInventorQtExaminerViewer::setReferencePathZPos ( )
protected

Definition at line 1643 of file G4OpenInventorQtExaminerViewer.cc.

1644{
1645 refZPositions.clear();
1646 refZPositions.push_back(0);
1647 float dist;
1648 for(unsigned int i=0; i < refParticleTrajectory.size() - 1; ++i) {
1649 dist = (refParticleTrajectory[i] -
1650 refParticleTrajectory[i + 1]).length();
1651 refZPositions.push_back(refZPositions[i] + dist);
1652 }
1653}

Referenced by invertRefPath(), and setReferencePath().

◆ setStartingPtForAnimation()

void G4OpenInventorQtExaminerViewer::setStartingPtForAnimation ( )
protected

Definition at line 2490 of file G4OpenInventorQtExaminerViewer.cc.

2491{
2492 if (SoQtExaminerViewer::isAnimating())
2493 stopAnimating();
2494
2495 SbRotation rot;
2496 SbVec3f p1{0.0, 0.0, 0.0}, p2{0.0, 0.0, 0.0}, p2_tmp, camUpV, camD, camD_tmp, leftRightAxis;
2497 float x1, y1, z1, x2, y2, z2;
2498
2499 if (currentState == ANIMATION) {
2500 p1 = refParticleTrajectory[refParticleIdx];
2501 p2 = refParticleTrajectory[++(refParticleIdx)];
2502 } else if (currentState == REVERSED_ANIMATION) {
2503 p2 = refParticleTrajectory[refParticleIdx];
2504 p1 = refParticleTrajectory[--(refParticleIdx)];
2505 } else if (currentState == PAUSED_ANIMATION) {
2506 if (refParticleIdx < (int) refParticleTrajectory.size()) {
2507 p1 = refParticleTrajectory[refParticleIdx];
2508 p2 = refParticleTrajectory[refParticleIdx + 1];
2509 } else {
2510 p1 = refParticleTrajectory[refParticleIdx - 1];
2511 p2 = refParticleTrajectory[refParticleIdx];
2512 }
2513 }
2514 p1.getValue(x1, y1, z1);
2515 p2.getValue(x2, y2, z2);
2516
2517 camD = p2 - p1;
2518 camD.normalize();
2519
2520 p2_tmp.setValue(x2, y1, z2);
2521 camD_tmp = p2_tmp - p1;
2522 camD_tmp.normalize();
2523
2524 camUpV.setValue(0, 1, 0);
2525 rot.setValue(camD_tmp, camD);
2526 rot.multVec(camUpV, camUpV);
2527
2528 leftRightAxis = camD.cross(camUpV);
2529
2530 myCam->position = p1;
2531 myCam->pointAt(p2, camUpV);
2532
2533 // Update camera position
2534 p1 = p1 + (up_down * camUpV) + (left_right * leftRightAxis);
2535 myCam->position = p1;
2536 // FWJ Try look-ahead here
2537 int idx = refParticleIdx + pathLookahead;
2538 idx = std::min(idx, (int)refParticleTrajectory.size() - 1);
2539 myCam->pointAt(refParticleTrajectory[idx], camUpV);
2540 // myCam->pointAt(refParticleTrajectory[idx], camUpVec);
2541 myCam->focalDistance = 0.1f;
2542}

Referenced by animateRefParticle(), and processSoEvent().

◆ setViewPt()

void G4OpenInventorQtExaminerViewer::setViewPt ( )
protected

Definition at line 3059 of file G4OpenInventorQtExaminerViewer.cc.

3060{
3061 if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
3062 || currentState == ROTATING) {
3063 if (animateSensor->isScheduled()) animateSensor->unschedule();
3064 setSuperimpositionEnabled(superimposition, FALSE);
3065 maxSpeed = 0.0f;
3066 scheduleRedraw();
3067 }
3068
3069 SoCamera * camera = getCamera();
3070 if (camera == NULL) {
3071 G4warn << "setViewPt: Camera is null. Unable to set the viewpoint." <<
3072 G4endl;
3073 // String dialogName = (char *) "Missing Camera Node";
3074 // std::string msg = "Camera is null. Unable to set the viewpoint.";
3075 // warningMsgDialog(msg, dialogName, NULL);
3076 return;
3077 }
3078
3079 if (!viewPtList.size()) {
3080 G4warn << "setViewPt: There are no viewpoints to load." << G4endl;
3081 // String dialogName = (char *) "Missing Viewpoints";
3082 // std::string msg = "There are no viewpoints to load.";
3083 // warningMsgDialog(msg, dialogName, NULL);
3084 return;
3085 }
3086
3087 if (SoQtExaminerViewer::isAnimating()) stopAnimating();
3088
3089 if (currentState != VIEWPOINT) {
3090 currentState = VIEWPOINT;
3091 //////////////////////////////////////////////////////////////
3092 setSuperimpositionEnabled(superimposition, TRUE);
3093 axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
3094 animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
3095 animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
3096 scheduleRedraw();
3097 ///////////////////////////////////////////////////////////////
3098 }
3099
3100#if QT_VERSION < 0x060000
3101#else
3102 if((viewPtIdx<0)||(viewPtIdx>=int(viewPtList.size()))) {
3103 G4warn << "setViewPt: inconsitent viewPtIdx " << viewPtIdx << ", viewPtList.size() " << viewPtList.size() << G4endl;
3104 return;
3105 }
3106#endif
3107
3108 curViewPtName = viewPtList[viewPtIdx].viewPtName;
3109 camera->viewportMapping = viewPtList[viewPtIdx].viewportMapping;
3110 camera->position = viewPtList[viewPtIdx].position;
3111 camera->orientation = viewPtList[viewPtIdx].orientation;
3112 camera->aspectRatio = viewPtList[viewPtIdx].aspectRatio;
3113 camera->nearDistance = viewPtList[viewPtIdx].nearDistance;
3114 camera->farDistance = viewPtList[viewPtIdx].farDistance;
3115 camera->focalDistance = viewPtList[viewPtIdx].focalDistance;
3116
3117 // Restore camera height (changed by zooming)
3118 if (camera->isOfType(SoPerspectiveCamera::getClassTypeId())) {
3119 if (viewPtList[viewPtIdx].camType == ORTHOGRAPHIC) {
3120 toggleCameraType();
3121 camera = getCamera();
3122 ((SoOrthographicCamera *) camera)->height.setValue(
3123 viewPtList[viewPtIdx].height);
3124 } else
3125 ((SoPerspectiveCamera *) camera)->heightAngle.setValue(
3126 viewPtList[viewPtIdx].height);
3127 } else if (camera->isOfType(SoOrthographicCamera::getClassTypeId())) {
3128 if (viewPtList[viewPtIdx].camType == PERSPECTIVE) {
3129 toggleCameraType();
3130 camera = getCamera();
3131 ((SoPerspectiveCamera *) camera)->heightAngle.setValue(
3132 viewPtList[viewPtIdx].height);
3133 } else
3134 ((SoOrthographicCamera *) camera)->height.setValue(
3135 viewPtList[viewPtIdx].height);
3136 } else {
3137 SoDebugError::post("G4OpenInventorQtExaminerViewer::setViewPt",
3138 "Only Perspective and Orthographic cameras are supported.");
3139 return;
3140 }
3141
3142}

Referenced by deleteViewPt().

◆ sortElements()

void G4OpenInventorQtExaminerViewer::sortElements ( )
protected

Definition at line 1977 of file G4OpenInventorQtExaminerViewer.cc.

1978{
1979 if(refParticleTrajectory.empty())
1980 return;
1981
1982 float * trajLength = new float[refParticleTrajectory.size()];
1983 typedef std::map<elementForSorting, sceneElement> sortedMap;
1984 sortedMap sorted;
1985
1986 // For every point on the reference trajectory, compute
1987 // the total length from the start
1988 SbVec3f prevPoint;
1989 std::vector<SbVec3f>::iterator itRef = refParticleTrajectory.begin();
1990 int trajIndex = 0;
1991 prevPoint = *itRef;
1992 trajLength[trajIndex] = 0.0;
1993 ++itRef;
1994 ++trajIndex;
1995 for(; itRef != refParticleTrajectory.end(); ++itRef, ++trajIndex) {
1996 trajLength[trajIndex] = trajLength[trajIndex-1] + (*itRef - prevPoint).length();
1997 prevPoint = *itRef;
1998 }
1999
2000 // Compute the smallest distance between the element
2001 // and the reference trajectory (find the closest point),
2002 // then map the element to the trajectory length of that
2003 // point (calculated above)
2004 SoGetBoundingBoxAction bAction(getViewportRegion());
2005 SbVec3f elementCoord;
2006 std::vector<sceneElement>::iterator itEl;
2007 int elementIndex;
2008 elementForSorting el;
2009 for(itEl = sceneElements.begin(), elementIndex = 0;
2010 itEl != sceneElements.end(); ++itEl, ++elementIndex) {
2011 bAction.apply(itEl->path);
2012
2013 // FWJ sceneElement already has a center
2014 elementCoord = itEl->center;
2015 // ... and this sometimes returns an empty box!
2016 // elementCoord = bAction.getBoundingBox().getCenter();
2017 // if (bAction.getBoundingBox().isEmpty()) {
2018 // G4cout << "sortElements: Box is empty!" << G4endl;
2019 // G4cout << " element name=" << itEl->name << G4endl;
2020 // }
2021
2022 int index;
2023 distanceToTrajectory(elementCoord, el.smallestDistance, el.closestPoint, index);
2024 itEl->closestPointZCoord = el.closestPointZCoord = trajLength[index];
2025 el.distanceToBeamlineStart = (itEl->center - refParticleTrajectory[0]).length();
2026
2027 // This map of the scene elements (or their coordinates rather)
2028 // is automatically sorted by trajectory length (Z coord), then
2029 // by the distance between the element and the point in case the Z coord
2030 // is the same as another element. This is done by using as a key
2031 // an element structure which implements the operator for weak ordering
2032 sorted.insert(std::make_pair(el,*itEl));
2033 }
2034
2035 // store the sorted elements into the vector field
2036 sceneElements.clear();
2037
2038 sortedMap::iterator itSorted = sorted.begin();
2039 for(; itSorted != sorted.end(); itSorted++)
2040 sceneElements.push_back(itSorted->second);
2041
2042 zcoordSetFlag = true;
2043
2044 createElementsList();
2045
2046 delete[] trajLength;
2047}
G4OpenInventorQtExaminerViewer::distanceToTrajectory
void distanceToTrajectory(const SbVec3f &, float &, SbVec3f &, int &)
Definition G4OpenInventorQtExaminerViewer.cc:1885

Referenced by invertRefPath(), and setReferencePath().

◆ sortViewPts()

void G4OpenInventorQtExaminerViewer::sortViewPts ( std::vector< std::string > sortedViewPts)
protected

Definition at line 3556 of file G4OpenInventorQtExaminerViewer.cc.

3557{
3558 SbVec3f axis;
3559 float x, y, z, angle;
3560 std::size_t sortIdx = 0, unsortIdx = 0;
3561
3562 if (fileOut.is_open())
3563 fileOut.close();
3564
3565 fileOut.open(fileName.c_str()); // Erase current viewpoint file
3566
3567 writeViewPtIdx();
3568
3569 std::size_t size = sortedViewPts.size();
3570 while (sortIdx < size) {
3571 while (strcmp(sortedViewPts[sortIdx].c_str(),
3572#if QT_VERSION < 0x060000
3573 viewPtList[unsortIdx].viewPtName))
3574#else
3575 viewPtList[unsortIdx].viewPtName.c_str()))
3576#endif
3577 unsortIdx++;
3578
3579 std::string vpName = viewPtList[unsortIdx].viewPtName;
3580
3581 while ((int) vpName.size() < MAX_VP_NAME)
3582 vpName += " ";
3583 fileOut << vpName << std::endl;
3584 viewPtList[unsortIdx].position.getValue(x, y, z);
3585 fileOut << x << " " << y << " " << z << std::endl;
3586
3587 // Reusing x, y and z for storing the axis
3588 viewPtList[unsortIdx].orientation.getValue(axis, angle);
3589 axis.getValue(x, y, z);
3590 fileOut << x << " " << y << " " << z << " " << angle << std::endl;
3591
3592 fileOut << viewPtList[unsortIdx].camType << " "
3593 << viewPtList[unsortIdx].height << std::endl;
3594 fileOut << viewPtList[unsortIdx].focalDistance << " ";
3595
3596 fileOut << viewPtList[unsortIdx].nearDistance << " ";
3597
3598 fileOut << viewPtList[unsortIdx].farDistance << std::endl;
3599
3600 fileOut << viewPtList[unsortIdx].viewportMapping << " ";
3601 fileOut << viewPtList[unsortIdx].aspectRatio << "\n" << std::endl;
3602 fileOut.flush();
3603
3604 unsortIdx = 0;
3605 sortIdx++;
3606 }
3607}

Referenced by renameViewPt().

◆ sqrlen()

float G4OpenInventorQtExaminerViewer::sqrlen ( const SbVec3f & a)
protected

Definition at line 1877 of file G4OpenInventorQtExaminerViewer.cc.

1878{
1879 float x,y,z;
1880 a.getValue(x,y,z);
1881 return x*x + y*y + z*z;
1882}

Referenced by distanceToTrajectory().

◆ superimpositionCB()

void G4OpenInventorQtExaminerViewer::superimpositionCB ( void * closure,
SoAction * action )
staticprotected

Definition at line 855 of file G4OpenInventorQtExaminerViewer.cc.

857{
858 if (closure)
859 ((G4OpenInventorQtExaminerViewer*)closure)->superimpositionEvent(action);
860}

Referenced by construct().

◆ superimpositionEvent()

void G4OpenInventorQtExaminerViewer::superimpositionEvent ( SoAction * action)
protected

Definition at line 865 of file G4OpenInventorQtExaminerViewer.cc.

866{
867
868 if (!action->isOfType(SoGLRenderAction::getClassTypeId()))
869 return;
870 SbViewportRegion vpRegion =
871 ((SoGLRenderAction*)action)->getViewportRegion();
872 SbVec2s viewportSize = vpRegion.getViewportSizePixels();
873
874 // Aspect is WIDTH/HEIGHT
875 float aspect = float(viewportSize[0]) / float(viewportSize[1]);
876
877 // FWJ DEBUG
878 // G4cout << "SPEVENT X0 Y0 DX DY aspect: " << vpRegion.getViewportOrigin()[0] <<
879 // " " << vpRegion.getViewportOrigin()[1] <<
880 // " " << viewportSize[0] <<
881 // " " << viewportSize()[1] <<
882 // " " << aspect << G4endl;
883
884 // Translation and scale factor for animation speed indicator...
885
886 float factorx = 1.0f / float(viewportSize[1]) * 220.0f;
887 float factory = factorx;
888
889 if (aspect > 1.0f) {
890 stranslation->translation.setValue(SbVec3f(0.0f, -0.4f, 0.0f));
891 } else {
892 stranslation->translation.setValue(SbVec3f(0.0f, -0.4f / aspect, 0.0f));
893 factorx /= aspect;
894 factory /= aspect;
895 }
896 if (viewportSize[0] > 500)
897 factorx *= 500.0f / 400.0f;
898 else
899 factorx *= float(viewportSize[0]) / 400.0f;
900
901 sscale->scaleFactor.setValue(SbVec3f(factorx, factory, 1.0f));
902
903 // TEXT OVERLAY...
904
905 // FWJ Simplified and rewrote the following section to ease problems
906 // with the overlayed text after a viewer window resize.
907 // Result is now readable but needs further refinement of the scaling.
908
909 float xInfo, yInfo, xLogName, yLogName, xSolid, ySolid,
910 xMaterial, yMaterial, xZPos, yZPos;
911
912 // Base point for navigation distance or viewpoint name
913 // Origin is at center of render area.
914 xInfo = -.475;
915 yInfo = .475;
916 // Menu bar height in same coordinates:
917 float mbgap = 0.03;
918 if (aspect > 1.) xInfo = xInfo*aspect;
919 if (aspect < 1.) yInfo = yInfo/aspect;
920 yInfo = yInfo - mbgap*aspect;
921
922 // Following are relative to above base point
923 xLogName = 0.0;
924 yLogName = -.88 + mbgap*aspect;
925 xSolid = 0.0;
926 ySolid = -.91 + mbgap*aspect;
927 xMaterial = 0.0;
928 yMaterial = -.94 + mbgap*aspect;
929 xZPos = 0.0;
930 yZPos = -.97 + mbgap*aspect;
931
932 // Top line
933 curInfoTrans->translation.setValue(SbVec3f(xInfo, yInfo, 0.0));
934
935 // Bottom lines
936 mouseOverTransLogName->translation.setValue(SbVec3f(xLogName, yLogName, 0.0));
937 mouseOverTransSolid->translation.setValue(SbVec3f(xSolid, ySolid, 0.0));
938 mouseOverTransMaterial->translation.setValue(SbVec3f(xMaterial, yMaterial, 0.0));
939 mouseOverTransZPos->translation.setValue(SbVec3f(xZPos, yZPos, 0.0));
940
941 if (currentState == VIEWPOINT) { // Displaying viewpoint name
942 curInfoFont->size.setValue(15);
943 curInfoFont->name.setValue("defaultFont:Italic");
944#if QT_VERSION < 0x060000
945 curInfoText->string.setValue(SbString(curViewPtName));
946#else
947 curInfoText->string.setValue(SbString(curViewPtName.c_str()));
948#endif
949 }
950 else if(currentState == GENERAL) { // Displaying longitudinal distance
951 curInfoFont->size.setValue(16);
952 curInfoFont->name.setValue("defaultFont:Bold");
953 curInfoText->string.setValue(SbString(""));
954 }
955 else {
956 if (refParticleIdx < (int) refParticleTrajectory.size() - 1) {
957 curInfoFont->size.setValue(16);
958 curInfoFont->name.setValue("defaultFont:Bold");
959 char zPos[20];
960 // FWJ need a better format here
961 snprintf(zPos, sizeof zPos, "%-7.2f [m]", refZPositions[refParticleIdx] / 1000);
962 curInfoText->string.setValue(SbString(zPos));
963 }
964 }
965}

◆ updateSpeedIndicator()

void G4OpenInventorQtExaminerViewer::updateSpeedIndicator ( void )
protected

Definition at line 1574 of file G4OpenInventorQtExaminerViewer.cc.

1575{
1576 assert(this->sgeometry != NULL);
1577
1578 SbVec3f * points = this->sgeometry->point.startEditing();
1579
1580 if (points[10][0] == 0.0f)
1581 this->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_ALL);
1582 if (points[14][0] == 0.0f)
1583 this->animSpeedSwitch->whichChild.setValue(SO_SWITCH_ALL);
1584 points[10][0] = this->maxSpeed;
1585 points[11][0] = this->maxSpeed;
1586 points[14][0] = this->maxSpeed;
1587 points[15][0] = this->maxSpeed;
1588 this->sgeometry->point.finishEditing();
1589
1590 if (this->maxSpeed == 0.0f) {
1591 this->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
1592 this->animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
1593 }
1594}

Referenced by actualRedraw().

◆ updateViewParams()

void G4OpenInventorQtExaminerViewer::updateViewParams ( SoKeyboardEvent::Key )
protected

◆ viewPtAutoName()

std::string G4OpenInventorQtExaminerViewer::viewPtAutoName ( )
protected

◆ writeViewPtIdx()

void G4OpenInventorQtExaminerViewer::writeViewPtIdx ( )
protected

Definition at line 3011 of file G4OpenInventorQtExaminerViewer.cc.

3012{
3013 std::string idxStr;
3014 std::stringstream out;
3015
3016 out << viewPtIdx;
3017 idxStr = out.str();
3018 fileOut.seekp(0, std::ios::beg);
3019
3020 while ((int) idxStr.length() < MAX_VP_IDX) {
3021 idxStr += " ";
3022 }
3023
3024 // FWJ DEBUG
3025 // G4cout << "writeViewPtIdx: " << viewPtIdx << G4endl;
3026 fileOut << idxStr << "\n";
3027 fileOut.flush();
3028 fileOut.seekp(0, std::ios::end);
3029}

Referenced by deleteViewPt(), saveViewPt(), and sortViewPts().

◆ zoom()

void G4OpenInventorQtExaminerViewer::zoom ( const float diffvalue)
protected

Definition at line 3614 of file G4OpenInventorQtExaminerViewer.cc.

3615{
3616 float multiplicator = float(std::exp(diffvalue));
3617 SoCamera *cam = getCamera();
3618
3619 if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
3620 const float oldfocaldist = cam->focalDistance.getValue();
3621 const float newfocaldist = oldfocaldist * multiplicator;
3622
3623 SbVec3f direction;
3624 cam->orientation.getValue().multVec(SbVec3f(0, 0, -1), direction);
3625
3626 const SbVec3f oldpos = cam->position.getValue();
3627 const SbVec3f newpos = oldpos + (newfocaldist - oldfocaldist) * -direction;
3628 cam->position = newpos;
3629 cam->focalDistance = newfocaldist;
3630 } else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
3631 SoOrthographicCamera * oc = (SoOrthographicCamera *)cam;
3632 oc->height = oc->height.getValue() * multiplicator;
3633 }
3634}

Referenced by processSoEvent().

Friends And Related Symbol Documentation

◆ G4OpenInventorQtViewer

friend class G4OpenInventorQtViewer
friend

Definition at line 94 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by G4OpenInventorQtViewer.

◆ HookEventProcState

friend class HookEventProcState
friend

Definition at line 261 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and HookEventProcState.

Member Data Documentation

◆ abbrOutputFlag

bool G4OpenInventorQtExaminerViewer::abbrOutputFlag

Definition at line 233 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), mouseoverCB(), and pickingCB().

◆ animateBtwPtsPeriod

double G4OpenInventorQtExaminerViewer::animateBtwPtsPeriod
protected

Definition at line 297 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorCB(), animateSensorRotationCB(), construct(), decSpeed(), incSpeed(), and processSoEvent().

◆ animateSensor

SoTimerSensor* G4OpenInventorQtExaminerViewer::animateSensor
protected

Definition at line 301 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateRefParticle(), animateSensorCB(), construct(), decSpeed(), processSoEvent(), and setViewPt().

◆ animateSensorRotation

SoTimerSensor* G4OpenInventorQtExaminerViewer::animateSensorRotation
protected

Definition at line 302 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorRotationCB(), construct(), and rotateCamera().

◆ animSpeedOutlineSwitch

SoSwitch* G4OpenInventorQtExaminerViewer::animSpeedOutlineSwitch
protected

Definition at line 467 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), processSoEvent(), setViewPt(), and updateSpeedIndicator().

◆ animSpeedSwitch

SoSwitch* G4OpenInventorQtExaminerViewer::animSpeedSwitch
protected

Definition at line 468 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), processSoEvent(), setViewPt(), and updateSpeedIndicator().

◆ axisSwitch

SoSwitch* G4OpenInventorQtExaminerViewer::axisSwitch
protected

Definition at line 466 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), processSoEvent(), and setViewPt().

◆ beforePausing

State G4OpenInventorQtExaminerViewer::beforePausing
protected

Definition at line 412 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by processSoEvent().

◆ camB4Animation

viewPtData G4OpenInventorQtExaminerViewer::camB4Animation
protected

Definition at line 424 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by restoreCamera(), and saveCurCamera().

◆ camDir

SbVec3f G4OpenInventorQtExaminerViewer::camDir
protected

Definition at line 282 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera(), processSoEvent(), and rotateCamera().

◆ camEndOrient

SbRotation G4OpenInventorQtExaminerViewer::camEndOrient
protected

Definition at line 305 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateRefParticle(), and animateSensorCB().

◆ camEndPos

SbVec3f G4OpenInventorQtExaminerViewer::camEndPos
protected

Definition at line 304 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateRefParticle(), and animateSensorCB().

◆ camStartOrient

SbRotation G4OpenInventorQtExaminerViewer::camStartOrient
protected

Definition at line 305 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateRefParticle(), and animateSensorCB().

◆ camStartPos

SbVec3f G4OpenInventorQtExaminerViewer::camStartPos
protected

Definition at line 304 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateRefParticle(), and animateSensorCB().

◆ camUpVec

SbVec3f G4OpenInventorQtExaminerViewer::camUpVec
protected

Definition at line 281 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera(), processSoEvent(), and rotateCamera().

◆ center

SbVec3f G4OpenInventorQtExaminerViewer::center
protected

Definition at line 491 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera().

◆ curEltName

std::string G4OpenInventorQtExaminerViewer::curEltName
protected

Definition at line 280 of file G4OpenInventorQtExaminerViewer.hh.

◆ curInfoFont

SoFont* G4OpenInventorQtExaminerViewer::curInfoFont
protected

Definition at line 461 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ curInfoSwitch

SoSwitch* G4OpenInventorQtExaminerViewer::curInfoSwitch
protected

Definition at line 469 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ curInfoText

SoText2* G4OpenInventorQtExaminerViewer::curInfoText
protected

Definition at line 452 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ curInfoTrans

SoTranslation* G4OpenInventorQtExaminerViewer::curInfoTrans
protected

Definition at line 444 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ currentState

State G4OpenInventorQtExaminerViewer::currentState
protected

Definition at line 412 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by actualRedraw(), animateRefParticle(), animateSensorCB(), animateSensorRotationCB(), cleanUpAfterPrevFile(), construct(), incSpeed(), processSoEvent(), setStartingPtForAnimation(), setViewPt(), and superimpositionEvent().

◆ curViewPtName

char* G4OpenInventorQtExaminerViewer::curViewPtName
protected

Definition at line 414 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), deleteViewPt(), renameViewPt(), setViewPt(), and superimpositionEvent().

◆ defaultHeight

float G4OpenInventorQtExaminerViewer::defaultHeight
protected

Definition at line 485 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook().

◆ defaultHeightAngle

float G4OpenInventorQtExaminerViewer::defaultHeightAngle
protected

Definition at line 486 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook().

◆ distance

float G4OpenInventorQtExaminerViewer::distance
protected

Definition at line 411 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera(), and rotateCamera().

◆ fileIn

std::ifstream G4OpenInventorQtExaminerViewer::fileIn
protected

Definition at line 398 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook(), deleteViewPt(), loadViewPts(), and renameViewPt().

◆ fileName

std::string G4OpenInventorQtExaminerViewer::fileName
protected

Definition at line 397 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook(), construct(), deleteViewPt(), renameViewPt(), and sortViewPts().

◆ fileOut

std::ofstream G4OpenInventorQtExaminerViewer::fileOut
protected

Definition at line 399 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook(), cleanUpAfterPrevFile(), deleteViewPt(), renameViewPt(), saveViewPt(), sortViewPts(), and writeViewPtIdx().

◆ hookBeamOn

HookEventProcState* G4OpenInventorQtExaminerViewer::hookBeamOn
protected

Definition at line 260 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and ~G4OpenInventorQtExaminerViewer().

◆ left_right

float G4OpenInventorQtExaminerViewer::left_right
protected

Definition at line 429 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), processSoEvent(), and setStartingPtForAnimation().

◆ MAX_VP_IDX

int G4OpenInventorQtExaminerViewer::MAX_VP_IDX
protected

Definition at line 401 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and writeViewPtIdx().

◆ MAX_VP_NAME

int G4OpenInventorQtExaminerViewer::MAX_VP_NAME
protected

Definition at line 402 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), renameViewPt(), saveViewPt(), and sortViewPts().

◆ maxSpeed

float G4OpenInventorQtExaminerViewer::maxSpeed
protected

Definition at line 480 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), decSpeed(), processSoEvent(), setViewPt(), and updateSpeedIndicator().

◆ mouseOverFontLogName

SoFont* G4OpenInventorQtExaminerViewer::mouseOverFontLogName
protected

Definition at line 464 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ mouseOverFontMaterial

SoFont* G4OpenInventorQtExaminerViewer::mouseOverFontMaterial
protected

Definition at line 463 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ mouseOverFontSolid

SoFont* G4OpenInventorQtExaminerViewer::mouseOverFontSolid
protected

Definition at line 462 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ mouseOverFontZPos

SoFont* G4OpenInventorQtExaminerViewer::mouseOverFontZPos
protected

Definition at line 465 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ mouseOverTextLogName

SoText2* G4OpenInventorQtExaminerViewer::mouseOverTextLogName
protected

Definition at line 458 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and mouseoverCB().

◆ mouseOverTextMaterial

SoText2* G4OpenInventorQtExaminerViewer::mouseOverTextMaterial
protected

Definition at line 457 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and mouseoverCB().

◆ mouseOverTextSolid

SoText2* G4OpenInventorQtExaminerViewer::mouseOverTextSolid
protected

Definition at line 456 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and mouseoverCB().

◆ mouseOverTextZPos

SoText2* G4OpenInventorQtExaminerViewer::mouseOverTextZPos
protected

Definition at line 459 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and mouseoverCB().

◆ mouseOverTransLogName

SoTranslation* G4OpenInventorQtExaminerViewer::mouseOverTransLogName
protected

Definition at line 447 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ mouseOverTransMaterial

SoTranslation* G4OpenInventorQtExaminerViewer::mouseOverTransMaterial
protected

Definition at line 446 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ mouseOverTransSolid

SoTranslation* G4OpenInventorQtExaminerViewer::mouseOverTransSolid
protected

Definition at line 445 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ mouseOverTransZPos

SoTranslation* G4OpenInventorQtExaminerViewer::mouseOverTransZPos
protected

Definition at line 448 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ myCam

SoCamera* G4OpenInventorQtExaminerViewer::myCam
protected

Definition at line 427 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook(), animateRefParticle(), construct(), processSoEvent(), and setStartingPtForAnimation().

◆ newEvents

bool G4OpenInventorQtExaminerViewer::newEvents
protected

Definition at line 262 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and sceneChangeCB().

◆ newSceneGraph

SoSeparator* G4OpenInventorQtExaminerViewer::newSceneGraph
protected

Definition at line 494 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ offsetFromCenter

SbVec3f G4OpenInventorQtExaminerViewer::offsetFromCenter
protected

Definition at line 491 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera().

◆ pathLookahead

G4int G4OpenInventorQtExaminerViewer::pathLookahead
protected

Definition at line 488 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and setStartingPtForAnimation().

◆ pickRefPathFlag

bool G4OpenInventorQtExaminerViewer::pickRefPathFlag

Definition at line 234 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and pickingCB().

◆ prevColorField

void* G4OpenInventorQtExaminerViewer::prevColorField
protected

Definition at line 422 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ prevParticleDir

SbVec3f G4OpenInventorQtExaminerViewer::prevParticleDir
protected

Definition at line 421 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera().

◆ prevPt

SbVec3f G4OpenInventorQtExaminerViewer::prevPt
protected

Definition at line 420 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera(), and rotateCamera().

◆ prevRefIdx

int G4OpenInventorQtExaminerViewer::prevRefIdx
protected

Definition at line 410 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by processSoEvent().

◆ prevState

State G4OpenInventorQtExaminerViewer::prevState
protected

Definition at line 412 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorRotationCB(), and processSoEvent().

◆ refParticleIdx

int G4OpenInventorQtExaminerViewer::refParticleIdx
protected

Definition at line 409 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorCB(), incSpeed(), moveCamera(), processSoEvent(), setStartingPtForAnimation(), and superimpositionEvent().

◆ refParticleTrajectory

std::vector<SbVec3f> G4OpenInventorQtExaminerViewer::refParticleTrajectory
protected

Definition at line 405 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorCB(), distanceToTrajectory(), evenOutRefParticlePts(), incSpeed(), invertRefPath(), moveCamera(), processSoEvent(), setReferencePath(), setReferencePathZPos(), setStartingPtForAnimation(), sortElements(), and superimpositionEvent().

◆ refZPositions

std::vector<float> G4OpenInventorQtExaminerViewer::refZPositions
protected

Definition at line 407 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by setReferencePathZPos(), and superimpositionEvent().

◆ returnToAnim

bool G4OpenInventorQtExaminerViewer::returnToAnim
protected

Definition at line 426 of file G4OpenInventorQtExaminerViewer.hh.

◆ returnToSaveVP

bool G4OpenInventorQtExaminerViewer::returnToSaveVP
protected

Definition at line 425 of file G4OpenInventorQtExaminerViewer.hh.

◆ rotAxis

SbVec3f G4OpenInventorQtExaminerViewer::rotAxis
protected

Definition at line 430 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by processSoEvent(), and rotateCamera().

◆ rotCnt

int G4OpenInventorQtExaminerViewer::rotCnt
protected

Definition at line 431 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorRotationCB(), processSoEvent(), and rotateCamera().

◆ rotUpVec

bool G4OpenInventorQtExaminerViewer::rotUpVec
protected

Definition at line 492 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct().

◆ saveRefCoordsFileName

std::string G4OpenInventorQtExaminerViewer::saveRefCoordsFileName

Definition at line 228 of file G4OpenInventorQtExaminerViewer.hh.

◆ saveScenegraphFileName

std::string G4OpenInventorQtExaminerViewer::saveScenegraphFileName

Definition at line 227 of file G4OpenInventorQtExaminerViewer.hh.

◆ sceneChangeSensor

SoNodeSensor* G4OpenInventorQtExaminerViewer::sceneChangeSensor
protected

Definition at line 303 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by afterRealizeHook().

◆ sceneElements

std::vector<sceneElement> G4OpenInventorQtExaminerViewer::sceneElements
protected

Definition at line 395 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by createElementsList(), getSceneElements(), and sortElements().

◆ searcher

SoSearchAction* G4OpenInventorQtExaminerViewer::searcher
protected

Definition at line 437 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and getSuperimpositionNode().

◆ sgeometry

SoCoordinate3* G4OpenInventorQtExaminerViewer::sgeometry
protected

Definition at line 440 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and updateSpeedIndicator().

◆ speedStep

double G4OpenInventorQtExaminerViewer::speedStep
protected

Definition at line 297 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by animateSensorCB(), construct(), decSpeed(), and incSpeed().

◆ sscale

SoScale* G4OpenInventorQtExaminerViewer::sscale
protected

Definition at line 441 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ step

int G4OpenInventorQtExaminerViewer::step
protected

Definition at line 419 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), moveCamera(), and processSoEvent().

◆ stranslation

SoTranslation* G4OpenInventorQtExaminerViewer::stranslation
protected

Definition at line 443 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), and superimpositionEvent().

◆ superimposition

SoNode* G4OpenInventorQtExaminerViewer::superimposition
protected

Definition at line 439 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), mouseoverCB(), processSoEvent(), and setViewPt().

◆ up_down

float G4OpenInventorQtExaminerViewer::up_down
protected

Definition at line 429 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), processSoEvent(), and setStartingPtForAnimation().

◆ upVector

SbVec3f G4OpenInventorQtExaminerViewer::upVector
protected

Definition at line 491 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by moveCamera().

◆ viewingBeforePickRef

bool G4OpenInventorQtExaminerViewer::viewingBeforePickRef

Definition at line 235 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by pickingCB().

◆ viewPtIdx

int G4OpenInventorQtExaminerViewer::viewPtIdx
protected

Definition at line 400 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by cleanUpAfterPrevFile(), construct(), deleteViewPt(), loadViewPts(), renameViewPt(), saveViewPt(), setViewPt(), and writeViewPtIdx().

◆ viewPtList

std::vector<viewPtData> G4OpenInventorQtExaminerViewer::viewPtList
protected

Definition at line 396 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by addViewPoints(), afterRealizeHook(), cleanUpAfterPrevFile(), deleteViewPt(), loadViewPts(), processSoEvent(), renameViewPt(), saveViewPt(), setViewPt(), and sortViewPts().

◆ zcoordSetFlag

bool G4OpenInventorQtExaminerViewer::zcoordSetFlag
protected

Definition at line 393 of file G4OpenInventorQtExaminerViewer.hh.

Referenced by construct(), createElementsList(), and sortElements().

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