g4SceneProperties.cc

Go to the documentation of this file.

 
// g4display
#include "g4SceneProperties.h"
#include "g4Text.h"
 
// gemc
#include "gutilities.h"
 
// geant4
#include "G4UImanager.hh"
 
namespace {
bool is3DTextKind(const std::string& kind) {
    return kind == "3D" || kind == "3d" || kind == "text" || kind == "Text";
}
 
std::string colourToRGB(const std::string& colour) {
    if (colour.find(' ') != std::string::npos) { return colour; }
    if (colour == "black")   { return "0 0 0"; }
    if (colour == "blue")    { return "0 0 1"; }
    if (colour == "cyan")    { return "0 1 1"; }
    if (colour == "green")   { return "0 1 0"; }
    if (colour == "grey" || colour == "gray") { return "0.9 0.9 0.9"; }
    if (colour == "red")     { return "1 0 0"; }
    if (colour == "yellow")  { return "1 1 0"; }
    return "1 1 1";
}
}
 
std::vector<std::string> G4SceneProperties::scene_commands(const std::shared_ptr<GOptions> &gopts) {
    std::vector<std::string> cmds;
 
    const bool gui = gopts->getSwitch("gui");
    const bool use_dawn = gopts->getSwitch("useDawn");
 
    // Project options onto simple structs for downstream use.
    auto g4view = g4display::getG4View(gopts);
    auto g4camera = g4display::getG4Camera(gopts);
    auto g4light = g4display::getG4Light(gopts);
 
    const bool open_configured_viewer = gui || g4view.driver == "TOOLSSG_OFFSCREEN";
    if (!use_dawn && !open_configured_viewer) { return cmds; }
 
    if (use_dawn) {
        cmds.emplace_back("/vis/open DAWNFILE");
    }
    if (open_configured_viewer) {
        // Open the configured viewer driver. Offscreen drivers ignore window position, so omit it.
        std::string openArg = g4view.driver + " " + g4view.dimension;
        if (g4view.driver != "TOOLSSG_OFFSCREEN") openArg += g4view.position;
        cmds.emplace_back("/vis/open " + openArg);
    }
 
    // Open the viewer without a scene, then create and attach the initialized ROOT model. Opening a
    // viewer on either an empty or a pre-populated unattached scene causes warnings or crashes in OGLSQt.
    cmds.emplace_back("/vis/viewer/set/autoRefresh false");
    cmds.emplace_back("/vis/scene/create gemc");
    cmds.emplace_back("/vis/sceneHandler/attach");
    cmds.emplace_back("/vis/scene/add/volume root -1");
 
    if (use_dawn && !open_configured_viewer) {
        cmds.emplace_back("/vis/geometry/set/visibility World 0 false");
        cmds.emplace_back("/vis/viewer/set/style surface");
    }
    if (open_configured_viewer) {
        // Convert configured camera angles to degrees for the Geant4 viewer command.
        const double toDegrees = 180.0 / M_PI;
        double thetaValue      = gutilities::getG4Number(g4camera.theta) * toDegrees;
        double phiValue        = gutilities::getG4Number(g4camera.phi)   * toDegrees;
        double lightThetaValue = gutilities::getG4Number(g4light.theta)  * toDegrees;
        double lightPhiValue   = gutilities::getG4Number(g4light.phi)    * toDegrees;
        if (lightThetaValue == 0.0 && lightPhiValue == 0.0) {
            lightThetaValue = thetaValue;
            lightPhiValue   = phiValue;
        }
 
        cmds.emplace_back("/vis/viewer/set/viewpointThetaPhi " + std::to_string(thetaValue) + " " + std::to_string(phiValue));
        cmds.emplace_back("/vis/viewer/set/lightsThetaPhi " + std::to_string(lightThetaValue) + " " + std::to_string(lightPhiValue));
        cmds.emplace_back("/vis/viewer/set/lineSegmentsPerCircle " + std::to_string(g4view.segsPerCircle));
        cmds.emplace_back("/vis/viewer/set/background " + g4view.background);
        cmds.emplace_back("/vis/viewer/set/numberOfCloudPoints " + std::to_string(g4view.cloudPoints));
    }
    cmds.emplace_back("/vis/viewer/set/autoRefresh true");
 
    return cmds;
}
 
std::vector<std::string> G4SceneProperties::addSceneDecorations(const std::shared_ptr<GOptions> &gopts) {
    std::vector<std::string> commands;
    const auto decorations = g4display::getG4Decorations(gopts);
 
    if (decorations.scale) {
        commands.emplace_back("/vis/scene/add/scale " +
                              std::to_string(decorations.scaleLength) + " " +
                              decorations.scaleUnit + " " +
                              decorations.scaleDirection + " " +
                              colourToRGB(decorations.scaleColor));
    }
    if (decorations.axes) { commands.emplace_back("/vis/scene/add/axes"); }
    if (decorations.date) {
        commands.emplace_back("/vis/scene/add/date " + std::to_string(decorations.dateSize));
    }
    if (decorations.logo2D) { commands.emplace_back("/vis/scene/add/logo2D"); }
    if (decorations.logo) { commands.emplace_back("/vis/scene/add/logo"); }
    if (decorations.frame) {
        commands.emplace_back("/vis/set/colour " + decorations.frameColor);
        commands.emplace_back("/vis/set/lineWidth " + std::to_string(decorations.frameLineWidth));
        commands.emplace_back("/vis/scene/add/frame");
        commands.emplace_back("/vis/set/colour");
        commands.emplace_back("/vis/set/lineWidth");
    }
 
    return commands;
}
 
std::vector<std::string> G4SceneProperties::addSceneTexts(const std::shared_ptr<GOptions> &gopts) {
    std::vector<std::string> commands;
 
    std::vector<g4display::G4SceneText> text_to_add = g4display::getSceneTexts(gopts);
 
    // Map each configured text item into Geant4 text commands.
    for (const auto &text: text_to_add) {
        commands.emplace_back("/vis/set/textColour " + text.color);
        if (!text.layout.empty()) {
            commands.emplace_back("/vis/set/textLayout " + text.layout);
        }
 
        if (is3DTextKind(text.kind)) {
            if (!text.z) {
                log->error(goptions::EC__MANDATORY_NOT_FILLED,
                           "A 3D g4text entry requires a z coordinate");
            }
            commands.emplace_back(
                "/vis/scene/add/text " +
                std::to_string(text.x) + " " +
                std::to_string(text.y) + " " +
                std::to_string(*text.z) + " " +
                text.unit + " " +
                std::to_string(text.size) + " " +
                std::to_string(text.dx) + " " +
                std::to_string(text.dy) + " " +
                text.text);
        } else {
            commands.emplace_back(
                "/vis/scene/add/text2D " +
                std::to_string(text.x) + " " +
                std::to_string(text.y) + " " +
                std::to_string(text.size) + " ! ! " +
                text.text);
        }
 
        if (!text.layout.empty()) {
            commands.emplace_back("/vis/set/textLayout left");
        }
 
        // Restore default text color.
        commands.emplace_back("/vis/set/textColour");
    }
 
    return commands;
}