g4display_options.cc

Go to the documentation of this file.

// g4display_options.cc
//
// Implementation of g4display option projection and option schema definition.
// Doxygen documentation for public behavior is authoritative in g4display_options.h (see rule 7).
 
#include "g4display_options.h"
#include "g4displayConventions.h"
#include "g4Text.h"
 
namespace g4display {
namespace {
YAML::Node getG4ViewValue(const std::shared_ptr<GOptions>& gopts, const std::string& key) {
    auto node = gopts->getOptionNode("g4view");
    if (node.IsMap() && node[key]) {
        return node[key];
    }
    return gopts->getOptionMapInNode("g4view", key);
}
 
template<typename T>
T getOptionValueOrDefault(const std::shared_ptr<GOptions>& gopts,
                          const std::string& option,
                          const std::string& key,
                          const T& defaultValue) {
    auto node = gopts->getOptionNode(option);
    if (node.IsMap()) {
        return gopts->get_variable_in_option<T>(node, key, defaultValue);
    }
    return gopts->getOptionMapInNode(option, key).as<T>();
}
}
 
// Read g4view option and return a projected G4View struct.
G4View getG4View(const std::shared_ptr<GOptions>& gopts) {
    G4View g4view;
 
    // Project the YAML-like option node values into strongly-typed fields.
    g4view.driver        = getG4ViewValue(gopts, "driver").as<std::string>();
    g4view.dimension     = getG4ViewValue(gopts, "dimension").as<std::string>();
    g4view.position      = getG4ViewValue(gopts, "position").as<std::string>();
    g4view.segsPerCircle = getG4ViewValue(gopts, "segsPerCircle").as<int>();
    g4view.background    = getG4ViewValue(gopts, "background").as<std::string>();
    g4view.cloudPoints   = getG4ViewValue(gopts, "cloudPoints").as<int>();
 
    return g4view;
}
 
// Read the g4camera option and return a G4Camera struct.
G4Camera getG4Camera(const std::shared_ptr<GOptions>& gopts) {
    G4Camera gcamera;
 
    // Camera angles are stored as strings (often with units), and can be parsed later.
    gcamera.phi   = gopts->getOptionMapInNode("g4camera", "phi").as<std::string>();
    gcamera.theta = gopts->getOptionMapInNode("g4camera", "theta").as<std::string>();
 
    return gcamera;
}
 
// Read the g4light option and return a G4Light struct.
G4Light getG4Light(const std::shared_ptr<GOptions>& gopts) {
    G4Light glight;
 
    // Light angles are stored as strings (often with units), and can be parsed later.
    glight.phi   = gopts->getOptionMapInNode("g4light", "phi").as<std::string>();
    glight.theta = gopts->getOptionMapInNode("g4light", "theta").as<std::string>();
 
    return glight;
}
 
// Read the dawn options and return a G4Dawn struct.
G4Dawn getG4Dawn(const std::shared_ptr<GOptions>& gopts) {
    G4Dawn gdawn;
 
    const auto phi   = gopts->getOptionMapInNode("dawn", "phi");
    const auto theta = gopts->getOptionMapInNode("dawn", "theta");
    if (phi && !phi.IsNull()) gdawn.phi = phi.as<std::string>();
    if (theta && !theta.IsNull()) gdawn.theta = theta.as<std::string>();
 
    return gdawn;
}
 
G4Decorations getG4Decorations(const std::shared_ptr<GOptions>& gopts) {
    G4Decorations decorations;
 
    decorations.scale          = getOptionValueOrDefault<bool>(gopts, "g4decoration", "scale", false);
    decorations.scaleLength    = getOptionValueOrDefault<double>(gopts, "g4decoration", "scaleLength", 10.0);
    decorations.scaleUnit      = getOptionValueOrDefault<std::string>(gopts, "g4decoration", "scaleUnit", "mm");
    decorations.scaleDirection = getOptionValueOrDefault<std::string>(gopts, "g4decoration", "scaleDirection", "z");
    decorations.scaleColor     = getOptionValueOrDefault<std::string>(gopts, "g4decoration", "scaleColor", "0.9 0.9 0.9");
    decorations.axes           = getOptionValueOrDefault<bool>(gopts, "g4decoration", "axes", false);
    decorations.eventID        = getOptionValueOrDefault<bool>(gopts, "g4decoration", "eventID", false);
    decorations.eventIDSize    = getOptionValueOrDefault<int>(gopts, "g4decoration", "eventIDSize", 24);
    decorations.date           = getOptionValueOrDefault<bool>(gopts, "g4decoration", "date", false);
    decorations.dateSize       = getOptionValueOrDefault<int>(gopts, "g4decoration", "dateSize", 24);
    decorations.logo2D         = getOptionValueOrDefault<bool>(gopts, "g4decoration", "logo2D", false);
    decorations.logo           = getOptionValueOrDefault<bool>(gopts, "g4decoration", "logo", false);
    decorations.frame          = getOptionValueOrDefault<bool>(gopts, "g4decoration", "frame", false);
    decorations.frameColor     = getOptionValueOrDefault<std::string>(gopts, "g4decoration", "frameColor", "red");
    decorations.frameLineWidth = getOptionValueOrDefault<double>(gopts, "g4decoration", "frameLineWidth", 2.0);
 
    return decorations;
}
 
// Define and return the option set for the g4display module.
GOptions defineOptions() {
    GOptions goptions(G4DISPLAY_LOGGER);
 
    // The module also defines options for g4scene helpers (same executable context).
    goptions += GOptions(G4SCENE_LOGGER);
 
    std::string help;
 
    // g4view
    std::vector<GVariable> g4view = {
        {"driver", std::string(g4display::GDEFAULTVIEWERDRIVER),
         "Geant4 visualization driver. See the detailed help for driver tradeoffs. "},
        {"dimension", std::string(g4display::GDEFAULTVIEWERSIZE), "Geant4 viewer dimension"},
        {"position", std::string(g4display::GDEFAULTVIEWERPOS), "Geant4 viewer position"},
        {"segsPerCircle", g4display::GDEFAULTVSEGPERCIRCLE, "Number of segments per circle"},
        {"background", "0 0.07059 0.16863", "Geant4 viewer background color as '<red> <green> <blue>'"},
        {"cloudPoints", 1000, "Number of points used for cloud volume rendering"}
    };
 
    help = "Defines the Geant4 viewer properties:  \n ";
    help += " - screen dimensions  \n ";
    help += " - screen position  \n ";
    help += " - resolution in terms of segments per circle  \n \n ";
    help += " - viewer background color as '<red> <green> <blue>'  \n ";
    help += " - number of cloud points for cloud volume rendering  \n \n ";
    help += "Viewer drivers (interactive-driver availability depends on the Geant4 build and platform):\n";
    help += " - ASCIITree (ATree): writes the geometry hierarchy as text; headless, but not graphical.\n";
    help += " - DAWNFILE (DAWNFILE): exports for high-quality DAWN rendering; external DAWN is required.\n";
    help += " - RayTracer (RT): software ray tracing to JPEG; realistic, but slower and not interactive.\n";
    help += " - VRML2FILE (VRML2FILE): exports a portable 3D scene for an external VRML viewer.\n";
    help += " - gMocrenFile (gMocrenFile): exports medical volume data for the specialized gMocren viewer.\n";
    help += " - TOOLSSG_OFFSCREEN (TSG_OFFSCREEN, TSG_FILE): headless image/vector output for batch jobs.\n";
    help += " - OpenGLImmediateQt (OGLIQt, OGLI): Qt/OpenGL with low scene memory, but slower redraws.\n";
    help += " - OpenGLStoredQt (OGLSQt, OGLS): Qt/OpenGL with fast redraw and picking; uses more memory.\n";
    help += " - OpenGLImmediateX (OGLIX, OGLIQt_FALLBACK): X11/OpenGL immediate mode; requires X.\n";
    help += " - OpenGLStoredX (OGLSX, OGLSQt_FALLBACK): fast X11/OpenGL redraw; uses more memory.\n";
    help += " - RayTracerX (RTX): ray-traced JPEG plus an X window; high quality, but slow and X-only.\n";
    help += " - TOOLSSG_X11_GLES (TSG_X11_GLES, TSGX11, TSG_QT_GLES_FALLBACK): interactive "
            "X11/GLES; avoids Qt, but requires an X server and GLES support.\n\n";
    help += " Examples: \n \n ";
    help += " -g4view=\"[{dimension: 1200x1000}]\"\n";
    help += " -g4view=\"[{driver: OGL, dimension: 1100x800, position: +200+100, segsPerCircle: 100, background: 0 0.07059 0.16863}]\" \n";
    help += " -g4view=\"[{driver: TOOLSSG_OFFSCREEN, segsPerCircle: 200, cloudPoints: 3000}]\" takes a screenshot at the end of each run \n";
 
    goptions.defineOption("g4view", "Defines the geant4 viewer properties", g4view, help);
 
    // g4camera
    std::vector<GVariable> g4camera = {
        {"phi", "0*deg", "Geant4 camera phi"},
        {"theta", "0*deg", "Geant4 camera theta"}
    };
 
    help = "Defines the geant4 camera view point  \n \n ";
    help += "Example: -g4camera=\"[{phi: 20*deg, theta: 15*deg}]\"  \n ";
 
    goptions.defineOption("g4camera", "Defines the geant4 camera view point", g4camera, help);
 
    // g4light
    std::vector<GVariable> g4light = {
        {"phi", "0*deg", "Geant4 light source phi"},
        {"theta", "0*deg", "Geant4 light source theta"}
    };
 
    help = "Defines the geant4 light source direction  \n \n ";
    help += "Example: -g4light=\"[{phi: 20*deg, theta: 15*deg}]\"  \n ";
 
    goptions.defineOption("g4light", "Defines the geant4 light source direction", g4light, help);
 
    // dawn
    help = "Defines the dawn camera view point and takes a dawn screenshot \n \n ";
    help += "Example: -dawn=\"[{phi: 20*deg, theta: 15*deg}]\"  \n ";
 
    std::vector<GVariable> dawn = {
        {"phi", "30*deg", "dawn camera phi"},
        {"theta", "30*deg", "dawn camera theta"}
    };
 
    goptions.defineOption("dawn", "Defines the dawn view point", dawn, help);
    goptions.defineSwitch("useDawn", "Take a dawn screenshot");
 
    // g4decoration
    std::vector<GVariable> g4decoration = {
        {"scale", false, "add a simple scale line"},
        {"scaleLength", 10.0, "scale length"},
        {"scaleUnit", "mm", "scale length unit"},
        {"scaleDirection", "z", "scale direction: x, y, or z"},
        {"scaleColor", "0.9 0.9 0.9", "scale color as 'r g b' or a named color"},
        {"axes", false, "add simple XYZ axes"},
        {"eventID",     false, "add event ID text at end of event"},
        {"eventIDSize", 24,    "event ID font size in points"},
        {"date",        false, "add a date stamp"},
        {"dateSize",    24,    "date font size in points"},
        {"logo2D", false, "add the 2D Geant4 logo"},
        {"logo", false, "add the 3D Geant4 logo"},
        {"frame", false, "add a frame around the view"},
        {"frameColor", "red", "frame color"},
        {"frameLineWidth", 2.0, "frame line width"}
    };
 
    help = "Adds optional Geant4 scene decorations. \n \n";
    help += "Example: -g4decoration=\"[{scale: true, axes: true, eventID: true, date: true, logo2D: true, logo: true, frame: true}]\" \n";
 
    goptions.defineOption("g4decoration", "Adds optional Geant4 scene decorations", g4decoration, help);
 
    help = "Display magnetic field lines in the initial visualization scene. \n \n";
    help += "The value is the number of field-line integration points. Set to 0 to disable. \n \n";
    help += "Example: -show_field_lines=100 \n";
    goptions.defineOption(GVariable("show_field_lines", 0, "number of field-line points to display"), help);
 
    help = "Display auxiliary edges in the initial visualization scene. \n \n";
    help += "Example: -show_auxiliary_edges=true \n";
    goptions.defineOption(GVariable("show_auxiliary_edges", false, "show auxiliary volume edges"), help);
 
    // scenetext
    goptions.addGOptions(addSceneTextsOptions());
 
    return goptions;
}
} // namespace g4display