lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c07cea1fe028470cd9050371f165c7c815eefb23
geant4/source/visualization/OpenInventor/src/G4OpenInventorQtExaminerViewer.cc
T
Gabriele Cosmo c07cea1fe0 Import Geant4 11.1.0.beta source tree
2022-07-01 10:44:02 +02:00

4116 lines
136 KiB
C++
Raw Blame History

//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// Frederick Jones TRIUMF 07 January 2018
#include "G4OpenInventorQtExaminerViewer.hh"
#include "ui_OIQtListsDialog.h"
#include "saveViewPt.h"
#include "pickext.h"
#include "pickref.h"
#include "wireframe.h"
#include <algorithm> // For using sort on a vector
#include "G4ios.hh"
#include "G4UImanager.hh"
#include "G4UIQt.hh"
#include <Inventor/Qt/SoQt.h>
#include <Inventor/Qt/SoQtCursor.h>
#include <Inventor/events/SoKeyboardEvent.h>
#include <Inventor/events/SoMouseButtonEvent.h>
#include <Inventor/events/SoLocation2Event.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoOrthographicCamera.h>
#include <Inventor/nodes/SoPerspectiveCamera.h>
// FWJ moved to header file
//#include <Inventor/nodes/SoEventCallback.h>
#include <Inventor/nodes/SoLineSet.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/errors/SoDebugError.h>
#include <Inventor/SoPickedPoint.h>
#include <Inventor/actions/SoWriteAction.h>
#include <Inventor/projectors/SbPlaneProjector.h>
#include <Inventor/sensors/SoTimerSensor.h> // Animation
#include <Inventor/sensors/SoNodeSensor.h> // Detect start of run
#include "Geant4_SoPolyhedron.h"
#include "G4TrajectoryPoint.hh"
#include "G4AttHolder.hh"
#include "G4AttCheck.hh"
#include <Inventor/nodes/SoCallback.h>
#include <Inventor/nodes/SoSwitch.h>
#include <Inventor/nodes/SoScale.h>
#include <Inventor/nodes/SoTranslation.h>
#include <Inventor/actions/SoSearchAction.h>
#include <Inventor/actions/SoGetBoundingBoxAction.h>
#include <Inventor/nodes/SoCoordinate3.h>
// For rendering distance during animation:
#include <Inventor/nodes/SoText2.h>
#include <Inventor/nodes/SoFont.h>
#include <Inventor/nodes/SoPointSet.h>
#include <Inventor/nodes/SoDrawStyle.h>
#include <Inventor/nodes/SoBaseColor.h>
// For searching for nodes within kits:
#include <Inventor/nodekits/SoBaseKit.h>
#include <QMenuBar>
#include <QPushButton>
#include <QRadioButton>
#include <QToolButton>
#include <QListWidget>
#include <QListWidgetItem>
#include <QInputDialog>
#include <QMessageBox>
#include <QFileDialog>
#include <QStyle>
#include <QCommonStyle>
//#include <QMainWindow>
#ifndef G4GMAKE
#include "moc_G4OpenInventorQtExaminerViewer.cpp"
#endif
G4OpenInventorQtExaminerViewer* G4OpenInventorQtExaminerViewer::viewer = 0;
#define MIN_SPEED 2.1 // Lower number means faster
#define START_STEP 0.3
#define SPEED_INDICATOR_STEP 0.045
#define MAX_SPEED_INDICATOR 0.81
// Number of steps 90 degree rotation around an element is split into
#define ROT_CNT 6
// Constructor
G4OpenInventorQtExaminerViewer::
G4OpenInventorQtExaminerViewer(QWidget* parent, const char* name, SbBool embed,
SoQtFullViewer::BuildFlag flag,
SoQtViewer::Type type)
: SoQtExaminerViewer(parent, name, embed, flag, type),
externalQtApp(0), processSoEventCount(0)
{
// FWJ DEBUG
// G4cout << "G4OpenInventorQtExaminerViewer CONSTRUCTOR CALLED" << G4endl;
// G4cout << "G4OpenInventorQtExaminerViewer parent=" << parent << G4endl;
// FWJ THIS DOESN'T WORK APPARENTLY NO MAINWINDOW
// QMenuBar* menubar = ((QMainWindow*)parent)->menuBar();
fName = new QString(name);
viewer = this;
construct(TRUE);
}
// Destructor
G4OpenInventorQtExaminerViewer::~G4OpenInventorQtExaminerViewer()
{
// if (superimposition != NULL) {
// removeSuperimposition(superimposition);
// superimposition->unref();
// superimposition = NULL;
// }
// if (animateSensor->isScheduled())
// animateSensor->unschedule();
// delete animateSensor;
// delete sceneChangeSensor;
// delete[] curViewPtName;
// delete searcher;
viewer = 0;
}
void G4OpenInventorQtExaminerViewer::construct(const SbBool)
{
setFeedbackSize(40);
hookBeamOn = new HookEventProcState(this);
newEvents = false;
buildWidget(getParentWidget());
fileName = "bookmarkFile"; // Default viewpoint file name
viewPtIdx = -1; // index of the most recent viewpoint in viewPtList vector
animateSensor = new SoTimerSensor(animateSensorCB, this);
animateSensorRotation = new SoTimerSensor(animateSensorRotationCB, this);
animateBtwPtsPeriod = MIN_SPEED;
currentState = GENERAL;
myCam = new SoPerspectiveCamera;
MAX_VP_IDX = 3;
MAX_VP_NAME = 35; // Max length of a viewpoint name, padded with spaces
curViewPtName = new char[MAX_VP_NAME + 1];
left_right = up_down = 0; // For movements around the beam during animation
speedStep = START_STEP; // For smoother animation speed increase/decrease
rotUpVec = false; // Used during scene element rotations
step = 1; //By default
// Used for moving along the beam with the
// mouse instead of rotating the view
lshiftdown = rshiftdown = false;
// Used for rotating the view with the camera
// staying in place
lctrldown = rctrldown = false;
// Used to send abbreviated output to the console when
abbrOutputFlag = false;
pickRefPathFlag = false;
prevColorField = NULL;
// warningFlag = false; // We come from the warning dialog
// myElementList = NULL;
// FWJ default path look-ahead
pathLookahead = 5;
newSceneGraph = NULL;
zcoordSetFlag = false;
//////////////////////////SUPERIMPOSED SCENE//////////////////////////
searcher = NULL;
// Used in animation; progressively scaled for gradual speed change
maxSpeed = 0.0f;
static const char * superimposed[] = {
"#Inventor V2.1 ascii", "",
"Separator ",
"{",
" MaterialBinding ",
" {",
" value OVERALL",
" }",
" OrthographicCamera ",
" {",
" height 1",
" nearDistance 0",
" farDistance 1",
" }",
" DEF soxt->callback Callback { }",
" Separator ",
" {",
" DEF soxt->translation Translation ",
" {",
" translation 0 0 0",
" }",
" DEF soxt->scale Scale ",
" {",
" scaleFactor 1 1 1",
" }",
" DEF soxt->geometry Coordinate3 ",
" {",
" point ",
" [",
" -0.81 -0.04 0, -0.81 0 0,",
" -0.81 0.04 0, 0 -0.04 0,",
" 0 0 0, 0 0.04 0,",
" 0.81 -0.04 0, 0.81 0 0,",
" 0.81 0.04 0,",
" 0 0.02 0,", // idx 9
" 0.81 0.02 0, 0.81 -0.02 0,",
" 0 -0.02 0,",
" 0 0.01 0,", // idx 13
" 0.4 0.01 0, 0.4 -0.01 0,",
" 0 -0.01 0",
" ]",
" }",
// current speed indicator (outline)
" DEF soxt->animSpeedOutlineSwitch Switch ",
" {",
" whichChild -3",
" Material ",
" {",
" emissiveColor 0 0 0",
" }",
" IndexedFaceSet ",
" {",
" coordIndex ",
" [",
" 12, 11, 10, 9, -1",
" ]",
" }",
" }",
// the coordinate system
" DEF soxt->axisSwitch Switch ",
" {",
" whichChild -3",
" BaseColor ",
" {",
" rgb 1 1 1",
" }",
" IndexedLineSet ",
" {",
" coordIndex ",
" [",
" 0, 2, -1,",
" 3, 5, -1,",
" 6, 8, -1,",
" 1, 7, -1",
" ]",
" }",
" }",
// current speed indicator
" DEF soxt->animSpeedSwitch Switch ",
" {",
" whichChild -3",
" Material ",
" {",
" emissiveColor 0 1 0",
" }",
" IndexedFaceSet ",
" {",
" coordIndex ",
" [",
" 16, 15, 14, 13, -1",
" ]",
" }",
" }",
" }",
// For displaying either z position (during animation) or current viewpoint name
" DEF soxt->curInfoSwitch Switch ",
" {",
" whichChild -3",
" DEF soxt->curInfoTrans Translation ",
" {",
" translation 0 0 0 ",
// " translation 10 20 30 ",
" }",
" DEF soxt->curInfoFont Font ",
" {",
" name defaultFont:Bold",
" size 16",
" }",
" DEF soxt->curInfoText Text2 ",
" {",
" string Hello",
" }",
" }",
// Need to use different fields for mouseover
// because newlines are ignored when the scene is rendered
" Separator ",
" {",
" DEF soxt->mouseOverTransLogName Translation ",
" {",
" translation 0 0 0 ",
" }",
" DEF soxt->mouseOverFontLogName Font ",
" {",
" name defaultFont:Bold",
" size 16",
" }",
" DEF soxt->mouseOverTextLogName Text2 { } ",
" }",
" Separator ",
" {",
" DEF soxt->mouseOverTransSolid Translation ",
" {",
" translation 0 0 0 ",
" }",
" DEF soxt->mouseOverFontSolid Font ",
" {",
" name defaultFont:Bold",
" size 16",
" }",
" DEF soxt->mouseOverTextSolid Text2 { } ",
" }",
" Separator ",
" {",
" DEF soxt->mouseOverTransMaterial Translation ",
" {",
" translation 0 0 0 ",
" }",
" DEF soxt->mouseOverFontMaterial Font ",
" {",
" name defaultFont:Bold",
" size 16",
" }",
" DEF soxt->mouseOverTextMaterial Text2 { } ",
" }",
" Separator ",
" {",
" DEF soxt->mouseOverTransZPos Translation ",
" {",
" translation 0 0 0 ",
" }",
" DEF soxt->mouseOverFontZPos Font ",
" {",
" name defaultFont:Bold",
" size 16",
" }",
" DEF soxt->mouseOverTextZPos Text2 { } ",
" }",
"}", NULL
};
int i, bufsize;
for (i = bufsize = 0; superimposed[i]; i++)
bufsize += strlen(superimposed[i]) + 1;
char * buf = new char[bufsize + 1];
for (i = bufsize = 0; superimposed[i]; i++) {
strcpy(buf + bufsize, superimposed[i]);
bufsize += strlen(superimposed[i]);
buf[bufsize] = '\n';
bufsize++;
}
SoInput * input = new SoInput;
input->setBuffer(buf, bufsize);
SbBool ok = SoDB::read(input, superimposition);
(void)ok; // FWJ added to avoid compiler warning
assert(ok);
delete input;
delete[] buf;
superimposition->ref();
sscale = (SoScale *) getSuperimpositionNode(superimposition, "soxt->scale");
stranslation = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->translation");
sgeometry = (SoCoordinate3 *) getSuperimpositionNode(superimposition, "soxt->geometry");
axisSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->axisSwitch");
animSpeedOutlineSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->animSpeedOutlineSwitch");
animSpeedSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->animSpeedSwitch");
curInfoSwitch = (SoSwitch *) getSuperimpositionNode(superimposition, "soxt->curInfoSwitch");
curInfoTrans = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->curInfoTrans");
curInfoFont = (SoFont *) getSuperimpositionNode(superimposition, "soxt->curInfoFont");
curInfoText = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->curInfoText");
mouseOverTransLogName = (SoTranslation*)getSuperimpositionNode(superimposition, "soxt->mouseOverTransLogName");
mouseOverFontLogName = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontLogName");
mouseOverTextLogName = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextLogName");
mouseOverTransSolid = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->mouseOverTransSolid");
mouseOverFontSolid = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontSolid");
mouseOverTextSolid = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextSolid");
mouseOverTransMaterial = (SoTranslation*)getSuperimpositionNode(superimposition, "soxt->mouseOverTransMaterial");
mouseOverFontMaterial = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontMaterial");
mouseOverTextMaterial = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextMaterial");
mouseOverTransZPos = (SoTranslation *) getSuperimpositionNode(superimposition, "soxt->mouseOverTransZPos");
mouseOverFontZPos = (SoFont *) getSuperimpositionNode(superimposition, "soxt->mouseOverFontZPos");
mouseOverTextZPos = (SoText2 *) getSuperimpositionNode(superimposition, "soxt->mouseOverTextZPos");
SoCallback * cb = (SoCallback *) getSuperimpositionNode(superimposition, "soxt->callback");
cb->setCallback(superimpositionCB, this);
addSuperimposition(superimposition);
setSuperimpositionEnabled(superimposition, FALSE);
axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
/////////////////////\SUPERIMPOSED SCENE///////////////////////////////////
}
// Adds a menu bar and menu items to the viewer.
void G4OpenInventorQtExaminerViewer::buildWidget(QWidget* parent)
{
if (!parent)
SoDebugError::post("G4OpenInventorQtExaminerViewer::buildWidget",
"Error: Parent is null.");
// Common font for (almost) all widgets
font = new QFont;
font->setPointSize(12);
// This font setting does not propagate to added child widgets - Why?
parent->setFont(*font);
// This propagates everywhere but would affect UIQt!
// QApplication::setFont(*font);
// MENU BAR
menubar = new QMenuBar(getRenderAreaWidget());
// FWJ DEBUG
// G4cout << "G4OpenInventorQtExaminerViewer: GOT A menubar=" <<
// menubar << G4endl;
filemenu = new QMenu("File");
menubar->addMenu(filemenu);
FileOpenBookmark = new QAction("Open Bookmark File", this);
FileOpenBookmark->setFont(*font);
connect(FileOpenBookmark, SIGNAL(triggered()), this,
SLOT(FileOpenBookmarkCB()));
filemenu->addAction(FileOpenBookmark);
FileNewBookmark = new QAction("New Bookmark File", this);
FileNewBookmark->setFont(*font);
connect(FileNewBookmark, SIGNAL(triggered()), this,
SLOT(FileNewBookmarkCB()));
filemenu->addAction(FileNewBookmark);
FileLoadRefPath = new QAction("Load Reference Path", this);
FileLoadRefPath->setFont(*font);
connect(FileLoadRefPath, SIGNAL(triggered()), this,
SLOT(FileLoadRefPathCB()));
filemenu->addAction(FileLoadRefPath);
FileSaveRefPath = new QAction("Save Reference Path", this);
FileSaveRefPath->setFont(*font);
connect(FileSaveRefPath, SIGNAL(triggered()), this,
SLOT(FileSaveRefPathCB()));
filemenu->addAction(FileSaveRefPath);
FileLoadSceneGraph = new QAction("Load scene graph", this);
FileLoadSceneGraph->setFont(*font);
connect(FileLoadSceneGraph, SIGNAL(triggered()), this,
SLOT(FileLoadSceneGraphCB()));
filemenu->addAction(FileLoadSceneGraph);
FileSaveSceneGraph = new QAction("Save scene graph", this);
FileSaveSceneGraph->setFont(*font);
connect(FileSaveSceneGraph, SIGNAL(triggered()), this,
SLOT(FileSaveSceneGraphCB()));
filemenu->addAction(FileSaveSceneGraph);
// Rest of File menu is done in G4OpenInventorQtViewer
toolsmenu = new QMenu("Tools");
menubar->addMenu(toolsmenu);
ToolsAnimateRefParticle = new QAction("Fly on Ref Path", this);
ToolsAnimateRefParticle->setFont(*font);
connect(ToolsAnimateRefParticle, SIGNAL(triggered()), this,
SLOT(ToolsAnimateRefParticleCB()));
toolsmenu->addAction(ToolsAnimateRefParticle);
ToolsRefPathStart = new QAction("Go to start of Ref Path", this);
ToolsRefPathStart->setFont(*font);
connect(ToolsRefPathStart, SIGNAL(triggered()), this,
SLOT(ToolsRefPathStartCB()));
toolsmenu->addAction(ToolsRefPathStart);
ToolsRefPathInvert = new QAction("Invert Ref Path", this);
ToolsRefPathInvert->setFont(*font);
connect(ToolsRefPathInvert, SIGNAL(triggered()), this,
SLOT(ToolsRefPathInvertCB()));
toolsmenu->addAction(ToolsRefPathInvert);
etcmenu = new QMenu("Etc");
menubar->addMenu(etcmenu);
// All Etc menu items are done in G4OpenInventorQtViewer
helpmenu = new QMenu("Help");
menubar->addMenu(helpmenu);
HelpControls = new QAction("Controls", this);
HelpControls->setFont(*font);
connect(HelpControls, SIGNAL(triggered()), this, SLOT(HelpControlsCB()));
helpmenu->addAction(HelpControls);
menubar->show();
// SoQtExaminerViewer::buildWidget(parent);
// APP VIEWER BUTTONS have their own box on upper left
// The built in viewer button list is PRIVATE
saveViewPtButton = new QPushButton;
saveViewPtButton->setIcon(QPixmap((const char **)saveViewPt_xpm));
saveViewPtButton->setIconSize(QSize(24,24));
saveViewPtButton->setToolTip("Bookmark this view");
connect(saveViewPtButton, SIGNAL(clicked()), this,
SLOT(SaveViewPtCB()));
addAppPushButton(saveViewPtButton);
nextViewPtButton = new QPushButton;
nextViewPtButton->setIconSize(QSize(24,24));
QCommonStyle style;
nextViewPtButton->setIcon(style.standardIcon(QStyle::SP_ArrowRight));
nextViewPtButton->setToolTip("Next bookmark");
connect(nextViewPtButton, SIGNAL(clicked()), this,
SLOT(NextViewPtCB()));
addAppPushButton(nextViewPtButton);
prevViewPtButton = new QPushButton;
prevViewPtButton->setIconSize(QSize(24,24));
prevViewPtButton->setIcon(style.standardIcon(QStyle::SP_ArrowLeft));
prevViewPtButton->setToolTip("Previous bookmark");
connect(prevViewPtButton, SIGNAL(clicked()), this,
SLOT(PrevViewPtCB()));
addAppPushButton(prevViewPtButton);
abbrOutputButton = new QPushButton;
abbrOutputButton->setCheckable(true);
abbrOutputButton->setIconSize(QSize(24,24));
abbrOutputButton->setIcon(QPixmap((const char **)pickext_xpm));
abbrOutputButton->setToolTip("Extended picking & readout");
connect(abbrOutputButton, SIGNAL(toggled(bool)), this,
SLOT(AbbrOutputCB(bool)));
addAppPushButton(abbrOutputButton);
pickRefPathButton = new QPushButton;
pickRefPathButton->setIconSize(QSize(24,24));
pickRefPathButton->setIcon(QPixmap((const char **)pickref_xpm));
pickRefPathButton->setToolTip("Pick ref trajectory");
connect(pickRefPathButton, SIGNAL(clicked()), this,
SLOT(PickRefPathCB()));
addAppPushButton(pickRefPathButton);
switchWireFrameButton = new QPushButton;
switchWireFrameButton->setCheckable(true);
switchWireFrameButton->setIconSize(QSize(24,24));
switchWireFrameButton->setIcon(QPixmap((const char **)wireframe_xpm));
switchWireFrameButton->setToolTip("Switch wireframe/solid");
connect(switchWireFrameButton, SIGNAL(toggled(bool)), this,
SLOT(SwitchWireFrameCB(bool)));
addAppPushButton(switchWireFrameButton);
switchAxesButton = new QPushButton;
switchAxesButton->setCheckable(true);
switchAxesButton->setText(QString("A"));
switchAxesButton->setToolTip("Axes on/off");
connect(switchAxesButton, SIGNAL(toggled(bool)), this,
SLOT(SwitchAxesCB(bool)));
addAppPushButton(switchAxesButton);
detachButton = new QPushButton;
detachButton->setIconSize(QSize(24,24));
detachButton->setIcon(style.standardIcon(QStyle::SP_CommandLink));
detachButton->setToolTip("Detach viewer window");
connect(detachButton, SIGNAL(clicked()), this,
SLOT(DetachCB()));
// Used for UIQt only so check and add later
// addAppPushButton(detachButton);
// HELP WINDOW
helpmsgbox = new QMessageBox(getParentWidget());
helpmsgbox->setWindowTitle("OIQt Controls");
helpmsgbox->setFont(*font);
QString messagetxt =
"\nVIEWING mode (Hand cursor):\n\n\
Left-button + pointer move: rotate\n\
Shift+Left-button + pointer move: pan\n\
Middle-button + pointer move: pan\n\
Ctrl+Shift+Left-button + pointer move: zoom\n\
Mouse wheel: zoom\n\
Right-button: popup menu\n\n\
PICKING mode (Arrow cursor):\n\n\
Click on a volume: geometry readout\n\
Click on a trajectory: particle & trajectory readout\n\
Ctrl + click on a volume: see daughters.\n\
Shift + click on a volume: see mother.\n\n\
EXTENDED PICKING mode (Arrow+ viewer button):\n\n\
Hover the mouse over a volume or trajectory for\n\
overlayed readout.\n\n\
ELEMENT NAVIGATION (requires Reference Path):\n\n\
Click on element in list: centers view on element\n\
Arrow keys: rotate in 90 degree steps around element \n\
Shift + Right Arrow: move to next element\n\
Shift + Left Arrow: move to previous element\n\n\
FLY mode (requires Reference Path):\n\n\
Page Up: Increase speed\n\
Page Down: Decrease speed (& reverse if wanted)\n\
Up Arrow: raise camera above path\n\
Down Arror: lower camera below path\n\
Escape: Exit fly mode";
helpmsgbox->setText(messagetxt);
helpmsgbox->setModal(false);
// helpmsgbox->setWindowModality(Qt::NonModal);
// AUXILIARY LISTS WINDOW
// Bypass the namespace in order to make a persistent object
AuxWindowDialog = new Ui_Dialog;
AuxWindow = new QDialog(parent);
AuxWindowDialog->setupUi(AuxWindow);
// SIGNALS
connect(AuxWindowDialog->listWidget, SIGNAL(itemClicked(QListWidgetItem*)),
this, SLOT(LoadBookmarkCB(QListWidgetItem*)));
connect(AuxWindowDialog->listWidget1, SIGNAL(itemClicked(QListWidgetItem*)),
this, SLOT(LookAtSceneElementCB(QListWidgetItem*)));
connect(AuxWindowDialog->pushButton_2, SIGNAL(clicked()),
this, SLOT(DeleteBookmarkCB()));
connect(AuxWindowDialog->pushButton_3, SIGNAL(clicked()),
this, SLOT(RenameBookmarkCB()));
connect(AuxWindowDialog->pushButton, SIGNAL(clicked()),
this, SLOT(SortBookmarksCB()));
// FWJ Better to do this after viewer window is realized
// AuxWindow->show();
// AuxWindow->raise();
// AuxWindow->activateWindow();
}
// Called right after buttons and widgets get realized.
// It sets the viewpoint last accessed.
void G4OpenInventorQtExaminerViewer::afterRealizeHook()
{
SoQtExaminerViewer::afterRealizeHook();
// Default height is used when selecting and viewing scene elements
// FWJ Added defaultHeight for Ortho camera
SoCamera *cam = getCamera();
if (cam) {
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
defaultHeightAngle =
((SoPerspectiveCamera *) cam)->heightAngle.getValue();
toggleCameraType();
defaultHeight =
((SoOrthographicCamera *) cam)->height.getValue();
toggleCameraType();
} else {
defaultHeight =
((SoOrthographicCamera *) cam)->height.getValue();
toggleCameraType();
cam = getCamera();
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
defaultHeightAngle =
((SoPerspectiveCamera *) cam)->heightAngle.getValue();
toggleCameraType();
}
}
// Open the default bookmark file
fileIn.open(fileName.c_str());
if (!fileIn.fail()) {
if (!loadViewPts()) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error reading bookmark file ";
messagetxt.append(QString(fileName.c_str()));
msgbox.setText(messagetxt);
msgbox.exec();
} else {
// Opens a file without erasing it
fileOut.open(fileName.c_str(), std::ios::in);
fileOut.seekp(0, std::ios::end); // For appending new data to the end
// FWJ DEBUG
// G4cout << "afterRealizeHook: opened EXISTING bookmark file"
// << G4endl;
if (viewPtList.size()) {
// FWJ disabled auto-selection of first viewpoint.
// Initial view should be user-controllable & not forced
// setViewPt();
addViewPoints();
}
}
fileIn.close();
} else {
// Creates a new default bookmark file
fileOut.open(fileName.c_str());
// FWJ DEBUG
// G4cout << "afterRealizeHook: Opened a NEW bookmark file" << G4endl;
}
fileIn.clear();
SoSeparator* root = (SoSeparator*) (getSceneManager()->getSceneGraph());
if (root == NULL)
SoDebugError::post("G4OpenInventorQtExaminerViewer::afterRealizeHook", "Root is null.");
else {
root->addChild(myCam); // For position/orientation calculation during animation
}
sceneChangeSensor = new SoNodeSensor;
sceneChangeSensor->setFunction(sceneChangeCB);
sceneChangeSensor->attach(root);
sceneChangeSensor->setData(this);
///////////////////////////// MOUSEOVER & PICK /////////////////////
// Monitor mouseover events for displaying the name of scene elements
// An SoEventCallback is needed instead of using the default processSoEvent
// because that last one does not provide us with an SoPath to the object
// that was picked
SoEventCallback *moCB = new SoEventCallback;
moCB->addEventCallback(
SoLocation2Event::getClassTypeId(),
mouseoverCB, static_cast<void *>(this));
root->addChild(moCB);
// Override the default picking mechanism present in G4OpenInventorViewer
// because we want abbreviated output when picking a trajectory
SoEventCallback *pickCB = new SoEventCallback;
pickCB->addEventCallback(
SoMouseButtonEvent::getClassTypeId(),
pickingCB, static_cast<void *>(this));
root->addChild(pickCB);
///////////////////////////// MOUSEOVER & PICK /////////////////////
AuxWindow->show();
AuxWindow->raise();
AuxWindow->activateWindow();
auto UI = G4UImanager::GetUIpointer();
uiQt = dynamic_cast<G4UIQt*>(UI->GetG4UIWindow());
// This explicitly sets the TabWidget as parent before addTab():
if (uiQt) {
viewerParent = getParentWidget();
viewerParent2 = viewerParent->parentWidget();
uiQt->AddTabWidget(getParentWidget(), *fName);
uiQtTabIndex = uiQt->GetViewerTabWidget()->currentIndex();
// attached = TRUE;
addAppPushButton(detachButton);
}
}
// This method locates a named node in the superimposed or original scene.
// FWJ RENAME THIS
SoNode*
G4OpenInventorQtExaminerViewer::getSuperimpositionNode(SoNode* root,
const char* name)
{
if (!searcher)
searcher = new SoSearchAction;
searcher->reset();
searcher->setName(SbName(name));
searcher->setInterest(SoSearchAction::FIRST);
searcher->setSearchingAll(TRUE);
searcher->apply(root);
assert(searcher->getPath());
return searcher->getPath()->getTail();
}
// FWJ don't know why userdata is called "closure"
// It contains the this pointer!
void G4OpenInventorQtExaminerViewer::superimpositionCB(void * closure,
SoAction * action)
{
if (closure)
((G4OpenInventorQtExaminerViewer*)closure)->superimpositionEvent(action);
}
// Renders and positions speed indicator and longitudinal
// distance/viewpoint name on the drawing canvas
void G4OpenInventorQtExaminerViewer::superimpositionEvent(SoAction * action)
{
if (!action->isOfType(SoGLRenderAction::getClassTypeId()))
return;
SbViewportRegion vpRegion =
((SoGLRenderAction*)action)->getViewportRegion();
SbVec2s viewportSize = vpRegion.getViewportSizePixels();
// Aspect is WIDTH/HEIGHT
float aspect = float(viewportSize[0]) / float(viewportSize[1]);
// FWJ DEBUG
// G4cout << "SPEVENT X0 Y0 DX DY aspect: " << vpRegion.getViewportOrigin()[0] <<
// " " << vpRegion.getViewportOrigin()[1] <<
// " " << viewportSize[0] <<
// " " << viewportSize()[1] <<
// " " << aspect << G4endl;
// Translation and scale factor for animation speed indicator...
float factorx = 1.0f / float(viewportSize[1]) * 220.0f;
float factory = factorx;
if (aspect > 1.0f) {
stranslation->translation.setValue(SbVec3f(0.0f, -0.4f, 0.0f));
} else {
stranslation->translation.setValue(SbVec3f(0.0f, -0.4f / aspect, 0.0f));
factorx /= aspect;
factory /= aspect;
}
if (viewportSize[0] > 500)
factorx *= 500.0f / 400.0f;
else
factorx *= float(viewportSize[0]) / 400.0f;
sscale->scaleFactor.setValue(SbVec3f(factorx, factory, 1.0f));
// TEXT OVERLAY...
// FWJ Simplified and rewrote the following section to ease problems
// with the overlayed text after a viewer window resize.
// Result is now readable but needs further refinement of the scaling.
float xInfo, yInfo, xLogName, yLogName, xSolid, ySolid,
xMaterial, yMaterial, xZPos, yZPos;
// Base point for navigation distance or viewpoint name
// Origin is at center of render area.
xInfo = -.475;
yInfo = .475;
// Menu bar height in same coordinates:
float mbgap = 0.03;
if (aspect > 1.) xInfo = xInfo*aspect;
if (aspect < 1.) yInfo = yInfo/aspect;
yInfo = yInfo - mbgap*aspect;
// Following are relative to above base point
xLogName = 0.0;
yLogName = -.88 + mbgap*aspect;
xSolid = 0.0;
ySolid = -.91 + mbgap*aspect;
xMaterial = 0.0;
yMaterial = -.94 + mbgap*aspect;
xZPos = 0.0;
yZPos = -.97 + mbgap*aspect;
// Top line
curInfoTrans->translation.setValue(SbVec3f(xInfo, yInfo, 0.0));
// Bottom lines
mouseOverTransLogName->translation.setValue(SbVec3f(xLogName, yLogName, 0.0));
mouseOverTransSolid->translation.setValue(SbVec3f(xSolid, ySolid, 0.0));
mouseOverTransMaterial->translation.setValue(SbVec3f(xMaterial, yMaterial, 0.0));
mouseOverTransZPos->translation.setValue(SbVec3f(xZPos, yZPos, 0.0));
if (currentState == VIEWPOINT) { // Displaying viewpoint name
curInfoFont->size.setValue(15);
curInfoFont->name.setValue("defaultFont:Italic");
curInfoText->string.setValue(SbString(curViewPtName));
}
else if(currentState == GENERAL) { // Displaying longitudinal distance
curInfoFont->size.setValue(16);
curInfoFont->name.setValue("defaultFont:Bold");
curInfoText->string.setValue(SbString(""));
}
else {
if (refParticleIdx < (int) refParticleTrajectory.size() - 1) {
curInfoFont->size.setValue(16);
curInfoFont->name.setValue("defaultFont:Bold");
char zPos[20];
// FWJ need a better format here
sprintf(zPos, "%-7.2f [m]", refZPositions[refParticleIdx] / 1000);
// sprintf(zPos, "%7.2f [m]", refZPositions[refParticleIdx] / 1000);
curInfoText->string.setValue(SbString(zPos));
}
}
}
// Loads view point data from a file into a vector.
bool G4OpenInventorQtExaminerViewer::loadViewPts()
{
bool error = false;
viewPtData tmp;
std::string token;
SbVec3f axis;
SbRotation orient;
float x, y, z, angle;
// Gets the last view point accessed, stored in the first line of the data file.
fileIn >> token;
parseString<int>(viewPtIdx, token, error);
getline(fileIn, token); // Remove "\n"
// Converts data from string type into necessary types
while (getline(fileIn, token)) {
int end = token.find_last_not_of(' '); // Remove padded spaces
token = token.substr(0, end + 1);
char *vpName = new char[token.size() + 1];
strcpy(vpName, token.c_str());
tmp.viewPtName = vpName;
fileIn >> token;
parseString<float>(x, token, error);
fileIn >> token;
parseString<float>(y, token, error);
fileIn >> token;
parseString<float>(z, token, error);
fileIn >> token;
tmp.position = axis.setValue(x, y, z);
parseString<float>(x, token, error);
fileIn >> token;
parseString<float>(y, token, error);
fileIn >> token;
parseString<float>(z, token, error);
fileIn >> token;
parseString<float>(angle, token, error);
fileIn >> token;
orient.setValue(axis.setValue(x, y, z), angle);
tmp.orientation = orient.getValue();
int camType;
parseString<int>(camType, token, error);
fileIn >> token;
tmp.camType = (CameraType) camType;
parseString<float>(tmp.height, token, error);
fileIn >> token;
parseString<float>(tmp.focalDistance, token, error);
fileIn >> token;
parseString<float>(tmp.nearDistance, token, error);
fileIn >> token;
parseString<float>(tmp.farDistance, token, error);
fileIn >> token;
parseString<int>(tmp.viewportMapping, token, error);
fileIn >> token;
parseString<float>(tmp.aspectRatio, token, error);
getline(fileIn, token); // To remove "\n" characters
getline(fileIn, token);
if (error) {
viewPtIdx = 0;
viewPtList.clear();
return false;
}
viewPtList.push_back(tmp);
}
return true;
}
// Rotates camera 90 degrees around a scene element.
// Rotation is animated for smoothness.
void G4OpenInventorQtExaminerViewer::rotateCamera()
{
SoCamera *cam = getCamera();
SbRotation rot(rotAxis, M_PI / (2 * ROT_CNT));
rot.multVec(camDir, camDir);
rot.multVec(camUpVec, camUpVec);
SbVec3f camPosNew = prevPt - (camDir*distance);
cam->position = camPosNew;
cam->pointAt(prevPt, camUpVec);
cam->focalDistance = (prevPt - camPosNew).length();
rotCnt--;
if (animateSensorRotation->isScheduled()) {
animateSensorRotation->unschedule();
}
animateSensorRotation->setBaseTime(SbTime::getTimeOfDay());
animateSensorRotation->setInterval(SbTime(0.02));
animateSensorRotation->schedule();
}
// Slides camera along the beamline.
void G4OpenInventorQtExaminerViewer::moveCamera(float dist, bool lookdown)
{
SoCamera *cam = getCamera();
SbVec3f p1, p2; // The particle moves from p1 to p2
SbVec3f particleDir; // Direction vector from p1 to p2
SbVec3f camPosNew; // New position of the camera
if(refParticleTrajectory.size() == 0) {
//refParticleTrajectory hasn't been set yet
if(dist)
distance = dist;
else
distance = (cam->position.getValue() - center).length();
cam->position.setValue(center + offsetFromCenter*distance);
cam->focalDistance = (cam->position.getValue() - center).length();
cam->pointAt(center, upVector);
}
else {
// If we move forward past the last trajectory point,
// go back to the beginning
if (refParticleIdx >= (int) refParticleTrajectory.size() - 1) {
prevPt = refParticleTrajectory[refParticleIdx - step];
dist = (prevPt - cam->position.getValue()).length();
refParticleIdx = 0;
}
// If we move backward past the beginning,
// go to the last trajectory point
if (refParticleIdx < 0) {
prevPt = refParticleTrajectory[refParticleIdx + step];
dist = (prevPt - cam->position.getValue()).length();
refParticleIdx = refParticleTrajectory.size() - 2;
}
// Set start and end points
p1 = refParticleTrajectory[refParticleIdx];
p2 = refParticleTrajectory[refParticleIdx + step];
// Get the direction from p1 to p2
particleDir = p2 - p1;
particleDir.normalize();
if(prevParticleDir == SbVec3f(0,0,0)) {
// First time entering BEAMLINE mode, look at
// the element from the front, with camera upright
if(lookdown)
camDir = SbVec3f(0,0,1);
else
camDir = SbVec3f(1,0,0);
camUpVec = SbVec3f(0,1,0);
// In case the start of the goes in a
// direction other than +z, rotate the camera accordingly
SbRotation rot(SbVec3f(0,0,1), particleDir);
rot.multVec(camDir, camDir);
rot.multVec(camUpVec, camUpVec);
}
else if(particleDir != prevParticleDir) {
// The beamline has changed direction
SbRotation rot(prevParticleDir, particleDir);
rot.multVec(camDir, camDir);
rot.multVec(camUpVec, camUpVec);
}
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
if (!dist)
distance = (prevPt - cam->position.getValue()).length();
else
distance = dist;
}
// FWJ distance not relevant -- use focalDistance
// if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
// if (!dist)
// distance = (prevPt - cam->position.getValue()).length();
// else
// distance = dist;
// }
float x,y,z;
prevPt.getValue(x,y,z);
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
camPosNew = p2 - (camDir*distance);
}
if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
// FWJ maintain focal distance
camPosNew = p2 - (camDir*cam->focalDistance.getValue());
// camPosNew = p2 - (camDir);
}
cam->position = camPosNew;
cam->pointAt(p2, camUpVec);
cam->focalDistance = (p2 - camPosNew).length();
p2.getValue(x,y,z);
camPosNew.getValue(x,y,z);
prevParticleDir = particleDir;
prevPt = p1; // For accurate distance calculation
}
}
void G4OpenInventorQtExaminerViewer::pickingCB(void *aThis,
SoEventCallback *eventCB)
{
SoHandleEventAction* action = eventCB->getAction();
const SoPickedPoint *pp = action->getPickedPoint();
G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*)aThis;
if(pp != NULL) {
SoPath* path = pp->getPath();
SoNode* node = ((SoFullPath*)path)->getTail();
if(node->getTypeId() == SoLineSet::getClassTypeId()) {
if(This->pickRefPathFlag) {
This->pickRefPathFlag = false;
if(This->viewingBeforePickRef != This->isViewing())
This->setViewing(This->viewingBeforePickRef);
else
This->setComponentCursor(SoQtCursor(SoQtCursor::DEFAULT));
// The trajectory is a set of lines stored in a LineSet
SoLineSet * trajectory = (SoLineSet *)node;
// FWJ DEBUG
// G4cout << "FOUND trajectory LineSet" << trajectory << G4endl;
// The set of all trajectories is stored in a Seperator group node
// one level above the LineSet that was picked. The nodes under that
// seperator are as follows (in this order): Material, LightModel,
// ResetTransform, MatrixTransform, Coordinate3, DrawStyle, LineSet
SoSeparator * grpNode =
(SoSeparator*)(((SoFullPath*)path)->getNodeFromTail(1));
// The node that contains the coordinates for the trajectory is a
// Coordinate3 node which occurs before the LineSet node. We iterate
// back through the nodes in the group until we find the Coordinate3 node
int nodeIndex = grpNode->findChild(trajectory);
SoNode * tmpNode;
// FWJ needs initialization
SoCoordinate3 * coords = 0;
// SoCoordinate3 * coords;
// We allow only 100 iterations, in case the node isn't found
// (should take only a few iterations)
for(int i = 0; i < 100; ++i) {
--nodeIndex;
tmpNode = grpNode->getChild(nodeIndex);
if(tmpNode->getTypeId() == SoCoordinate3::getClassTypeId()) {
//node found
coords = (SoCoordinate3 *)tmpNode;
break;
}
}
if(coords == NULL) {
G4cout << "Could not find the coordinates node"
" for the picked trajectory." << G4endl;
G4cout << " Reference trajectory not set" << G4endl;
return;
}
// FWJ DEBUG
// G4cout << "FOUND SoCoordinate3 node " << coords << G4endl;
if ((This->lshiftdown) || (This->rshiftdown))
This->setReferencePath(trajectory, coords, true); //APPENDING
else
This->setReferencePath(trajectory, coords, false);
return;
}
else if(This->abbrOutputFlag) {
G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
if(attHolder && attHolder->GetAttDefs().size()) {
std::string strTrajPoint = "G4TrajectoryPoint:";
std::ostringstream oss;
for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
G4cout << G4AttCheck(attHolder->GetAttValues()[i],
attHolder->GetAttDefs()[i]);
oss << G4AttCheck(attHolder->GetAttValues()[i],
attHolder->GetAttDefs()[i]);
if(oss.str().find(strTrajPoint) != std::string::npos) {
// Last attribute displayed was a trajectory point. Since we
// want abbreviated output, display the last one and exit
// (unless we're already at the last (and only) trajectory point)
if(i != attHolder->GetAttDefs().size()-1) {
G4cout << G4AttCheck(
attHolder->GetAttValues()[attHolder->GetAttDefs().size()-1],
attHolder->GetAttDefs()[attHolder->GetAttDefs().size()-1]);
}
break;
}
}
} else {
G4String name((char*)node->getName().getString());
G4String cls((char*)node->getTypeId().getName().getString());
G4cout << "SoNode : " << node
<< " SoType : " << cls
<< " name : " << name
<< G4endl;
G4cout << "No attributes attached." << G4endl;
}
return;
}
else{
//Go to default behavior
}
}
else {
//Go to default behavior
}
// Default behavior in G4OpenInventorViewer::SelectionCB
G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
if(attHolder && attHolder->GetAttDefs().size()) {
for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
G4cout << G4AttCheck(attHolder->GetAttValues()[i],
attHolder->GetAttDefs()[i]);
}
} else {
G4String name((char*)node->getName().getString());
G4String cls((char*)node->getTypeId().getName().getString());
G4cout << "SoNode : " << node
<< " SoType : " << cls
<< " name : " << name
<< G4endl;
G4cout << "No attributes attached." << G4endl;
}
//Suppress other event handlers
eventCB->setHandled();
}
}
void G4OpenInventorQtExaminerViewer::mouseoverCB(void *aThis, SoEventCallback *eventCB)
{
SoHandleEventAction* action = eventCB->getAction();
const SoPickedPoint* pp = action->getPickedPoint();
G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*)aThis;
if(!This->abbrOutputFlag)
return;
if(pp != NULL) {
const SbViewportRegion & viewportRegion = action->getViewportRegion();
std::string sLogName;
float x,y,z;
std::stringstream ssZPos;
std::stringstream ssSolids;
std::stringstream ssMaterials;
SoPath * path = pp->getPath();
SoNode* node = ((SoFullPath*)path)->getTail();
if(node->getTypeId() == Geant4_SoPolyhedron::getClassTypeId()) {
sLogName = "Logical Volume: ";
sLogName += ((Geant4_SoPolyhedron *)node)->getName().getString();
SoGetBoundingBoxAction bAction(viewportRegion);
bAction.apply((SoFullPath*)path);
SbBox3f bBox = bAction.getBoundingBox();
SbVec3f centr = bBox.getCenter();
centr.getValue(x,y,z);
ssZPos << "Pos: " << x << " " << y << " " << z;
G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
if(attHolder && attHolder->GetAttDefs().size()) {
std::vector<const std::map<G4String,G4AttDef>*> vecDefs =
attHolder->GetAttDefs();
std::vector<const std::vector<G4AttValue>*> vecVals =
attHolder->GetAttValues();
for (size_t i = 0; i < vecDefs.size(); ++i) {
const std::vector<G4AttValue> * vals = vecVals[i];
std::vector<G4AttValue>::const_iterator iValue;
for (iValue = vals->begin(); iValue != vals->end(); ++iValue) {
const G4String& valueName = iValue->GetName();
const G4String& value = iValue->GetValue();
if(valueName == "Solid") {
if(ssSolids.str() == "")
ssSolids << "Solid Name: " << value;
else
ssSolids << ", " << value;
}
if(valueName == "Material") {
if(ssMaterials.str() == "")
ssMaterials << "Material Name: " << value;
else
ssMaterials << ", " << value;
}
}
}
}
}
// FWJ Mouseover for trajectories
else if(node->getTypeId() == SoLineSet::getClassTypeId()) {
// G4cout << "Trajectory!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node);
if(attHolder && attHolder->GetAttDefs().size()) {
std::string strTrajPoint = "G4TrajectoryPoint:";
std::ostringstream oss;
G4String t1, t1Ch, t2, t3, t4;
for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
// G4cout << "Getting index " << i << " from attHolder" << G4endl;
// No, returns a vector!
// G4AttValue* attValue = attHolder->GetAttValues()[i];
const std::vector<G4AttValue>* vals = attHolder->GetAttValues()[i];
std::vector<G4AttValue>::const_iterator iValue;
for (iValue = vals->begin(); iValue != vals->end(); ++iValue) {
const G4String& valueName = iValue->GetName();
const G4String& value = iValue->GetValue();
// G4cout << " valueName = " << valueName << G4endl;
// G4cout << " value = " << value << G4endl;
// LINE 1
if (valueName == "PN") t1 = value;
if (valueName == "Ch") {
if (atof(value.c_str()) > 0)
t1Ch = " +";
else
t1Ch = " ";
t1Ch += value;
}
if (valueName == "PDG") {
t1 += " ";
t1 += value;
t1 += t1Ch;
This->mouseOverTextLogName->string.setValue(t1);
}
// G4cout << " t1 = " << t1 << G4endl;
// LINE 2
if (valueName == "EventID") t2 = "Evt " + value;
if (valueName == "ID") t2 += " Trk " + value;
if (valueName == "PID") {
t2 += " Prt " + value;
This->mouseOverTextSolid->string.setValue(t2);
}
// LINE 3
if (valueName == "IKE") t3 = "KE " + value;
if (valueName == "IMom") {
// Remove units
unsigned ipos = value.rfind(" ");
G4String value1 = value;
value1.erase(ipos);
t3 += " P (" + value1 + ")";
}
if (valueName == "IMag") {
t3 += " " + value + "/c";
// t3 += " " + value;
This->mouseOverTextMaterial->string.setValue(t3);
}
// LINE 4
if (valueName == "NTP") {
std::ostringstream t4oss;
t4oss << "TrjPts " << value;
t4oss << " Pos " << pp->getPoint()[0] << " " << pp->getPoint()[1] <<
" " << pp->getPoint()[2];
This->mouseOverTextZPos->string.setValue(SbString(t4oss.str().c_str()));
}
}
// G4cout << " NOW CALLING G4AttCheck" << G4endl;
// G4cout << G4AttCheck(attHolder->GetAttValues()[i],
// attHolder->GetAttDefs()[i]);
// oss << G4AttCheck(attHolder->GetAttValues()[i],
// attHolder->GetAttDefs()[i]);
// if(oss.str().find(strTrajPoint) != std::string::npos) {
// // Last attribute displayed was a trajectory point. Since we
// // want abbreviated output, display the last one and exit
// // (unless we're already at the last (and only) trajectory point)
// if(i != attHolder->GetAttDefs().size()-1) {
// G4cout << G4AttCheck(
// attHolder->GetAttValues()[attHolder->GetAttDefs().size()-1],
// attHolder->GetAttDefs()[attHolder->GetAttDefs().size()-1]);
// }
// break;
// }
}
}
This->setSuperimpositionEnabled(This->superimposition, TRUE);
This->scheduleRedraw();
eventCB->setHandled();
return;
}
bool redraw = false;
if(std::string(This->mouseOverTextLogName->string.getValues(0)->getString()) != sLogName) {
This->mouseOverTextLogName->string.setValue(SbString(sLogName.c_str()));
redraw = true;
}
if(std::string(This->mouseOverTextSolid->string.getValues(0)->getString()) != ssSolids.str()) {
This->mouseOverTextSolid->string.setValue(SbString(ssSolids.str().c_str()));
redraw = true;
}
if(std::string(This->mouseOverTextMaterial->string.getValues(0)->getString()) != ssMaterials.str()) {
This->mouseOverTextMaterial->string.setValue(SbString(ssMaterials.str().c_str()));
redraw = true;
}
if(std::string(This->mouseOverTextZPos->string.getValues(0)->getString()) != ssZPos.str()) {
This->mouseOverTextZPos->string.setValue(SbString(ssZPos.str().c_str()));
redraw = true;
}
if(redraw) {
This->setSuperimpositionEnabled(This->superimposition, TRUE);
This->scheduleRedraw();
}
eventCB->setHandled();
}
else {
if(std::string(This->mouseOverTextLogName->string.getValues(0)->getString()) != "") {
This->mouseOverTextLogName->string.setValue(SbString(""));
This->scheduleRedraw();
}
if(std::string(This->mouseOverTextSolid->string.getValues(0)->getString()) != "") {
This->mouseOverTextSolid->string.setValue(SbString(""));
This->scheduleRedraw();
}
if(std::string(This->mouseOverTextMaterial->string.getValues(0)->getString()) != "") {
This->mouseOverTextMaterial->string.setValue(SbString(""));
This->scheduleRedraw();
}
if(std::string(This->mouseOverTextZPos->string.getValues(0)->getString()) != "") {
This->mouseOverTextZPos->string.setValue(SbString(""));
This->scheduleRedraw();
}
}
}
// Called by hitting PageUp during animation.
void G4OpenInventorQtExaminerViewer::incSpeed() {
if (std::ceil(animateBtwPtsPeriod * 100) >= 4) {
if (speedStep > 0.08)
speedStep -= 0.02;
else
speedStep = 0.02;
animateBtwPtsPeriod -= speedStep;
} else
animateBtwPtsPeriod = 0.0;
if (currentState != PAUSED_ANIMATION) {
int lastIdx = refParticleTrajectory.size() - 1;
if (refParticleIdx < lastIdx && !animateSensor->isScheduled())
animateRefParticle();
}
}
// Called by hitting PageDown during animation.
void G4OpenInventorQtExaminerViewer::decSpeed() {
animateBtwPtsPeriod += speedStep;
if (animateBtwPtsPeriod < MIN_SPEED) {
if (std::floor(animateBtwPtsPeriod * 100) == 12) { // Errors in double representation
speedStep = 0.08;
} else if (animateBtwPtsPeriod > 0.12)
speedStep += 0.02;
} else {
animateBtwPtsPeriod = MIN_SPEED;
speedStep = START_STEP;
maxSpeed = 0.0f;
if (animateSensor->isScheduled())
animateSensor->unschedule();
}
}
// Based on the user's interaction the speed indicator bar needs to be adjusted
void G4OpenInventorQtExaminerViewer::updateSpeedIndicator(void)
{
assert(this->sgeometry != NULL);
SbVec3f * points = this->sgeometry->point.startEditing();
if (points[10][0] == 0.0f)
this->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_ALL);
if (points[14][0] == 0.0f)
this->animSpeedSwitch->whichChild.setValue(SO_SWITCH_ALL);
points[10][0] = this->maxSpeed;
points[11][0] = this->maxSpeed;
points[14][0] = this->maxSpeed;
points[15][0] = this->maxSpeed;
this->sgeometry->point.finishEditing();
if (this->maxSpeed == 0.0f) {
this->animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
this->animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
}
}
void G4OpenInventorQtExaminerViewer::actualRedraw(void) {
switch (currentState) {
case ANIMATION:
case REVERSED_ANIMATION:
case PAUSED_ANIMATION:
updateSpeedIndicator();
SoQtExaminerViewer::actualRedraw();
break;
default:
SoQtExaminerViewer::actualRedraw();
break;
}
}
void G4OpenInventorQtExaminerViewer::setReferencePath(SoLineSet *lineset,
SoCoordinate3 *coords, bool append)
{
// TODO: Color the reference path
// Disable the color stuff for now: changes all trajectories
// FWJ See G4OpenInventorXtExaminerViewer.cc for test code
// The trajectory is composed of all the polyline segments in the
// multiple value field (SoMFInt32) numVertices.
// For each of the numVertices.getNum()* polyline segments,
// retrieve the points from the SoCoordinate3 node
SbVec3f refParticlePt;
if(!append)
refParticleTrajectory.clear();
for(int i = 0; i < lineset->numVertices.getNum(); ++i) {
for(int j = 0; j < lineset->numVertices[i]; ++j) {
refParticlePt = coords->point[j];
refParticleTrajectory.push_back(refParticlePt);
}
}
// Remove points that are too close to each other
evenOutRefParticlePts();
setReferencePathZPos();
getSceneElements();
sortElements();
}
void G4OpenInventorQtExaminerViewer::setReferencePathZPos()
{
refZPositions.clear();
refZPositions.push_back(0);
float dist;
for(unsigned int i=0; i < refParticleTrajectory.size() - 1; ++i) {
dist = (refParticleTrajectory[i] -
refParticleTrajectory[i + 1]).length();
refZPositions.push_back(refZPositions[i] + dist);
}
}
void G4OpenInventorQtExaminerViewer::findAndSetRefPath()
{
SoSearchAction action;
action.setType(SoLineSet::getClassTypeId(),false);
action.setInterest(SoSearchAction::ALL);
action.apply(getSceneGraph());
SoPathList &pathList = action.getPaths();
if(pathList.getLength() != 0) {
SoCoordinate3 * coords = NULL;
std::vector<SoCoordinate3 *> coordvec;
std::vector<SoLineSet *> linevec;
bool refPathFound = false;
for(int i = 0; i < pathList.getLength(); ++i) {
SoFullPath *path = (SoFullPath *)pathList[i];
G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(path->getTail());
for (size_t j = 0; j < attHolder->GetAttDefs().size(); ++j) {
std::ostringstream oss;
oss << G4AttCheck(attHolder->GetAttValues()[j],
attHolder->GetAttDefs()[j]);
std::string findStr = "Type of trajectory (Type): ";
std::string compareValue = "REFERENCE";
size_t idx = oss.str().find(findStr);
if(idx != std::string::npos) {
if(oss.str().substr(idx + findStr.size(),
compareValue.size()) == compareValue) {
coords = getCoordsNode(path);
if(coords != NULL) {
refPathFound = true;
coordvec.push_back(coords);
linevec.push_back((SoLineSet *)path->getTail());
}
break;
}
}
findStr = "Track ID (ID): ";
idx = oss.str().find(findStr);
if(idx != std::string::npos) {
//index all primary tracks
std::string tmpstr = oss.str().substr(idx + findStr.size(),1);
std::istringstream buffer(tmpstr);
int num;
buffer >> num;
if(num == 1) {
// Check if next character is a number,
// in which case we don't have Track ID 1
// FWJ attempt to fix Coverity issue.
char nextChar = oss.str().at(idx+findStr.size()+1);
// const char * nextChar =
// oss.str().substr(idx + findStr.size() + 1,1).c_str();
if(std::isdigit(nextChar))
break; //Not a primary track, continue with next track
coords = getCoordsNode(path);
if(coords != NULL) {
coordvec.push_back(coords);
linevec.push_back((SoLineSet *)path->getTail());
break; //Found coords node, continue with next track
}
}
else
break; //Not a primary track, continue with next track
}
else{
//Not a Track ID attribute, fall through
}
}
if(refPathFound)
break;
}
if(coordvec.empty())
return; //No track with a Coordinate3 node found
if(refPathFound) {
//set ref path to last traj, coord in the vecs
setReferencePath(linevec.back(), coordvec.back());
return;
}
//else
int longestIdx = 0;
float longestLength = 0.0;
// For all paths
for(unsigned int i=0;i < linevec.size(); ++i) {
//First generate a vector with all the points in this lineset
std::vector<SbVec3f> trajectory;
// For all lines in the i path
for(int j=0; j < linevec[i]->numVertices.getNum(); ++j) {
// For all points in line j
for(int k=0; k < linevec[i]->numVertices[j]; ++k) {
trajectory.push_back(coordvec[i]->point[k]);
}
}
// Then calculate the total length
float tmpLength=0.0;
for(unsigned int j=0; j < trajectory.size() - 1; ++j) {
tmpLength += (trajectory[j] - trajectory[j + 1]).length();
}
if(tmpLength > longestLength) {
longestIdx = i;
longestLength = tmpLength;
}
}
// Set the longest path as the reference path
setReferencePath(linevec[longestIdx], coordvec[longestIdx]);
}
}
SoCoordinate3 * G4OpenInventorQtExaminerViewer::getCoordsNode(SoFullPath *path)
{
SoLineSet *trajectory = (SoLineSet *)path->getTail();
SoSeparator * grpNode = (SoSeparator*)(((SoFullPath*)path)->getNodeFromTail(1));
int nodeIndex = grpNode->findChild(trajectory);
SoNode * tmpNode;
// We allow only 100 iterations, in case the node isn't found
// (should take only a few iterations)
for (int i = 0; i < 100; ++i) {
--nodeIndex;
tmpNode = grpNode->getChild(nodeIndex);
if(tmpNode->getTypeId() == SoCoordinate3::getClassTypeId()) {
//node found
return (SoCoordinate3 *)tmpNode;
}
}
return NULL; //coords node not found
}
// Displays scene elements on the right side of listsDialog.
// else: scene graph is searched for Geant4_SoPolyhedron type nodes
void G4OpenInventorQtExaminerViewer::getSceneElements()
{
std::string field, eltName;
std::map<std::string, int> duplicates;
std::map<std::string, int> sceneElts;
SoSearchAction search;
Geant4_SoPolyhedron *node;
SoGroup *root = (SoGroup *)getSceneManager()->getSceneGraph();
SoBaseKit::setSearchingChildren(TRUE);
search.reset();
search.setSearchingAll(TRUE);
search.setInterest(SoSearchAction::ALL);
search.setType(Geant4_SoPolyhedron::getClassTypeId(), 0);
// FWJ DEBUG
// G4cout << "Searching for elements....." << G4endl;
search.apply(root);
SoPathList &pl = search.getPaths();
// First find which names occur more than once so we can append a counter to them
for (int i = 0; i < pl.getLength(); i++) {
SoFullPath *path = (SoFullPath *)pl[i];
node = (Geant4_SoPolyhedron *)path->getTail();
eltName = node->getName();
// G4cout << " FOUND " << i << " " << eltName << G4endl;
if(duplicates.count(eltName))
duplicates[eltName]++;
else
duplicates[eltName] = 1;
}
for(int i = 0; i < pl.getLength(); i++) {
float x,y,z;
std::stringstream ssCount;
SoFullPath *path = (SoFullPath *)pl[i];
node = (Geant4_SoPolyhedron *)path->getTail();
eltName = node->getName();
field = eltName;
if(duplicates[eltName] == 1)
ssCount << "";//duplicates[field]
else {
if(sceneElts.count(eltName))
sceneElts[eltName]++;
else
sceneElts[eltName] = 1;
ssCount << sceneElts[eltName];
field += "_";
}
field += ssCount.str();
SoGetBoundingBoxAction bAction(getViewportRegion());
bAction.apply(path);
SbBox3f bBox = bAction.getBoundingBox();
SbVec3f centr = bBox.getCenter();
centr.getValue(x,y,z);
path->ref();
sceneElement el = { field, path, centr, 0.0 };
sceneElements.push_back(el);
}
}
float G4OpenInventorQtExaminerViewer::sqrlen(const SbVec3f &a)
{
float x,y,z;
a.getValue(x,y,z);
return x*x + y*y + z*z;
}
void G4OpenInventorQtExaminerViewer::distanceToTrajectory(const SbVec3f &q,
float &dist,
SbVec3f &closestPoint,
int &index)
{
// a : Previous point on trajectory
// b : Next point on trajectory
// q : the point in space
// dab, daq, dbq: distance between a & b, a & q, b & q
//
// Theory: A point p on a line ab is defined as:
//
// p(t) = a+t?(b?a)
//
// note: All are vectors except the parameter t
//
// When t is between 0 and 1 the point p is situated between a and b on ab.
// The point p is defined in terms of the parameter t, subsequently so does
// the distance from the query point q to the point p. To find the minimum
// of that distance we differentiate it and set equal to zero:
//
// diff(Norm(p(t)- q)) = 0
//
// note: diff means taking the derivative with regard to t
//
// The resulting t is given in the code below. The square of the distance
// between p and q is given by:
//
// d^2 = (Norm(p(t)-q))^2
//
// The expression found is given in the code below (current_dist)
//
// Ref: http://programmizm.sourceforge.net/blog/2012/
// distance-from-a-point-to-a-polyline
//
// --PLG
const size_t count = refParticleTrajectory.size();
assert(count>0);
SbVec3f b = refParticleTrajectory[0];
SbVec3f dbq = b - q;
float sqrDist = sqrlen(dbq);
closestPoint = b;
index = 0;
for (size_t i = 1; i < count; ++i) {
const SbVec3f a = b;
const SbVec3f daq = dbq;
b = refParticleTrajectory[i];
dbq = b - q;
const SbVec3f dab = a - b;
float dab_x, dab_y, dab_z;
dab.getValue(dab_x,dab_y,dab_z);
float daq_x, daq_y, daq_z;
daq.getValue(daq_x, daq_y, daq_z);
float dbq_x, dbq_y, dbq_z;
dbq.getValue(dbq_x, dbq_y, dbq_z);
const float inv_sqrlen = 1./sqrlen(dab);
const float t = (dab_x*daq_x + dab_y*daq_y + dab_z*daq_z)*inv_sqrlen;
if (t<0.) {
// The trajectory point occurs before point a
// Go to the next point
continue;
}
float current_dist;
if (t<=1.) {
// The trajectory point occurs between a and b.
// Compute the distance to that point
current_dist = daq_x*daq_x + daq_y*daq_y + daq_z*daq_z
- t*(daq_x*dab_x + daq_y*dab_y + daq_z*dab_z)
+ t*t*(dab_x*dab_x + dab_y*dab_y + dab_z*dab_z);
}
else { //t>1.
// The trajectory point occurs after b.
// Get the distance to point b
current_dist = sqrlen(dbq);
}
if (current_dist < sqrDist) {
sqrDist = current_dist;
closestPoint = a + t*(b-a);
index = i;
}
}
dist = std::sqrt(sqrDist);
}
void G4OpenInventorQtExaminerViewer::sortElements()
{
if(refParticleTrajectory.empty())
return;
float * trajLength = new float[refParticleTrajectory.size()];
typedef std::map<elementForSorting, sceneElement> sortedMap;
sortedMap sorted;
// For every point on the reference trajectory, compute
// the total length from the start
SbVec3f prevPoint;
std::vector<SbVec3f>::iterator itRef = refParticleTrajectory.begin();
int trajIndex = 0;
prevPoint = *itRef;
trajLength[trajIndex] = 0.0;
++itRef;
++trajIndex;
for(; itRef != refParticleTrajectory.end(); ++itRef, ++trajIndex) {
trajLength[trajIndex] = trajLength[trajIndex-1] + (*itRef - prevPoint).length();
prevPoint = *itRef;
}
// Compute the smallest distance between the element
// and the reference trajectory (find the closest point),
// then map the element to the trajectory length of that
// point (calculated above)
SoGetBoundingBoxAction bAction(getViewportRegion());
SbVec3f elementCoord;
std::vector<sceneElement>::iterator itEl;
int elementIndex;
elementForSorting el;
for(itEl = sceneElements.begin(), elementIndex = 0;
itEl != sceneElements.end(); ++itEl, ++elementIndex) {
bAction.apply(itEl->path);
// FWJ sceneElement already has a center
elementCoord = itEl->center;
// ... and this sometimes returns an empty box!
// elementCoord = bAction.getBoundingBox().getCenter();
// if (bAction.getBoundingBox().isEmpty()) {
// G4cout << "sortElements: Box is empty!" << G4endl;
// G4cout << " element name=" << itEl->name << G4endl;
// }
int index;
distanceToTrajectory(elementCoord, el.smallestDistance, el.closestPoint, index);
itEl->closestPointZCoord = el.closestPointZCoord = trajLength[index];
el.distanceToBeamlineStart = (itEl->center - refParticleTrajectory[0]).length();
// This map of the scene elements (or their coordinates rather)
// is automatically sorted by trajectory length (Z coord), then
// by the distance between the element and the point in case the Z coord
// is the same as another element. This is done by using as a key
// an element structure which implements the operator for weak ordering
sorted.insert(std::make_pair(el,*itEl));
}
// store the sorted elements into the vector field
sceneElements.clear();
sortedMap::iterator itSorted = sorted.begin();
for(; itSorted != sorted.end(); itSorted++)
sceneElements.push_back(itSorted->second);
zcoordSetFlag = true;
createElementsList();
delete[] trajLength;
}
void G4OpenInventorQtExaminerViewer::createElementsList()
{
// FWJ DEBUG
// G4cout << "Populating ELEMENT LIST..." << G4endl;
AuxWindowDialog->listWidget1->clear();
// int size = sceneElements.size();
std::vector<sceneElement>::const_iterator it;
std::stringstream ss;
for(it=sceneElements.begin(); it!=sceneElements.end(); ++it) {
ss << it->name;
if(zcoordSetFlag)
ss << " [" << it->closestPointZCoord << "]";
new QListWidgetItem(ss.str().c_str(), AuxWindowDialog->listWidget1);
ss.str("");
}
}
// Called when user clicks a scene element in listsDialog.
// Zooms onto that element.
void
G4OpenInventorQtExaminerViewer::LookAtSceneElementCB(QListWidgetItem* item)
{
char* value;
std::string elementField;
// FWJ DEBUG
// G4cout << "AuxWindow: listWidget1 select element CALLBACK" << G4endl;
SoCamera * cam = getCamera();
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
value = strdup(qPrintable(item->text()));
// G4cout << "LOOKING FOR BOOKMARK " << value << G4endl;
if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
|| currentState == PAUSED_ANIMATION ) {
if (animateSensor->isScheduled())
animateSensor->unschedule();
setSuperimpositionEnabled(superimposition, FALSE);
maxSpeed = 0.0f;
scheduleRedraw();
restoreCamera();
currentState = prevState;
} else if (currentState == VIEWPOINT)
setSuperimpositionEnabled(superimposition, FALSE);
elementField = value;
int idx = elementField.find_last_of("[");
if(idx == -1)
idx = elementField.size(); //if "[" not found for whatever reason (list not sorted)
else
idx--; // To get rid of the space that is between the name and '['
bool error = false;
SoFullPath *path;
SoSearchAction search;
SoNode *root = getSceneManager()->getSceneGraph();
int counter, idxUnderscore = elementField.find_last_of("_");
parseString<int>(counter,
elementField.substr(idxUnderscore + 1, idx), error);
SoBaseKit::setSearchingChildren(TRUE);
search.reset();
search.setSearchingAll(TRUE);
// G4cout << " Starting search for elementField " << elementField
// << G4endl;
if(error) { // No counter is present => element name was not modified
curEltName = elementField.substr(0, idx);
search.setName(curEltName.c_str());
search.apply(root);
path = (SoFullPath *)search.getPath();
}
else {
curEltName = elementField.substr(0, idxUnderscore);
search.setInterest(SoSearchAction::ALL);
search.setName(curEltName.c_str());
search.apply(root);
SoPathList &pl = search.getPaths();
path = (SoFullPath *)pl[counter - 1]; // Since counter starts at 1, not 0
}
G4ThreeVector global;
// FWJ FLIP THIS
if ((idx > 0) && (path)) {
if(!refParticleTrajectory.empty()) {
SoGetBoundingBoxAction bAction(getViewportRegion());
bAction.apply(path);
SbBox3f bBox = bAction.getBoundingBox();
SbVec3f elementCoord = bBox.getCenter();
refParticleIdx = 0;
SbVec3f p;
float absLengthNow, absLengthMin;
int maxIdx = refParticleTrajectory.size() - 2;
int targetIdx = 0;
SbVec3f dir;
p = refParticleTrajectory[refParticleIdx];
absLengthMin = (p - elementCoord).length();
refParticleIdx++;
// Find a ref. particle's point closest to element's global coords
while (refParticleIdx < maxIdx) {
p = refParticleTrajectory[refParticleIdx];
absLengthNow = (p - elementCoord).length();
if (absLengthNow < absLengthMin) {
absLengthMin = absLengthNow;
targetIdx = refParticleIdx;
}
refParticleIdx++;
}
if (currentState != BEAMLINE) { // Set up default zoom
SbVec3f p1, pN;
currentState = BEAMLINE;
prevParticleDir = SbVec3f(0,0,0); //so that moveCamera() knows sets default parameters
p1 = prevPt = refParticleTrajectory[0];
pN = refParticleTrajectory[refParticleTrajectory.size() - 1];
distance = (pN - p1).length() / 10;
// FWJ Rather than switching to a default height, it is more flexible
// to keep the same height(magnification) while moving the camera.
// if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
// ((SoOrthographicCamera *) cam)->height.setValue(defaultHeight);
// // FWJ Restore the default height instead of hard-wired value
// // ((SoOrthographicCamera *) cam)->height.setValue(10000.0f);
// }
// else if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
// FWJ required to avoid extreme perspective after camera move:
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
((SoPerspectiveCamera*)cam)->heightAngle.setValue(defaultHeightAngle);
} else {
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId()))
distance = (prevPt - cam->position.getValue()).length();
}
refParticleIdx = targetIdx;
//////////////////////////////////////////////////////////////
setSuperimpositionEnabled(superimposition, TRUE);
axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
scheduleRedraw();
//////////////////////////////////////////////////////////////
moveCamera(distance);
}
else {
offsetFromCenter.setValue(0, 0, 1);
distance = 50;// small number since using viewAll() for default zoom
upVector.setValue(0, 1, 0);
moveCamera(distance);
cam->viewAll(path, getViewportRegion());
}
}
}
void G4OpenInventorQtExaminerViewer::FileLoadRefPathCB()
{
// G4cout << "File: Load Ref Path CALLBACK" << G4endl;
QFileDialog filedialog(getParentWidget(), tr("Load Reference Path"));
filedialog.setFileMode(QFileDialog::AnyFile);
filedialog.setFont(*font);
if (!filedialog.exec()) return;
QStringList filenameinlist = filedialog.selectedFiles();
QString filenamein = filenameinlist[0];
// G4cout << "Input file name is " << qPrintable(filenamein) << G4endl;
char* filename = new char[filenamein.size()+1];
filename = strdup(qPrintable(filenamein));
// G4cout << "char[] file name is " << filename << G4endl;
std::ifstream ifs(filename);
if(ifs.is_open()) {
refParticleTrajectory.clear();
float x,y,z;
while(ifs >> x >> y >> z) {
refParticleTrajectory.push_back(SbVec3f(x,y,z));
}
ifs.close();
} else {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Reference Path file not found: ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
return;
}
if (refParticleTrajectory.size() < 2) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Invalid Reference Path";
msgbox.setText(messagetxt);
msgbox.exec();
return;
}
// Following setReferencePath() ...
evenOutRefParticlePts();
setReferencePathZPos();
getSceneElements();
sortElements();
}
void G4OpenInventorQtExaminerViewer::FileSaveRefPathCB()
{
// G4cout << "File: Save Ref Path CALLBACK" << G4endl;
QFileDialog filedialog(getParentWidget(), tr("Save Reference Path"));
filedialog.setFileMode(QFileDialog::AnyFile);
// To enable confirmation of overwriting
filedialog.setAcceptMode(QFileDialog::AcceptSave);
filedialog.setFont(*font);
if (!filedialog.exec()) return;
QStringList filenameinlist = filedialog.selectedFiles();
QString filenamein = filenameinlist[0];
// G4cout << "Input file name is " << qPrintable(filenamein) << G4endl;
char* filename = new char[filenamein.size()+1];
filename = strdup(qPrintable(filenamein));
// G4cout << "char[] file name is " << filename << G4endl;
std::ofstream ofs(filename);
if (ofs.is_open()) {
float x,y,z;
for (unsigned int i=0; i < refParticleTrajectory.size(); ++i) {
refParticleTrajectory[i].getValue(x,y,z);
ofs << x << " " << y << " " << z << "\n";
}
ofs.close();
} else {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error opening file ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
}
}
void G4OpenInventorQtExaminerViewer::evenOutRefParticlePts()
{
if(refParticleTrajectory.empty())
return;
SbVec3f p1, p2, p3, dirNow, dirNxt, dir, p2_tmp, p_start, p_corner, p_nxt;
float avgDistBtwPts = 0;
float totalDistBtwPts = 0;
std::vector<SbVec3f> newRefParticleTrajectory;
SbVec3f refPoint;
int size = refParticleTrajectory.size() - 1;
int numOfPts = 0;
for (int i = 0; i < size; i++) {
p1 = refParticleTrajectory[i];
p2 = refParticleTrajectory[i + 1];
if (p1 == p2)
continue;
numOfPts++;
totalDistBtwPts += (p2 - p1).length();
}
// Nothing useful to do (and fix Coverity)
if (numOfPts <= 2) return;
avgDistBtwPts = totalDistBtwPts / numOfPts;
float minDistAllowed = 0.75 * avgDistBtwPts;
// float maxDistAllowed = 1.25 * avgDistBtwPts; // Pts tend to be close not far
float x, y, z;
int i = 0, j = 0;
while (i < size) {
p1 = refParticleTrajectory[i];
p2 = refParticleTrajectory[i + 1];
refPoint = p1;
p1.getValue(x, y, z);
newRefParticleTrajectory.push_back(refPoint);
j = i;
while ((p2 - p1).length() < minDistAllowed && j < (size - 1)) {
j++;
p1 = refParticleTrajectory[j];
p2 = refParticleTrajectory[j + 1];
}
if (j != i)
i = j + 1;
else
i++;
}
refParticleTrajectory.clear();
refParticleTrajectory = newRefParticleTrajectory;
}
void G4OpenInventorQtExaminerViewer::saveCurCamera()
{
SoCamera *cam = getCamera();
camB4Animation.viewportMapping = cam->viewportMapping.getValue();
camB4Animation.position = cam->position.getValue();
camB4Animation.orientation = cam->orientation.getValue();
camB4Animation.aspectRatio = cam->aspectRatio.getValue();
camB4Animation.nearDistance = cam->nearDistance.getValue();
camB4Animation.farDistance = cam->farDistance.getValue();
camB4Animation.focalDistance = cam->focalDistance.getValue();
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
camB4Animation.height =
((SoPerspectiveCamera *) cam)->heightAngle.getValue();
camB4Animation.camType = PERSPECTIVE;
} else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
camB4Animation.height =
((SoOrthographicCamera *) cam)->height.getValue();
camB4Animation.camType = ORTHOGRAPHIC;
}
}
void G4OpenInventorQtExaminerViewer::restoreCamera()
{
SoCamera *cam = getCamera();
cam->viewportMapping = camB4Animation.viewportMapping;
cam->position = camB4Animation.position;
cam->orientation = camB4Animation.orientation;
cam->aspectRatio = camB4Animation.aspectRatio;
cam->nearDistance = camB4Animation.nearDistance;
cam->farDistance = camB4Animation.farDistance;
cam->focalDistance = camB4Animation.focalDistance;
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
if (camB4Animation.camType == ORTHOGRAPHIC) {
toggleCameraType();
cam = getCamera();
((SoOrthographicCamera *) cam)->height.setValue(
camB4Animation.height);
} else
((SoPerspectiveCamera *) cam)->heightAngle.setValue(
camB4Animation.height);
} else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
if (camB4Animation.camType == PERSPECTIVE) {
toggleCameraType();
cam = getCamera();
((SoPerspectiveCamera *) cam)->heightAngle.setValue(
camB4Animation.height);
} else
((SoOrthographicCamera *) cam)->height.setValue(
camB4Animation.height);
}
}
void G4OpenInventorQtExaminerViewer::animateSensorRotationCB(void *data,
SoSensor *sensor)
{
SbTime curTime = SbTime::getTimeOfDay();
G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*) data;
SoTimerSensor* s = (SoTimerSensor*) sensor;
float t = float((curTime - s->getBaseTime()).getValue())
/ This->animateBtwPtsPeriod;
if ((t > 1.0f) || (t + s->getInterval().getValue() > 1.0f))
t = 1.0f;
SbBool end = (t == 1.0f);
if (end) {
This->animateSensorRotation->unschedule();
if(This->rotCnt) {
// rotations left
This->rotateCamera();
}
else {
// rotation over
This->currentState = This->prevState;
return;
}
}
}
// Called repeatedly during reference particle animation
void G4OpenInventorQtExaminerViewer::animateSensorCB(void *data,
SoSensor *sensor)
{
SbTime curTime = SbTime::getTimeOfDay();
G4OpenInventorQtExaminerViewer* This = (G4OpenInventorQtExaminerViewer*) data;
SoCamera *cam = This->getCamera();
SoTimerSensor* s = (SoTimerSensor*) sensor;
float t = float((curTime - s->getBaseTime()).getValue())
/ This->animateBtwPtsPeriod;
if ((t > 1.0f) || (t + s->getInterval().getValue() > 1.0f))
t = 1.0f;
SbBool end = (t == 1.0f);
cam->orientation = SbRotation::slerp(This->camStartOrient, This->camEndOrient, t);
cam->position = This->camStartPos + (This->camEndPos - This->camStartPos) * t;
if (end) {
This->animateSensor->unschedule();
if (This->currentState == ANIMATION) {
if (This->refParticleIdx < (int) (This->refParticleTrajectory.size() - 1))
This->animateRefParticle();
else {
This->animateBtwPtsPeriod = MIN_SPEED;
This->speedStep = START_STEP;
}
}
if (This->currentState == REVERSED_ANIMATION) {
if (This->refParticleIdx >= 1)
This->animateRefParticle();
else {
This->animateBtwPtsPeriod = MIN_SPEED;
This->speedStep = START_STEP;
}
}
}
}
void G4OpenInventorQtExaminerViewer::setStartingPtForAnimation()
{
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
SbRotation rot;
SbVec3f p1, p2, p2_tmp, camUpV, camD, camD_tmp, leftRightAxis;
float x1, y1, z1, x2, y2, z2;
if (currentState == ANIMATION) {
p1 = refParticleTrajectory[refParticleIdx];
p2 = refParticleTrajectory[++(refParticleIdx)];
} else if (currentState == REVERSED_ANIMATION) {
p2 = refParticleTrajectory[refParticleIdx];
p1 = refParticleTrajectory[--(refParticleIdx)];
} else if (currentState == PAUSED_ANIMATION) {
if (refParticleIdx < (int) refParticleTrajectory.size()) {
p1 = refParticleTrajectory[refParticleIdx];
p2 = refParticleTrajectory[refParticleIdx + 1];
} else {
p1 = refParticleTrajectory[refParticleIdx - 1];
p2 = refParticleTrajectory[refParticleIdx];
}
}
p1.getValue(x1, y1, z1);
p2.getValue(x2, y2, z2);
camD = p2 - p1;
camD.normalize();
p2_tmp.setValue(x2, y1, z2);
camD_tmp = p2_tmp - p1;
camD_tmp.normalize();
camUpV.setValue(0, 1, 0);
rot.setValue(camD_tmp, camD);
rot.multVec(camUpV, camUpV);
leftRightAxis = camD.cross(camUpV);
myCam->position = p1;
myCam->pointAt(p2, camUpV);
// Update camera position
p1 = p1 + (up_down * camUpV) + (left_right * leftRightAxis);
myCam->position = p1;
// FWJ Try look-ahead here
int idx = refParticleIdx + pathLookahead;
idx = std::min(idx, (int)refParticleTrajectory.size() - 1);
myCam->pointAt(refParticleTrajectory[idx], camUpV);
// myCam->pointAt(refParticleTrajectory[idx], camUpVec);
myCam->focalDistance = 0.1f;
}
void G4OpenInventorQtExaminerViewer::gotoRefPathStart()
{
G4OpenInventorQtExaminerViewer::ToolsRefPathStartCB();
}
void G4OpenInventorQtExaminerViewer::ToolsRefPathStartCB()
{
if (!refParticleTrajectory.size()) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "No current reference path";
msgbox.setText(messagetxt);
msgbox.exec();
return;
}
if (currentState == ROTATING)
return;
if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
|| currentState == PAUSED_ANIMATION) {
if (animateSensor->isScheduled())
animateSensor->unschedule();
setSuperimpositionEnabled(superimposition, FALSE);
maxSpeed = 0.0f;
scheduleRedraw();
} else {
saveCurCamera();
prevState = currentState;
prevRefIdx = refParticleIdx;
}
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
up_down = 0;
left_right = 0;
step = 1;
refParticleIdx = 0;
currentState = BEAMLINE;
setSuperimpositionEnabled(superimposition, TRUE);
axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
scheduleRedraw();
// FWJ Disabled: this is set in moveCamera()
// Zoom in
// SoCamera *cam = getCamera();
// cam->focalDistance = 0.1f;
prevParticleDir = SbVec3f(0,0,0);
//Default zoom
SbVec3f p1 = refParticleTrajectory[0];
SbVec3f pN = refParticleTrajectory[refParticleTrajectory.size() - 1];
distance = (pN - p1).length() / 10;
moveCamera(distance, true);
}
void G4OpenInventorQtExaminerViewer::ToolsRefPathInvertCB()
{
invertRefPath();
}
void G4OpenInventorQtExaminerViewer::invertRefPath()
{
std::reverse(refParticleTrajectory.begin(),
refParticleTrajectory.end());
setReferencePathZPos();
sortElements();
}
void G4OpenInventorQtExaminerViewer::animateRefParticle()
{
SoCamera *cam = getCamera();
camStartPos = cam->position.getValue();
camStartOrient = cam->orientation.getValue();
if (currentState != BEAMLINE)
setStartingPtForAnimation();
camEndPos = myCam->position.getValue();
camEndOrient = myCam->orientation.getValue();
if (animateSensor->isScheduled())
animateSensor->unschedule();
animateSensor->setBaseTime(SbTime::getTimeOfDay());
animateSensor->setInterval(SbTime(0.02));
animateSensor->schedule();
}
void G4OpenInventorQtExaminerViewer::addEscapeCallback(void (*callback)())
{
escapeCallback = callback;
}
void G4OpenInventorQtExaminerViewer::sceneChangeCB(void* userData, SoSensor*)
{
// FWJ DEBUG
// G4cout << "SCENE CHANGE callback" << G4endl;
// NOTE: could/should be disabled during animation
G4OpenInventorQtExaminerViewer* This =
(G4OpenInventorQtExaminerViewer*)userData;
if(This->newEvents) {
This->findAndSetRefPath();
This->newEvents = false;
}
}
//////////////////////////////////// BOOKMARKS ///////////////////////////
// Adds bookmarks to listsDialog.
void G4OpenInventorQtExaminerViewer::addViewPoints()
{
int size = viewPtList.size();
if (!size) return;
for (int i = 0; i < size; i++) {
new QListWidgetItem(viewPtList[i].viewPtName,
AuxWindowDialog->listWidget);
}
}
// Converts a string type word into a float type.
template<class T>
void G4OpenInventorQtExaminerViewer::parseString(T &t, const std::string &s,
bool &error)
{
std::istringstream str(s);
if ((str >> t).fail())
error = true;
}
void
G4OpenInventorQtExaminerViewer::FileOpenBookmarkCB()
{
// FWJ DEBUG
// G4cout << "File: Open Bookmark File CALLBACK" << G4endl;
QFileDialog filedialog(getParentWidget(), tr("Open bookmark file"));
filedialog.setFileMode(QFileDialog::ExistingFile);
filedialog.setFont(*font);
if (!filedialog.exec()) return;
QStringList filenameinlist = filedialog.selectedFiles();
QString filenamein = filenameinlist[0];
char* filename = new char[filenamein.size()+1];
filename = strdup(qPrintable(filenamein));
// G4cout << "char[] file name is " << filename << G4endl;
fileIn.close();
fileIn.open(filename);
if (fileIn.fail()) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error opening file: ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
// G4cout << "ERROR opening file " << filename << G4endl;
fileIn.clear();
return;
}
// Opens a file without erasing it
cleanUpAfterPrevFile();
if (!loadViewPts()) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error reading bookmark file: ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
// G4cout << "ERROR reading bookmark file " << filename << G4endl;
fileIn.clear();
return;
}
fileName = filename;
fileOut.open(fileName.c_str(), std::ios::in);
fileOut.seekp(0, std::ios::end);
addViewPoints();
// LATER: display filename in lists window
fileIn.close();
fileIn.clear();
}
// Called before loading a new viewpoint file.
// Resets member fields to default values.
void G4OpenInventorQtExaminerViewer::cleanUpAfterPrevFile()
{
viewPtIdx = -1;
viewPtList.clear();
// setSuperimpositionEnabled(superimposition, FALSE);
// scheduleRedraw();
currentState = GENERAL;
if (fileOut.is_open()) fileOut.close();
AuxWindowDialog->listWidget->clear();
AuxWindowDialog->lineEdit->setText(QString(""));
}
void
G4OpenInventorQtExaminerViewer::FileNewBookmarkCB()
{
// G4cout << "File: Open New Bookmark File CALLBACK" << G4endl;
QFileDialog filedialog(getParentWidget(), tr("Open new bookmark file"));
filedialog.setFileMode(QFileDialog::AnyFile);
// To enable confirmation of overwriting
filedialog.setAcceptMode(QFileDialog::AcceptSave);
// But change the "Save" button text
filedialog.setLabelText(QFileDialog::Accept, QString("New"));
filedialog.setFont(*font);
if (!filedialog.exec()) return;
QStringList filenameinlist = filedialog.selectedFiles();
QString filenamein = filenameinlist[0];
// G4cout << "Input file name is " << qPrintable(filenamein) << G4endl;
char* filename = new char[filenamein.size()+1];
filename = strdup(qPrintable(filenamein));
// G4cout << "char[] file name is " << filename << G4endl;
cleanUpAfterPrevFile();
fileName = filename;
fileOut.open(fileName.c_str());
if (fileOut.fail()) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error opening new bookmark file: ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
// G4cout << "ERROR opening new bookmark file " << filename << G4endl;
}
}
void
G4OpenInventorQtExaminerViewer::ToolsAnimateRefParticleCB()
{
// G4cout << "Tools: Animate Ref Particle CALLBACK" << G4endl;
if (!refParticleTrajectory.size()) {
returnToAnim = true;
G4cout << "No Reference Trajectory" << G4endl;
return;
}
///////////////////////////////////////////////////////////////
setSuperimpositionEnabled(superimposition, TRUE);
maxSpeed = SPEED_INDICATOR_STEP;
axisSwitch->whichChild.setValue(SO_SWITCH_ALL);
animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_ALL);
animSpeedSwitch->whichChild.setValue(SO_SWITCH_ALL);
scheduleRedraw();
///////////////////////////////////////////////////////////////
SoCamera *cam = getCamera();
// SbVec3f camDirOld, camDirNew, camDirNew_tmp, camUpVec, P0, P1, P1_tmp;
if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
|| currentState == ROTATING)
return;
if (currentState != PAUSED_ANIMATION) {
saveCurCamera();
prevState = currentState;
prevRefIdx = refParticleIdx;
if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
toggleCameraType();
cam = getCamera();
}
refParticleIdx = 0; // Set the camera to the starting point of the animation
animateBtwPtsPeriod = MIN_SPEED;
speedStep = START_STEP;
left_right = up_down = 0;
cam->focalDistance = 0.1f;
((SoPerspectiveCamera *) cam)->heightAngle = 0.50f;
}
currentState = ANIMATION;
setStartingPtForAnimation();
cam->position = (myCam)->position.getValue();
cam->orientation = (myCam)->orientation.getValue();
animateRefParticle(); // Animate the camera
}
void
G4OpenInventorQtExaminerViewer::SaveViewPtCB()
{
// G4cout << "AppButton: Save Viewpoint CALLBACK" << G4endl;
// First get viewpoint name ...
// EMULATING getViewPtNameCB ...
// bool ok;
// Note QString() returns an empty string
// NONE OF THE FOLLOWING CHANGES THE FONT: FORGET IT FOR NOW
QInputDialog* inputdialog = new QInputDialog(getParentWidget());
inputdialog->setFont(*font);
inputdialog->setWindowTitle(tr("Enter a name for the bookmark"));
inputdialog->setLabelText("Bookmark name");
// inputdialog->setTextEchoMode(QLineEdit::Normal);
inputdialog->adjustSize();
QString namein;
if (inputdialog->exec() == QDialog::Accepted)
namein=inputdialog->textValue().trimmed();
else
return;
if (namein.isEmpty()) return;
// This easier approach failed: unable to set font size
// QString namein =
// QInputDialog::getText(getParentWidget(),
// tr("Enter a name for the bookmark"),
// tr("Bookmark name"), QLineEdit::Normal,
// QString(), &ok);
const int nVPName = MAX_VP_NAME + 1;
char* name = new char[nVPName];
// strncpy(name, strName.c_str(), nVPName);
namein.truncate(MAX_VP_NAME);
QByteArray ba = namein.toLocal8Bit();
name = strdup(ba.constData());
// name = strdup(qPrintable(namein))
// FWJ DEBUG
// G4cout << "QString is " << qPrintable(namein) << G4endl;
// G4cout << "char[] is " << name << G4endl;
for (int i = 0; i < (int)viewPtList.size(); i++) {
if (!strcmp(name, viewPtList[i].viewPtName)) {
QMessageBox msgbox;
msgbox.setText("Bookmark name is already in use");
msgbox.exec();
return;
}
}
if (viewPtIdx == -1) viewPtIdx = 0;
saveViewPt(name);
saveViewPtItem = new QListWidgetItem(namein,
AuxWindowDialog->listWidget);
AuxWindowDialog->listWidget->setCurrentItem(saveViewPtItem);
AuxWindowDialog->lineEdit->setText(namein);
}
// Saves current camera parameters to a viewpoint file.
void G4OpenInventorQtExaminerViewer::saveViewPt(char *name)
{
SbVec3f axis;
viewPtData tmp;
float x, y, z, angle;
SoCamera* camera = getCamera();
// NOTE: Xt VSN increments this at end of procedure
// viewPtIdx++;
// FWJ DEBUG
// G4cout << "saveViewPt: saving bookmark " << viewPtIdx << " " << name
// << G4endl;
if (viewPtList.size() == 0) {
writeViewPtIdx();
}
tmp.viewPtName = name;
tmp.viewportMapping = camera->viewportMapping.getValue();
tmp.position = camera->position.getValue();
tmp.orientation = camera->orientation.getValue();
tmp.aspectRatio = camera->aspectRatio.getValue();
tmp.nearDistance = camera->nearDistance.getValue();
tmp.farDistance = camera->farDistance.getValue();
tmp.focalDistance = camera->focalDistance.getValue();
// Save camera height (changed by zooming)
if (camera->isOfType(SoPerspectiveCamera::getClassTypeId())) {
tmp.height = ((SoPerspectiveCamera *) camera)->heightAngle.getValue();
tmp.camType = PERSPECTIVE;
} else if (camera->isOfType(SoOrthographicCamera::getClassTypeId())) {
tmp.height = ((SoOrthographicCamera *) camera)->height.getValue();
tmp.camType = ORTHOGRAPHIC;
} else {
SoDebugError::post("G4OpenInventorQtExaminerViewer::saveViewPtCB",
"Only Perspective and Orthographic cameras are supported.");
return;
}
viewPtList.push_back(tmp);
// Now save the view point to a .txt file
// FWJ DEBUG
// G4cout << "saveViewPt: writing to Bookmark file " << fileName << G4endl;
std::string vpName = name;
while ((int) vpName.size() <= MAX_VP_NAME)
vpName += " ";
fileOut << vpName << std::endl;
tmp.position.getValue(x, y, z);
fileOut << x << " " << y << " " << z << std::endl;
// Reusing x, y and z for storing the axis
tmp.orientation.getValue(axis, angle);
axis.getValue(x, y, z);
fileOut << x << " " << y << " " << z << " " << angle << std::endl;
fileOut << tmp.camType << " " << tmp.height << std::endl;
fileOut << tmp.focalDistance << " ";
fileOut << tmp.nearDistance << " ";
fileOut << tmp.farDistance << std::endl;
fileOut << tmp.viewportMapping << " ";
fileOut << tmp.aspectRatio << "\n" << std::endl;
fileOut.flush();
viewPtIdx++;
// FWJ DEBUG
// G4cout << "saveViewPt: finished writing to file" << G4endl <<
// " Next viewPtIdx is " << viewPtIdx << G4endl;
}
// Updates the viewPtIdx in a viewpoint file.
void G4OpenInventorQtExaminerViewer::writeViewPtIdx()
{
std::string idxStr;
std::stringstream out;
out << viewPtIdx;
idxStr = out.str();
fileOut.seekp(0, std::ios::beg);
while ((int) idxStr.length() < MAX_VP_IDX) {
idxStr += " ";
}
// FWJ DEBUG
// G4cout << "writeViewPtIdx: " << viewPtIdx << G4endl;
fileOut << idxStr << "\n";
fileOut.flush();
fileOut.seekp(0, std::ios::end);
}
// Receives the name of the bookmark clicked and searches for it in viewPtList.
void G4OpenInventorQtExaminerViewer::LoadBookmarkCB(QListWidgetItem* item)
{
// FWJ DEBUG
// G4cout << "AuxWindow: listWidget LoadBookmark CALLBACK" << G4endl;
const int nVPName = MAX_VP_NAME + 1;
char* vpName = new char[nVPName];
vpName = strdup(qPrintable(item->text()));
// G4cout << "LOOKING FOR BOOKMARK " << vpName << G4endl;
for (int i = 0; i < (int)viewPtList.size(); i++) {
if (!strcmp(viewPtList[i].viewPtName, vpName)) {
viewPtIdx = i;
break;
}
}
// G4cout << " FOUND viewPtIdx " << viewPtIdx << G4endl;
writeViewPtIdx();
setViewPt();
AuxWindowDialog->lineEdit->setText(item->text());
}
// Sets the viewpoint based on camera data that viewPtIdx is pointing to.
void G4OpenInventorQtExaminerViewer::setViewPt()
{
if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
|| currentState == ROTATING) {
if (animateSensor->isScheduled()) animateSensor->unschedule();
setSuperimpositionEnabled(superimposition, FALSE);
maxSpeed = 0.0f;
scheduleRedraw();
}
SoCamera * camera = getCamera();
if (camera == NULL) {
G4cout << "setViewPt: Camera is null. Unable to set the viewpoint." <<
G4endl;
// String dialogName = (char *) "Missing Camera Node";
// std::string msg = "Camera is null. Unable to set the viewpoint.";
// warningMsgDialog(msg, dialogName, NULL);
return;
}
if (!viewPtList.size()) {
G4cout << "setViewPt: There are no viewpoints to load." << G4endl;
// String dialogName = (char *) "Missing Viewpoints";
// std::string msg = "There are no viewpoints to load.";
// warningMsgDialog(msg, dialogName, NULL);
return;
}
if (SoQtExaminerViewer::isAnimating()) stopAnimating();
if (currentState != VIEWPOINT) {
currentState = VIEWPOINT;
//////////////////////////////////////////////////////////////
setSuperimpositionEnabled(superimposition, TRUE);
axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedOutlineSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
scheduleRedraw();
///////////////////////////////////////////////////////////////
}
curViewPtName = viewPtList[viewPtIdx].viewPtName;
camera->viewportMapping = viewPtList[viewPtIdx].viewportMapping;
camera->position = viewPtList[viewPtIdx].position;
camera->orientation = viewPtList[viewPtIdx].orientation;
camera->aspectRatio = viewPtList[viewPtIdx].aspectRatio;
camera->nearDistance = viewPtList[viewPtIdx].nearDistance;
camera->farDistance = viewPtList[viewPtIdx].farDistance;
camera->focalDistance = viewPtList[viewPtIdx].focalDistance;
// Restore camera height (changed by zooming)
if (camera->isOfType(SoPerspectiveCamera::getClassTypeId())) {
if (viewPtList[viewPtIdx].camType == ORTHOGRAPHIC) {
toggleCameraType();
camera = getCamera();
((SoOrthographicCamera *) camera)->height.setValue(
viewPtList[viewPtIdx].height);
} else
((SoPerspectiveCamera *) camera)->heightAngle.setValue(
viewPtList[viewPtIdx].height);
} else if (camera->isOfType(SoOrthographicCamera::getClassTypeId())) {
if (viewPtList[viewPtIdx].camType == PERSPECTIVE) {
toggleCameraType();
camera = getCamera();
((SoPerspectiveCamera *) camera)->heightAngle.setValue(
viewPtList[viewPtIdx].height);
} else
((SoOrthographicCamera *) camera)->height.setValue(
viewPtList[viewPtIdx].height);
} else {
SoDebugError::post("G4OpenInventorQtExaminerViewer::setViewPt",
"Only Perspective and Orthographic cameras are supported.");
return;
}
}
void G4OpenInventorQtExaminerViewer::NextViewPtCB()
{
// FWJ DEBUG
// G4cout << "App Button: nextViewPt CALLBACK" << G4endl;
if (!viewPtList.size()) return;
if (viewPtIdx >= (int)viewPtList.size() - 1)
viewPtIdx = 0;
else
viewPtIdx++;
writeViewPtIdx();
setViewPt();
char* viewptname = viewPtList[viewPtIdx].viewPtName;
AuxWindowDialog->lineEdit->setText(QString(viewptname));
}
void G4OpenInventorQtExaminerViewer::PrevViewPtCB()
{
// FWJ DEBUG
// G4cout << "App Button: prevViewPt CALLBACK" << G4endl;
if (!viewPtList.size()) return;
if (viewPtIdx == 0)
viewPtIdx = viewPtList.size() - 1;
else
viewPtIdx--;
writeViewPtIdx();
setViewPt();
char* viewptname = viewPtList[viewPtIdx].viewPtName;
AuxWindowDialog->lineEdit->setText(QString(viewptname));
}
void G4OpenInventorQtExaminerViewer::AbbrOutputCB(bool checked)
{
// FWJ DEBUG
// G4cout << "App Button: abbrOutput CALLBACK" << G4endl;
abbrOutputFlag = checked;
}
void G4OpenInventorQtExaminerViewer::PickRefPathCB()
{
// FWJ DEBUG
// G4cout << "App Button: pickRefPath CALLBACK" << G4endl;
// Save viewing state and go to picking mode
viewingBeforePickRef = isViewing();
if(isViewing())
setViewing(false);
setComponentCursor(SoQtCursor(SoQtCursor::CROSSHAIR));
pickRefPathFlag = true;
}
void G4OpenInventorQtExaminerViewer::SwitchWireFrameCB(bool checked)
{
// FWJ DEBUG
// G4cout << "App Button: switchWireFrame CALLBACK" << G4endl;
// if (switchWireFrameButton->isDown()) {
if (checked) {
setDrawStyle(SoQtViewer::STILL, SoQtViewer::VIEW_LINE);
setDrawStyle(SoQtViewer::INTERACTIVE, SoQtViewer::VIEW_LINE);
} else {
setDrawStyle(SoQtViewer::STILL, SoQtViewer::VIEW_AS_IS);
setDrawStyle(SoQtViewer::INTERACTIVE,
SoQtViewer::VIEW_SAME_AS_STILL);
}
}
void G4OpenInventorQtExaminerViewer::SwitchAxesCB(bool checked)
{
// FWJ DEBUG
// G4cout << "App Button: switchAxes CALLBACK" << G4endl;
setFeedbackVisibility(checked);
// if (checked) {
// setFeedbackVisibility(TRUE);
// } else {
// setFeedbackVisibility(FALSE);
// }
}
void G4OpenInventorQtExaminerViewer::DetachCB()
{
// FWJ DEBUG
// G4cout << "App Button: detach CALLBACK" << G4endl;
uiQt->GetViewerTabWidget()->removeTab(uiQtTabIndex);
viewerParent->setParent(viewerParent2);
removeAppPushButton(detachButton);
show();
}
void G4OpenInventorQtExaminerViewer::DeleteBookmarkCB()
{
// FWJ DEBUG
// G4cout << "Delete Button: DeleteBookmark CALLBACK" << G4endl;
// Maybe nothing selected yet
QListWidgetItem* listitem = AuxWindowDialog->listWidget->currentItem();
if (!listitem) return;
if (!(listitem->isSelected())) return;
QString vpnamein = listitem->text();
const int nVPName = MAX_VP_NAME + 1;
char* vpName = new char[nVPName];
vpName = strdup(qPrintable(vpnamein));
// G4cout << "DELETING bookmark " << vpName << G4endl;
deleteViewPt(vpName);
delete listitem;
}
// Deletes current viewpoint the user is looking at.
// Updates the input file and bookmarks as well.
void G4OpenInventorQtExaminerViewer::deleteViewPt(char *vpName)
{
std::string line;
int end;
fileIn.open(fileName.c_str());
std::ofstream out("temporaryFile.txt");
if (!vpName)
vpName = viewPtList[viewPtIdx].viewPtName;
getline(fileIn, line); // Printing the viewpoint idx
out << line << "\n";
while (getline(fileIn, line)) {
end = line.find_last_not_of(' ');
line = line.substr(0, end + 1);
if (!strcmp(line.c_str(), vpName)) { // Equal
while (line.size()) {
getline(fileIn, line);
}
while (getline(fileIn, line))
out << line << "\n";
} else {
while (line.size()) {
out << line << "\n";
getline(fileIn, line);
}
out << "\n";
}
}
int idx = 0; // Remove viewpoint from the vector
int size = viewPtList.size();
while (idx < size) {
if (!strcmp(viewPtList[idx].viewPtName, vpName)) {
viewPtList.erase(viewPtList.begin() + idx);
break;
}
idx++;
}
out.close();
fileOut.close();
fileIn.clear();
fileIn.close();
// FWJ check return status: error popups needed here
int istat = remove(fileName.c_str());
if (istat == -1) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error removing bookmarks file";
// messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
// G4cout << "Error removing bookmarks file" << G4endl;
}
istat = rename("temporaryFile.txt", fileName.c_str());
if (istat == -1) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error renaming bookmarks file";
// messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
// G4cout << "Error renaming bookmarks file" << G4endl;
}
fileOut.open(fileName.c_str(), std::ios::in);
fileOut.seekp(0, std::ios::end);
if (!viewPtList.size()) { // viewPtList is empty
curViewPtName = (char *) "";
scheduleRedraw();
} else {
if (viewPtIdx >= (int) viewPtList.size())
viewPtIdx--;
writeViewPtIdx();
setViewPt();
}
}
void G4OpenInventorQtExaminerViewer::RenameBookmarkCB()
{
// FWJ DEBUG
// G4cout << "Rename Button: RenameBookmark CALLBACK" << G4endl;
// Maybe nothing selected yet
QListWidgetItem* listitem = AuxWindowDialog->listWidget->currentItem();
if (!listitem) return;
if (!(listitem->isSelected())) return;
QString vpnamein = listitem->text();
const int nVPName = MAX_VP_NAME + 1;
// char* vpName = new char[nVPName];
// vpName = strdup(qPrintable(vpnamein));
// G4cout << "RENAMING bookmark " << vpName << G4endl;
QInputDialog* inputdialog = new QInputDialog(getParentWidget());
inputdialog->setFont(*font);
inputdialog->setWindowTitle(tr("Enter"));
inputdialog->setLabelText("New bookmark name");
inputdialog->adjustSize();
QString newnamein;
if (inputdialog->exec() == QDialog::Accepted)
newnamein=inputdialog->textValue().trimmed();
else
return;
if (newnamein.isEmpty()) return;
char* newname = new char[nVPName];
newname = strdup(qPrintable(newnamein));
int size = viewPtList.size();
for (int i = 0; i < size; i++) {
if (!strcmp(newname, viewPtList[i].viewPtName)) {
QMessageBox msgbox;
msgbox.setFont(*font);
msgbox.setText("Bookmark name is already in use");
msgbox.exec();
}
}
// G4cout << "RENAMING to " << newname << G4endl;
renameViewPt(newname);
listitem->setText(QString(newname));
AuxWindowDialog->lineEdit->setText(newname);
// if (currentState == VIEWPOINT)
// scheduleRedraw();
delete[] newname;
}
// Renames currently selected viewpoint.
void G4OpenInventorQtExaminerViewer::renameViewPt(char *vpName)
{
int idx = 0, end, pos;
int size = viewPtList.size();
std::string line, newName;
fileIn.open(fileName.c_str());
newName = vpName;
while ((int) newName.size() < MAX_VP_NAME)
newName += " ";
getline(fileIn, line);
pos = fileIn.tellg();
while (getline(fileIn, line)) {
end = line.find_last_not_of(' ');
line = line.substr(0, end + 1);
if (!strcmp(line.c_str(), curViewPtName)) {
fileOut.seekp(pos);
fileOut << newName;
fileOut.seekp(0, std::ios::end); // Set the file pointer to the end of the file
break;
}
while (line.size())
getline(fileIn, line);
pos = fileIn.tellg();
}
fileIn.close();
fileIn.clear();
while (idx < size) {
if (!strcmp(viewPtList[idx].viewPtName, curViewPtName)) {
strcpy(viewPtList[idx].viewPtName, vpName);
break;
}
idx++;
}
}
void G4OpenInventorQtExaminerViewer::SortBookmarksCB()
{
// FWJ NOTE: Xt version of this does not work (does nothing)
// G4cout << "Sort Button: SortBookmarks CALLBACK" << G4endl;
// FWJ List for sorting
// The dialog list and bookmark file will be rewritten.
// Simpler to populate this list from the data structure.
std::vector<std::string> charList;
if (viewPtList.size() < 2) return;
// Get current entries from the list
for (int i = 0; i < (int)viewPtList.size(); i++) {
charList.push_back(viewPtList[i].viewPtName);
// G4cout << " Pushed " << i << " " << charList[i] << G4endl;
}
std::sort(charList.begin(), charList.end());
// FWJ POPULATE the new dialog list
// G4cout << " Populating Bookmark listWidget..." << G4endl;
AuxWindowDialog->listWidget->clear();
for (int i = 0; i < (int)viewPtList.size(); i++) {
// viewPtIdx has to be changed to account for a different order in viewPtList
if (!strcmp(charList[i].c_str(), curViewPtName))
viewPtIdx = i;
new QListWidgetItem(charList[i].c_str(), AuxWindowDialog->listWidget);
}
sortViewPts(charList);
}
// Rewrites entire viewpoint file with sorted viewpoints.
void G4OpenInventorQtExaminerViewer::sortViewPts(std::vector<std::string> sortedViewPts)
{
SbVec3f axis;
float x, y, z, angle;
int sortIdx = 0, unsortIdx = 0;
if (fileOut.is_open())
fileOut.close();
fileOut.open(fileName.c_str()); // Erase current viewpoint file
writeViewPtIdx();
int size = sortedViewPts.size();
while (sortIdx < size) {
while (strcmp(sortedViewPts[sortIdx].c_str(),
viewPtList[unsortIdx].viewPtName))
unsortIdx++;
std::string vpName = viewPtList[unsortIdx].viewPtName;
while ((int) vpName.size() < MAX_VP_NAME)
vpName += " ";
fileOut << vpName << std::endl;
viewPtList[unsortIdx].position.getValue(x, y, z);
fileOut << x << " " << y << " " << z << std::endl;
// Reusing x, y and z for storing the axis
viewPtList[unsortIdx].orientation.getValue(axis, angle);
axis.getValue(x, y, z);
fileOut << x << " " << y << " " << z << " " << angle << std::endl;
fileOut << viewPtList[unsortIdx].camType << " "
<< viewPtList[unsortIdx].height << std::endl;
fileOut << viewPtList[unsortIdx].focalDistance << " ";
fileOut << viewPtList[unsortIdx].nearDistance << " ";
fileOut << viewPtList[unsortIdx].farDistance << std::endl;
fileOut << viewPtList[unsortIdx].viewportMapping << " ";
fileOut << viewPtList[unsortIdx].aspectRatio << "\n" << std::endl;
fileOut.flush();
unsortIdx = 0;
sortIdx++;
}
}
// Emulating private method SoGuiFullViewerP::zoom()
void
G4OpenInventorQtExaminerViewer::zoom(const float diffvalue)
{
float multiplicator = float(std::exp(diffvalue));
SoCamera *cam = getCamera();
if (cam->isOfType(SoPerspectiveCamera::getClassTypeId())) {
const float oldfocaldist = cam->focalDistance.getValue();
const float newfocaldist = oldfocaldist * multiplicator;
SbVec3f direction;
cam->orientation.getValue().multVec(SbVec3f(0, 0, -1), direction);
const SbVec3f oldpos = cam->position.getValue();
const SbVec3f newpos = oldpos + (newfocaldist - oldfocaldist) * -direction;
cam->position = newpos;
cam->focalDistance = newfocaldist;
} else if (cam->isOfType(SoOrthographicCamera::getClassTypeId())) {
SoOrthographicCamera * oc = (SoOrthographicCamera *)cam;
oc->height = oc->height.getValue() * multiplicator;
}
}
// Handling mouse and keyboard events
SbBool
G4OpenInventorQtExaminerViewer::processSoEvent(const SoEvent* const ev)
{
// FWJ DEBUG
// G4cout << "processSoEvent ############" << ++processSoEventCount << G4endl;
SoCamera *cam = getCamera();
const SoType type(ev->getTypeId());
if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) {
SoMouseButtonEvent * me = (SoMouseButtonEvent *) ev;
// if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
// || currentState == PAUSED_ANIMATION) {
switch (me->getButton()) {
case SoMouseButtonEvent::BUTTON4: // Scroll wheel up
if (me->getState() == SoButtonEvent::DOWN) {
// G4cout << "SCROLL WHEEL UP" << G4endl;
zoom(-0.1f);
return TRUE;
}
break;
case SoMouseButtonEvent::BUTTON5: // Scroll wheel down
if (me->getState() == SoButtonEvent::DOWN) {
// G4cout << "SCROLL WHEEL DOWN" << G4endl;
zoom(0.1f);
return TRUE;
}
break;
default:
break;
}
// }
if (currentState == GENERAL) {
}
}
if (type.isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
SoKeyboardEvent* ke = (SoKeyboardEvent*)ev;
if (SoKeyboardEvent::isKeyPressEvent(ev, ke->getKey())) {
switch (ke->getKey()) {
case SoKeyboardEvent::E:
if (externalQtApp) {
// G4cout << "E KEY PRESSED" << G4endl;
return TRUE;
} else {
G4cout <<
"E KEY PRESSED, EXITING OIQT VIEWER SECONDARY LOOP" <<
G4endl;
SoQt::exitMainLoop();
// escapeCallback();
return TRUE;
}
case SoKeyboardEvent::LEFT_SHIFT:
this->lshiftdown = true;
return TRUE;
case SoKeyboardEvent::RIGHT_SHIFT:
this->rshiftdown = true;
return TRUE;
case SoKeyboardEvent::LEFT_CONTROL:
this->lctrldown = true;
return TRUE;
case SoKeyboardEvent::RIGHT_CONTROL:
this->rctrldown = true;
return TRUE;
case SoKeyboardEvent::SPACE:
if (currentState == ANIMATION
|| currentState == REVERSED_ANIMATION) {
beforePausing = currentState;
currentState = PAUSED_ANIMATION;
if (animateSensor->isScheduled())
animateSensor->unschedule();
return TRUE;
} else if (currentState == PAUSED_ANIMATION) {
if (maxSpeed) {
if ((beforePausing == ANIMATION
&& refParticleIdx
< (int) refParticleTrajectory.size() - 1)
|| (beforePausing == REVERSED_ANIMATION
&& refParticleIdx > 0)) {
currentState = beforePausing;
animateRefParticle();
}
}
return TRUE;
}
break;
case SoKeyboardEvent::ESCAPE:
if (currentState == ANIMATION
|| currentState == REVERSED_ANIMATION
|| currentState == PAUSED_ANIMATION) {
if (animateSensor->isScheduled())
animateSensor->unschedule();
currentState = prevState;
refParticleIdx = prevRefIdx;
setSuperimpositionEnabled(superimposition, FALSE);
maxSpeed = 0.0f;
step = 1;
scheduleRedraw();
if (currentState == VIEWPOINT) {
setSuperimpositionEnabled(superimposition, TRUE);
axisSwitch->whichChild.setValue(SO_SWITCH_NONE);
animSpeedOutlineSwitch->whichChild.setValue(
SO_SWITCH_NONE);
animSpeedSwitch->whichChild.setValue(SO_SWITCH_NONE);
scheduleRedraw();
}
restoreCamera();
return TRUE;
}
break;
case SoKeyboardEvent::DELETE:
if (viewPtList.size()
&& (currentState != ANIMATION
&& currentState != REVERSED_ANIMATION
&& currentState != PAUSED_ANIMATION)) {
// FWJ IMPLEMENT LATER
// String dialogName = (char *) "Delete Viewpoint";
// std::string msg = "Are you sure you want to delete current viewpoint?";
// warningMsgDialog(msg, dialogName, deleteViewPtCB);
return TRUE;
}
break;
case SoKeyboardEvent::LEFT_ARROW:
switch (currentState) {
case BEAMLINE:
if ((this->lshiftdown) || (this->rshiftdown)) {
refParticleIdx -= step;
moveCamera();
}
else if ((this->lctrldown) || (this->rctrldown)) {
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
prevState = currentState;
currentState = ROTATING;
animateBtwPtsPeriod = 0.08f;
SbVec3f tmp = camDir;
tmp.negate();
rotAxis = tmp;
rotCnt = ROT_CNT;
moveCamera(); // To make sure camera is perpendicular to the beamline
rotateCamera();
}
else {
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
prevState = currentState;
currentState = ROTATING;
animateBtwPtsPeriod = 0.08f;
SbVec3f tmp = camUpVec;
tmp.negate();
rotAxis = tmp;
rotCnt = ROT_CNT;
moveCamera(); // To make sure camera is perpendicular to the beamline
rotateCamera();
}
return TRUE;
case ANIMATION:
case REVERSED_ANIMATION:
left_right -= 1.5f;
return TRUE;
case PAUSED_ANIMATION:
left_right -= 1.5f;
setStartingPtForAnimation();
cam->position = myCam->position;
return TRUE;
case GENERAL:
case VIEWPOINT:
if ((!this->lshiftdown) && (!this->rshiftdown)) {
// Using this allows us to look around without
// changing the camera parameters (camDir, camUpVec)
this->bottomWheelMotion(
this->getBottomWheelValue() + 0.1f);
return TRUE;
}
break;
case ROTATING:
// For this state, let the keyboard event
// be handled by superclass
break;
default:
SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
"Unhandled viewer state");
break;
}
break;
case SoKeyboardEvent::RIGHT_ARROW:
switch(currentState) {
case BEAMLINE:
if ((this->lshiftdown) || (this->rshiftdown)) {
refParticleIdx += step;
moveCamera();
}
else if ((this->lctrldown) || (this->rctrldown)) {
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
prevState = currentState;
currentState = ROTATING;
animateBtwPtsPeriod = 0.08f;
rotAxis = camDir;
rotCnt = ROT_CNT;
moveCamera(); // To make sure camera is perpendicular to the beamline
rotateCamera();
}
else{
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
prevState = currentState;
currentState = ROTATING;
animateBtwPtsPeriod = 0.08f;
rotAxis = camUpVec;
rotCnt = ROT_CNT;
moveCamera(); // To make sure camera is perpendicular to the beamline
rotateCamera();
}
return TRUE;
case ANIMATION:
case REVERSED_ANIMATION:
left_right += 1.5f;
return TRUE;
case PAUSED_ANIMATION:
left_right += 1.5f;
setStartingPtForAnimation();
cam->position = myCam->position;
return TRUE;
case GENERAL:
case VIEWPOINT:
if ((!this->lshiftdown) && (!this->rshiftdown)) {
// Using this allows us to look around without
// changing the camera parameters (camDir, camUpVec)
this->bottomWheelMotion(
this->getBottomWheelValue() - 0.1f);
return TRUE;
}
break;
case ROTATING:
// For this state, let the keyboard event
// be handled by superclass
break;
default:
SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
"Unhandled viewer state");
break;
}
break;
case SoKeyboardEvent::DOWN_ARROW:
switch(currentState) {
case BEAMLINE:
if ((this->lshiftdown) || (this->rshiftdown)) {
refParticleIdx -= step;
moveCamera();
}
else{
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
prevState = currentState;
currentState = ROTATING;
animateBtwPtsPeriod = 0.08f;
rotAxis = camDir.cross(camUpVec);
rotCnt = ROT_CNT;
moveCamera(); // To make sure camera is perpendicular to the beamline
rotateCamera();
}
return TRUE;
case ANIMATION:
case REVERSED_ANIMATION:
up_down -= 1.5f;
return TRUE;
case PAUSED_ANIMATION:
up_down -= 1.5f;
setStartingPtForAnimation();
cam->position = myCam->position;
return TRUE;
case GENERAL:
case VIEWPOINT:
// Using this allows us to look around without
// changing the camera parameters (camDir, camUpVec)
if ((!this->lshiftdown) && (!this->rshiftdown)) {
this->leftWheelMotion(this->getLeftWheelValue() - 0.1f);
return TRUE;
}
break;
case ROTATING:
// For this state, let the keyboard event
// be handled by superclass
break;
default:
SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
"Unhandled viewer state");
break;
}
break;
case SoKeyboardEvent::UP_ARROW:
switch(currentState) {
case BEAMLINE:
if ((this->lshiftdown) || (this->rshiftdown)) {
refParticleIdx -= step;
moveCamera();
}
else{
if (SoQtExaminerViewer::isAnimating())
stopAnimating();
prevState = currentState;
currentState = ROTATING;
animateBtwPtsPeriod = 0.08f;
rotAxis = camUpVec.cross(camDir);
rotCnt = ROT_CNT;
moveCamera();
rotateCamera();
}
return TRUE;
case ANIMATION:
case REVERSED_ANIMATION:
up_down += 1.5f;
return TRUE;
case PAUSED_ANIMATION:
up_down += 1.5f;
setStartingPtForAnimation();
cam->position = myCam->position;
return TRUE;
case GENERAL:
case VIEWPOINT:
// Using this allows us to look around without
// changing the camera parameters (camDir, camUpVec)
if ((!this->lshiftdown) && (!this->rshiftdown)) {
this->leftWheelMotion(this->getLeftWheelValue() + 0.1f);
return TRUE;
}
break;
case ROTATING:
// For this state, let the keyboard event
// be handled by superclass
break;
default:
SoDebugError::post("G4OpenInventorQtExaminerViewer::processSoEvent",
"Unhandled viewer state");
break;
}
break;
case SoKeyboardEvent::PAGE_UP:
switch(currentState) {
case BEAMLINE:
if (step < (int) refParticleTrajectory.size() / 5) // Magic number
step++;
return TRUE;
case ANIMATION:
incSpeed();
maxSpeed += SPEED_INDICATOR_STEP;
if (maxSpeed > 0.8)
maxSpeed = MAX_SPEED_INDICATOR;
scheduleRedraw();
return TRUE;
case REVERSED_ANIMATION:
if(!animateSensor->isScheduled()) {
currentState = ANIMATION;
if (refParticleIdx
< (int) refParticleTrajectory.size() - 1) {
refParticleIdx++;
maxSpeed = SPEED_INDICATOR_STEP;
scheduleRedraw();
animateRefParticle();
}
}
else{
maxSpeed += SPEED_INDICATOR_STEP;
decSpeed();
scheduleRedraw();
}
return TRUE;
case PAUSED_ANIMATION:
maxSpeed += SPEED_INDICATOR_STEP;
if (maxSpeed > 0.8)
maxSpeed = MAX_SPEED_INDICATOR;
if (beforePausing == ANIMATION) {
incSpeed();
} else {
decSpeed();
if (animateBtwPtsPeriod >= MIN_SPEED)
beforePausing = ANIMATION;
}
scheduleRedraw();
return TRUE;
default: //fall through
break;
}
break;
case SoKeyboardEvent::PAGE_DOWN:
switch(currentState) {
case BEAMLINE:
if (step > 1)
step--;
return TRUE;
case ANIMATION:
if(!animateSensor->isScheduled()) {
currentState = REVERSED_ANIMATION;
if (refParticleIdx > 1) {
refParticleIdx--;
maxSpeed = -SPEED_INDICATOR_STEP;
scheduleRedraw();
animateRefParticle();
}
}
else{
maxSpeed -= SPEED_INDICATOR_STEP;
decSpeed();
scheduleRedraw();
}
return TRUE;
case REVERSED_ANIMATION:
incSpeed();
maxSpeed -= SPEED_INDICATOR_STEP;
if (maxSpeed < -0.8)
maxSpeed = -MAX_SPEED_INDICATOR;
scheduleRedraw();
return TRUE;
case PAUSED_ANIMATION:
maxSpeed -= SPEED_INDICATOR_STEP;
if (maxSpeed < -0.8)
maxSpeed = -MAX_SPEED_INDICATOR;
if (beforePausing == REVERSED_ANIMATION) {
incSpeed();
} else {
decSpeed();
if (animateBtwPtsPeriod >= MIN_SPEED)
beforePausing = REVERSED_ANIMATION;
}
scheduleRedraw();
return TRUE;
default:
//fall through
break;
}
break;
// FROM XT VIEWER
// case SoKeyboardEvent::E:
// this->escapeCallback(this->examinerObject);
// break;
default:
break; // To get rid of compiler warnings
}
}
if (SoKeyboardEvent::isKeyReleaseEvent(ev, ke->getKey())) {
switch (ke->getKey()) {
case SoKeyboardEvent::LEFT_SHIFT:
this->lshiftdown = false;
return TRUE;
case SoKeyboardEvent::RIGHT_SHIFT:
this->rshiftdown = false;
return TRUE;
case SoKeyboardEvent::LEFT_CONTROL:
this->lctrldown = false;
return TRUE;
case SoKeyboardEvent::RIGHT_CONTROL:
this->rctrldown = false;
return TRUE;
default:
break;
}
}
}
// Pass the event on to the viewer
// Need some checks here as in Xt viewer?
if (currentState == ANIMATION || currentState == REVERSED_ANIMATION
|| currentState == ROTATING)
return FALSE;
else
return SoQtExaminerViewer::processSoEvent(ev);
}
// REMAINDER OF MENU BAR FUNCTIONS...
void G4OpenInventorQtExaminerViewer::FileLoadSceneGraphCB()
{
// G4cout << "File: Load scene graph CALLBACK" << G4endl;
QFileDialog filedialog(getParentWidget(), tr("Load Scene Graph"));
filedialog.setFileMode(QFileDialog::AnyFile);
filedialog.setFont(*font);
if (!filedialog.exec()) return;
QStringList filenameinlist = filedialog.selectedFiles();
QString filenamein = filenameinlist[0];
// G4cout << "Entered file name is " << qPrintable(filenamein) << G4endl;
char* filename = new char[filenamein.size()+1];
filename = strdup(qPrintable(filenamein));
// G4cout << "char[] file name is " << filename << G4endl;
SoInput sceneInput;
if (sceneInput.openFile(filename)) {
// Read the whole file into the database
newSceneGraph = SoDB::readAll(&sceneInput);
if (newSceneGraph == NULL) {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error reading scene graph file ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
sceneInput.closeFile();
return;
}
} else {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error opening scene graph file ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
return;
}
SoSeparator* root = (SoSeparator*)getSceneGraph();
root->unref();
newSceneGraph->ref();
setSceneGraph(newSceneGraph);
}
void G4OpenInventorQtExaminerViewer::FileSaveSceneGraphCB()
{
// G4cout << "File: Save scene graph CALLBACK" << G4endl;
QFileDialog filedialog(getParentWidget(), tr("Save scene graph"));
filedialog.setFileMode(QFileDialog::AnyFile);
// To enable confirmation of overwriting
filedialog.setAcceptMode(QFileDialog::AcceptSave);
filedialog.setFont(*font);
if (!filedialog.exec()) return;
QStringList filenameinlist = filedialog.selectedFiles();
QString filenamein = filenameinlist[0];
// G4cout << "Entered file name is " << qPrintable(filenamein) << G4endl;
char* filename = new char[filenamein.size()+1];
filename = strdup(qPrintable(filenamein));
// G4cout << "char[] file name is " << filename << G4endl;
SoWriteAction writeAction;
SoSeparator* root = (SoSeparator*)getSceneGraph();
SoOutput* out = writeAction.getOutput();
if (out->openFile(filename)) {
out->setBinary(FALSE);
writeAction.apply(root);
out->closeFile();
} else {
QMessageBox msgbox;
msgbox.setFont(*font);
QString messagetxt = "Error opening file ";
messagetxt.append(filenamein);
msgbox.setText(messagetxt);
msgbox.exec();
}
}
void G4OpenInventorQtExaminerViewer::HelpControlsCB()
{
// G4cout << "Help: Help Controls CALLBACK" << G4endl;
helpmsgbox->show();
}
HookEventProcState::HookEventProcState(G4OpenInventorQtExaminerViewer* vwr)
{
viewer = vwr;
}
HookEventProcState::~HookEventProcState()
{;}
G4bool HookEventProcState::Notify(G4ApplicationState requestedState)
{
if (requestedState == G4State_EventProc) viewer->newEvents = true;
return true;
}
Reference in New Issue View Git Blame Copy Permalink