Gabriele Cosmo
452 lines
17 KiB
C++
452 lines
17 KiB
C++
//
|
|
// ********************************************************************
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// John Allison 27th March 1996
|
|
// Abstract interface class for graphics views.
|
|
|
|
#include "G4VViewer.hh"
|
|
|
|
#include "G4PhysicalVolumeStore.hh"
|
|
#include "G4Scene.hh"
|
|
#include "G4Timer.hh"
|
|
#include "G4Transform3D.hh"
|
|
#include "G4UImanager.hh"
|
|
#include "G4UIsession.hh"
|
|
#include "G4VGraphicsSystem.hh"
|
|
#include "G4VInteractiveSession.hh"
|
|
#include "G4VPhysicalVolume.hh"
|
|
#include "G4VSceneHandler.hh"
|
|
#include "G4VisManager.hh"
|
|
#include "G4ios.hh"
|
|
|
|
#include <sstream>
|
|
|
|
G4VViewer::G4VViewer(G4VSceneHandler& sceneHandler, G4int id, const G4String& name)
|
|
: fSceneHandler(sceneHandler), fViewId(id), fNeedKernelVisit(true)
|
|
{
|
|
if (name == "") {
|
|
std::ostringstream ost;
|
|
ost << fSceneHandler.GetName() << '-' << fViewId;
|
|
fName = ost.str();
|
|
}
|
|
else {
|
|
fName = name;
|
|
}
|
|
fShortName = fName.substr(0, fName.find(' '));
|
|
G4StrUtil::strip(fShortName);
|
|
|
|
fVP = G4VisManager::GetInstance()->GetDefaultViewParameters();
|
|
fDefaultVP = fVP;
|
|
|
|
fSceneTree.SetType(G4SceneTreeItem::root);
|
|
fSceneTree.SetDescription(fName);
|
|
}
|
|
|
|
G4VViewer::~G4VViewer()
|
|
{
|
|
fSceneHandler.RemoveViewerFromList(this);
|
|
}
|
|
|
|
void G4VViewer::SetName(const G4String& name)
|
|
{
|
|
fName = name;
|
|
fShortName = fName.substr(0, fName.find(' '));
|
|
G4StrUtil::strip(fShortName);
|
|
}
|
|
|
|
void G4VViewer::NeedKernelVisit()
|
|
{
|
|
fNeedKernelVisit = true;
|
|
|
|
// At one time I thought we'd better notify all viewers. But I guess
|
|
// each viewer can take care of itself, so the following code is
|
|
// redundant (but keep it commented out for now). (John Allison)
|
|
// Notify all viewers that a kernel visit is required.
|
|
// const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
|
|
// G4ViewerListConstIterator i;
|
|
// for (i = viewerList.begin(); i != viewerList.end(); i++) {
|
|
// (*i) -> SetNeedKernelVisit ();
|
|
// }
|
|
// ??...but, there's a problem in OpenGL Stored which seems to
|
|
// require *all* viewers to revisit the kernel, so...
|
|
// const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
|
|
// G4ViewerListConstIterator i;
|
|
// for (i = viewerList.begin(); i != viewerList.end(); i++) {
|
|
// (*i) -> SetNeedKernelVisit (true);
|
|
// }
|
|
// Feb 2005 - commented out. Let's fix OpenGL if necessary.
|
|
}
|
|
|
|
void G4VViewer::FinishView() {}
|
|
|
|
void G4VViewer::ShowView() {}
|
|
|
|
void G4VViewer::ProcessView()
|
|
{
|
|
// If the scene has changed, or if the concrete viewer has decided
|
|
// that it necessary to visit the kernel, perhaps because the view
|
|
// parameters have changed significantly (this should be done in the
|
|
// concrete viewer's DrawView)...
|
|
if (fNeedKernelVisit) {
|
|
// Reset flag. This must be done before ProcessScene to prevent
|
|
// recursive calls when recomputing transients...
|
|
G4Timer timer;
|
|
timer.Start();
|
|
fNeedKernelVisit = false;
|
|
fSceneHandler.ClearStore();
|
|
fSceneHandler.ProcessScene();
|
|
UpdateGUISceneTree();
|
|
timer.Stop();
|
|
fKernelVisitElapsedTimeSeconds = timer.GetRealElapsed();
|
|
}
|
|
}
|
|
|
|
void G4VViewer::SetViewParameters(const G4ViewParameters& vp)
|
|
{
|
|
fVP = vp;
|
|
}
|
|
|
|
void G4VViewer::SetTouchable(
|
|
const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& fullPath)
|
|
{
|
|
// Set the touchable for /vis/touchable/set/... commands.
|
|
std::ostringstream oss;
|
|
const auto& pvStore = G4PhysicalVolumeStore::GetInstance();
|
|
for (const auto& pvNodeId : fullPath) {
|
|
const auto& pv = pvNodeId.GetPhysicalVolume();
|
|
auto iterator = find(pvStore->cbegin(), pvStore->cend(), pv);
|
|
if (iterator == pvStore->cend()) {
|
|
G4ExceptionDescription ed;
|
|
ed << "Volume no longer in physical volume store.";
|
|
G4Exception("G4VViewer::SetTouchable", "visman0401", JustWarning, ed);
|
|
}
|
|
else {
|
|
oss << ' ' << pvNodeId.GetPhysicalVolume()->GetName() << ' ' << pvNodeId.GetCopyNo();
|
|
}
|
|
}
|
|
G4UImanager::GetUIpointer()->ApplyCommand("/vis/set/touchable" + oss.str());
|
|
}
|
|
|
|
void G4VViewer::TouchableSetVisibility(
|
|
const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& fullPath, G4bool visibiity)
|
|
{
|
|
// Changes the Vis Attribute Modifiers and scene tree WITHOUT triggering a rebuild.
|
|
|
|
// The following is equivalent to
|
|
// G4UImanager::GetUIpointer()->ApplyCommand("/vis/touchable/set/visibility ...");
|
|
// (assuming the touchable has already been set), but avoids view rebuild.
|
|
|
|
// Instantiate a working copy of a G4VisAttributes object...
|
|
G4VisAttributes workingVisAtts;
|
|
// and set the visibility.
|
|
workingVisAtts.SetVisibility(visibiity);
|
|
|
|
fVP.AddVisAttributesModifier(G4ModelingParameters::VisAttributesModifier(
|
|
workingVisAtts, G4ModelingParameters::VASVisibility,
|
|
G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
|
|
// G4ModelingParameters::VASVisibility (VAS = Vis Attribute Signifier)
|
|
// signifies that it is the visibility that should be picked out
|
|
// and merged with the touchable's normal vis attributes.
|
|
|
|
// Find scene tree item and set visibility
|
|
// The scene tree works with strings
|
|
G4String fullPathString = G4PhysicalVolumeModel::GetPVNamePathString(fullPath);
|
|
std::list<G4SceneTreeItem>::iterator foundIter;
|
|
if (fSceneTree.FindTouchableFromRoot(fullPathString, foundIter)) {
|
|
foundIter->AccessVisAttributes().SetVisibility(visibiity);
|
|
UpdateGUISceneTree();
|
|
}
|
|
else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Touchable \"" << fullPath << "\" not found";
|
|
G4Exception("G4VViewer::TouchableSetVisibility", "visman0402", JustWarning, ed);
|
|
}
|
|
}
|
|
|
|
void G4VViewer::TouchableSetColour(
|
|
const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& fullPath,
|
|
const G4Colour& colour)
|
|
{
|
|
// Changes the Vis Attribute Modifiers and scene tree WITHOUT triggering a rebuild.
|
|
|
|
// The following is equivalent to
|
|
// G4UImanager::GetUIpointer()->ApplyCommand("/vis/touchable/set/colour ...");
|
|
// (assuming the touchable has already been set), but avoids view rebuild.
|
|
|
|
// Instantiate a working copy of a G4VisAttributes object...
|
|
G4VisAttributes workingVisAtts;
|
|
// and set the colour.
|
|
workingVisAtts.SetColour(colour);
|
|
|
|
fVP.AddVisAttributesModifier(G4ModelingParameters::VisAttributesModifier(
|
|
workingVisAtts, G4ModelingParameters::VASColour,
|
|
G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
|
|
// G4ModelingParameters::VASColour (VAS = Vis Attribute Signifier)
|
|
// signifies that it is the colour that should be picked out
|
|
// and merged with the touchable's normal vis attributes.
|
|
|
|
// Find scene tree item and set colour
|
|
// The scene tree works with strings
|
|
G4String fullPathString = G4PhysicalVolumeModel::GetPVNamePathString(fullPath);
|
|
std::list<G4SceneTreeItem>::iterator foundIter;
|
|
if (fSceneTree.FindTouchableFromRoot(fullPathString, foundIter)) {
|
|
foundIter->AccessVisAttributes().SetColour(colour);
|
|
UpdateGUISceneTree();
|
|
}
|
|
else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Touchable \"" << fullPath << "\" not found";
|
|
G4Exception("G4VViewer::TouchableSetColour", "visman0403", JustWarning, ed);
|
|
}
|
|
}
|
|
|
|
void G4VViewer::UpdateGUISceneTree()
|
|
{
|
|
G4UImanager* UI = G4UImanager::GetUIpointer();
|
|
auto uiWindow = dynamic_cast<G4VInteractiveSession*>(UI->GetG4UIWindow());
|
|
if (uiWindow) uiWindow->UpdateSceneTree(fSceneTree);
|
|
}
|
|
|
|
void G4VViewer::InsertModelInSceneTree(G4VModel* model)
|
|
{
|
|
const auto& modelType = model->GetType();
|
|
const auto& modelDescription = model->GetGlobalDescription();
|
|
|
|
auto type = G4SceneTreeItem::model;
|
|
auto pvModel = dynamic_cast<G4PhysicalVolumeModel*>(model);
|
|
if (pvModel) type = G4SceneTreeItem::pvmodel;
|
|
|
|
fCurtailDescent = false; // This is used later in SceneTreeScene::ProcessVolume
|
|
G4String furtherInfo;
|
|
if (pvModel) {
|
|
struct : public G4PseudoScene {
|
|
void ProcessVolume(const G4VSolid&) {++fNTotalTouchables;}
|
|
G4int fNTotalTouchables = 0;
|
|
} counter;
|
|
pvModel->DescribeYourselfTo(counter); // Calls ProcessVolume for every touchable
|
|
if (counter.fNTotalTouchables > fMaxNTouchables) {
|
|
std::ostringstream oss;
|
|
oss << counter.fNTotalTouchables << " touchables - too many for scene tree";
|
|
furtherInfo = oss.str();
|
|
if (G4VisManager::GetInstance()->GetVerbosity() >= G4VisManager::warnings) {
|
|
G4ExceptionDescription ed;
|
|
ed << pvModel->GetGlobalDescription() <<
|
|
":\n Too many touchables (" << counter.fNTotalTouchables
|
|
<< ") for scene tree. Scene tree for this model will be empty.";
|
|
G4Exception("G4VViewer::InsertModelInSceneTree", "visman0404", JustWarning, ed);
|
|
}
|
|
fCurtailDescent = true; // This is used later in SceneTreeScene::ProcessVolume
|
|
}
|
|
}
|
|
|
|
// Find appropriate model
|
|
auto& modelItems = fSceneTree.AccessChildren();
|
|
auto modelIter = modelItems.begin();
|
|
auto pvModelIter = modelItems.end();
|
|
for (; modelIter != modelItems.end(); ++modelIter) {
|
|
if (modelIter->GetType() == G4SceneTreeItem::pvmodel) {
|
|
pvModelIter = modelIter; // Last pre-existing PV model (if any)
|
|
}
|
|
if (modelIter->GetModelDescription() == modelDescription) break;
|
|
}
|
|
|
|
if (modelIter == modelItems.end()) { // Model not seen before
|
|
G4SceneTreeItem modelItem(type);
|
|
modelItem.SetDescription("model");
|
|
modelItem.SetModelType(modelType);
|
|
modelItem.SetModelDescription(modelDescription);
|
|
modelItem.SetFurtherInfo(furtherInfo);
|
|
if (pvModelIter != modelItems.end() && // There was pre-existing PV Model...
|
|
type == G4SceneTreeItem::pvmodel) { // ...and the new model is also PV...
|
|
fSceneTree.InsertChild(++pvModelIter, modelItem); // ...insert after, else...
|
|
} else {
|
|
fSceneTree.InsertChild(modelIter, modelItem); // ...insert at end
|
|
}
|
|
} else { // Existing model - mark visible == active
|
|
modelIter->AccessVisAttributes().SetVisibility(true);
|
|
}
|
|
}
|
|
|
|
G4VViewer::SceneTreeScene::SceneTreeScene(G4VViewer* pViewer, G4PhysicalVolumeModel* pPVModel)
|
|
: fpViewer (pViewer)
|
|
, fpPVModel(pPVModel)
|
|
{
|
|
if (fpPVModel == nullptr) {
|
|
G4Exception("G4VViewer::SceneTreeScene::SceneTreeScene", "visman0405", FatalException,
|
|
"G4PhysicalVolumeModel pointer is null");
|
|
return; // To keep Coverity happy
|
|
}
|
|
|
|
// Describe the model to an empty scene simply to get the numbers of touchables
|
|
struct : public G4PseudoScene {
|
|
void ProcessVolume(const G4VSolid&) {}
|
|
} counter;
|
|
fpPVModel->DescribeYourselfTo(counter); // Calls ProcessVolume for every touchable
|
|
|
|
// Limit the expanded depth to limit the number expanded so as not to swamp the GUI
|
|
G4int expanded = 0;
|
|
for (const auto& dn : fpPVModel->GetNumberOfTouchables()) {
|
|
expanded += dn.second;
|
|
if (fMaximumExpandedDepth < dn.first) fMaximumExpandedDepth = dn.first;
|
|
if (expanded > fMaximumExpanded) break;
|
|
}
|
|
|
|
// Find appropriate model and its iterator
|
|
const auto& modelID = fpPVModel->GetGlobalDescription();
|
|
auto& modelItems = fpViewer->fSceneTree.AccessChildren();
|
|
fModelIter = modelItems.begin();
|
|
for (; fModelIter != modelItems.end(); ++fModelIter) {
|
|
if (fModelIter->GetModelDescription() == modelID) break;
|
|
}
|
|
if (fModelIter == modelItems.end()) {
|
|
G4Exception("G4VViewer::SceneTreeScene::SceneTreeScene", "visman0406", JustWarning,
|
|
"Model not found");
|
|
}
|
|
}
|
|
|
|
void G4VViewer::SceneTreeScene::ProcessVolume(const G4VSolid&)
|
|
{
|
|
if (fpViewer->fCurtailDescent) {
|
|
fpPVModel->CurtailDescent();
|
|
return;
|
|
}
|
|
|
|
const auto& modelID = fpPVModel->GetGlobalDescription();
|
|
|
|
std::ostringstream oss;
|
|
oss << fpPVModel->GetFullPVPath(); // of this volume
|
|
G4String fullPathString(oss.str()); // Has a leading space
|
|
|
|
// Navigate scene tree and find or insert touchables one by one
|
|
// Work down the path - "name id", then "name id name id", etc.
|
|
const auto& nodeIDs = fpPVModel->GetFullPVPath();
|
|
G4String partialPathString;
|
|
auto currentIter = fModelIter;
|
|
G4int depth = 0;
|
|
for (const auto& nodeID : nodeIDs) {
|
|
std::ostringstream oss1;
|
|
oss1 << nodeID;
|
|
partialPathString += ' ' + oss1.str();
|
|
currentIter =
|
|
FindOrInsertTouchable(modelID, *currentIter, ++depth, partialPathString, fullPathString);
|
|
}
|
|
}
|
|
|
|
// clang-format off
|
|
std::list<G4SceneTreeItem>::iterator G4VViewer::SceneTreeScene::FindOrInsertTouchable
|
|
(const G4String& modelID, G4SceneTreeItem& mother,
|
|
G4int depth, const G4String& partialPathString, const G4String& fullPathString)
|
|
{
|
|
auto& children = mother.AccessChildren();
|
|
auto childIter = children.begin();
|
|
for (; childIter != children.end(); ++childIter) {
|
|
if (childIter->GetPVPath() == partialPathString) break;
|
|
}
|
|
if (childIter != children.end()) {
|
|
|
|
// Item already exists
|
|
|
|
if (childIter->GetType() == G4SceneTreeItem::ghost) {
|
|
|
|
// Previously it was a ghost - but maybe this time it's real
|
|
|
|
if (partialPathString == fullPathString) {
|
|
// Partial path string refers to the actual volume so it's a touchable
|
|
childIter->SetType(G4SceneTreeItem::touchable);
|
|
// Populate with information
|
|
childIter->SetDescription(fpPVModel->GetCurrentTag());
|
|
childIter->SetModelType(fpPVModel->GetType());
|
|
childIter->SetModelDescription(modelID);
|
|
childIter->SetPVPath(partialPathString);
|
|
if (fpVisAttributes) childIter->SetVisAttributes(*fpVisAttributes);
|
|
childIter->SetAttDefs(fpPVModel->GetAttDefs());
|
|
childIter->SetAttValues(fpPVModel->CreateCurrentAttValues());
|
|
} // Partial path string refers to an ancester - do nothing
|
|
|
|
} else {
|
|
|
|
// Already a pre-existing full touchable
|
|
|
|
if (partialPathString == fullPathString) {
|
|
// Partial path string refers to the actual volume
|
|
// Replace vis attributes (if any) - they might have changed
|
|
if (fpVisAttributes) childIter->SetVisAttributes(*fpVisAttributes);
|
|
} // Partial path string refers to an ancester - do nothing
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Item does not yet exist
|
|
|
|
if (partialPathString == fullPathString) {
|
|
|
|
// Partial path string refers to the actual volume
|
|
// Insert new touchable item
|
|
G4SceneTreeItem touchable(G4SceneTreeItem::touchable);
|
|
touchable.SetExpanded(depth > fMaximumExpandedDepth? false: true);
|
|
touchable.SetDescription(fpPVModel->GetCurrentTag());
|
|
touchable.SetModelType(fpPVModel->GetType());
|
|
touchable.SetModelDescription(modelID);
|
|
touchable.SetPVPath(partialPathString);
|
|
if (fpVisAttributes) touchable.SetVisAttributes(*fpVisAttributes);
|
|
touchable.SetAttDefs(fpPVModel->GetAttDefs());
|
|
touchable.SetAttValues(fpPVModel->CreateCurrentAttValues());
|
|
childIter = mother.InsertChild(childIter,touchable);
|
|
|
|
} else {
|
|
|
|
// Partial path string refers to an ancester - it's what we call a "ghost"
|
|
G4SceneTreeItem ghost(G4SceneTreeItem::ghost);
|
|
ghost.SetExpanded(depth > fMaximumExpandedDepth? false: true);
|
|
// Create a tag from the partial path
|
|
std::istringstream iss(partialPathString);
|
|
G4String name, copyNo;
|
|
while (iss >> name >> copyNo);
|
|
std::ostringstream oss;
|
|
oss << name << ':' << copyNo;
|
|
ghost.SetDescription(oss.str());
|
|
ghost.SetModelType(fpPVModel->GetType());
|
|
ghost.SetModelDescription(modelID);
|
|
ghost.SetPVPath(partialPathString);
|
|
ghost.AccessVisAttributes().SetVisibility(false);
|
|
childIter = mother.InsertChild(childIter,ghost);
|
|
}
|
|
}
|
|
|
|
return childIter;
|
|
}
|
|
// clang-format on
|
|
|
|
std::ostream& operator<<(std::ostream& os, const G4VViewer& v)
|
|
{
|
|
os << "View " << v.fName << ":\n";
|
|
os << v.fVP;
|
|
return os;
|
|
}
|