lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
84a556a9dca683c2d541394a795642ecb4c07a3d
geant4/source/visualization/ToolsSG/include/G4ToolsSGOffscreenViewer.hh
T
Gabriele Cosmo 9f34590941 Import Geant4 11.1.0 source tree
2022-12-09 14:43:28 +01:00

405 lines
17 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. *
// ********************************************************************
//
// Guy Barrand 09th June 2022
#ifndef G4TOOLSSGOFFSCREENVIEWER_HH
#define G4TOOLSSGOFFSCREENVIEWER_HH
#include "G4ToolsSGViewer.hh"
#include "G4UIcmdWithABool.hh"
#include <tools/fpng>
#include <tools/toojpeg>
#include <tools/offscreen/sg_viewer>
#include <tools/tos>
#include <tools/sto>
class G4ToolsSGOffscreenViewer : public G4ToolsSGViewer<tools::offscreen::session,tools::offscreen::sg_viewer> {
typedef G4ToolsSGViewer<tools::offscreen::session,tools::offscreen::sg_viewer> parent;
public:
G4ToolsSGOffscreenViewer(tools::offscreen::session& a_session,G4ToolsSGSceneHandler& a_scene_handler, const G4String& a_name)
:parent(a_session,a_scene_handler,a_name)
,fFileName("auto")
,fFilePrefix("auto")
,fFileIndex(0)
,fResetFileIndex(false)
{
Messenger::Create();
}
virtual ~G4ToolsSGOffscreenViewer() = default;
protected:
G4ToolsSGOffscreenViewer(const G4ToolsSGOffscreenViewer& a_from):parent(a_from){}
G4ToolsSGOffscreenViewer& operator=(const G4ToolsSGOffscreenViewer&) {return *this;}
public:
virtual void Initialise() {
if(fSGViewer) return; //done.
//::printf("debug : G4ToolsSGOffscreenViewer::Initialize\n");
// auto refresh true produces too much files.
fVP.SetAutoRefresh(false);
fDefaultVP.SetAutoRefresh(false);
fSGViewer = new tools::offscreen::sg_viewer(fSGSession
,fVP.GetWindowAbsoluteLocationHintX(1440)
,fVP.GetWindowAbsoluteLocationHintY(900)
,fVP.GetWindowSizeHintX()
,fVP.GetWindowSizeHintY()
,fName);
fSGViewer->set_file_format("zb_png");
fSGViewer->set_file_name("out.png");
fSGViewer->set_png_writer(tools::fpng::write);
fSGViewer->set_jpeg_writer(tools::toojpeg::write);
fSGViewer->set_do_transparency(true);
fSGViewer->set_top_to_bottom(false); //if using tools::fpng, tools::toojpeg.
}
virtual void SetView() {
//::printf("debug : G4ToolsSGOffscreenViewer::SetView\n");
fVP.SetGlobalMarkerScale(1); //WARNING: for __APPLE__, the G4ToolsSGQtViewer set it to 2.
parent::SetView();
}
virtual void DrawView() {
if (!fNeedKernelVisit) KernelVisitDecision();
fLastVP = fVP;
ProcessView(); // Clears store and processes scene only if necessary.
//::printf("debug : G4ToolsSGOffscreenViewer::DrawView %s\n",fName.c_str());
if(fSGViewer) {
fSGSceneHandler.TouchPlotters(fSGViewer->sg());
if(fFileName=="auto") {
std::string prefix;
if(fFilePrefix=="auto") {
prefix = "g4tsg_offscreen_"+fSGViewer->file_format()+"_";
} else {
prefix = fFilePrefix;
}
std::string suffix;
if(G4ToolsSGOffscreenViewer::GetFormatExtension(fSGViewer->file_format(),suffix)) {
std::string file_name = prefix+tools::tos(GetFileIndex())+"."+suffix;
fSGViewer->set_file_name(file_name);
}
} else {
fSGViewer->set_file_name(fFileName);
}
if(fSGViewer->write_paper()) {
if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations) {
G4cout << "File " << fSGViewer->file_name() << " produced." << G4endl;
}
}
}
}
virtual void ClearView() {
//::printf("debug : G4ToolsSGOffscreenViewer::ClearView %s\n",fName.c_str());
}
virtual void ShowView() {
//::printf("debug : G4ToolsSGOffscreenViewer::ShowView %s\n",fName.c_str());
}
virtual void FinishView() {
//::printf("debug : G4ToolsSGOffscreenViewer::FinishView %s\n",fName.c_str());
if(fSGViewer) {
fSGSceneHandler.TouchPlotters(fSGViewer->sg());
}
}
protected:
void SetSize(unsigned int a_w,unsigned int a_h) {
if(!fSGViewer) return;
if(!a_w || !a_h) {
fSGViewer->set_size(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
} else {
fSGViewer->set_size(a_w,a_h);
}
}
void SetFileFormat(const G4String& a_format) {
if(!fSGViewer) return;
fSGViewer->set_file_format(a_format);
}
void SetDoTransparency(bool a_value) {
if(!fSGViewer) return;
fSGViewer->set_do_transparency(a_value);
}
void SetFileName(const G4String& a_file,const G4String& a_prefix,bool a_reset_index) {
fFileName = a_file;
fFilePrefix = a_prefix;
fResetFileIndex = a_reset_index;
}
void SetGL2PSSort(const G4String& a_sort) {
if(!fSGViewer) return;
fSGViewer->set_opts_1(a_sort);
}
void SetGL2PSOptions(const G4String& a_opts) {
if(!fSGViewer) return;
fSGViewer->set_opts_2(a_opts);
}
class Messenger: public G4VVisCommand {
public:
static void Create() {static Messenger s_messenger;}
private:
Messenger() {
G4UIparameter* parameter;
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
cmd_format = new G4UIcommand("/vis/tsg/offscreen/set/format", this);
cmd_format->SetGuidance("Set file format.");
cmd_format->SetGuidance("Available formats are:");
cmd_format->SetGuidance("- zb_png: tools::sg offscreen zbuffer put in a png file.");
cmd_format->SetGuidance("- zb_jpeg: tools::sg offscreen zbuffer put in a jpeg file.");
cmd_format->SetGuidance("- zb_ps: tools::sg offscreen zbuffer put in a PostScript file.");
cmd_format->SetGuidance("- gl2ps_eps: gl2ps producing eps");
cmd_format->SetGuidance("- gl2ps_ps: gl2ps producing ps");
cmd_format->SetGuidance("- gl2ps_pdf: gl2ps producing pdf");
cmd_format->SetGuidance("- gl2ps_svg: gl2ps producing svg");
cmd_format->SetGuidance("- gl2ps_tex: gl2ps producing tex");
cmd_format->SetGuidance("- gl2ps_pgf: gl2ps producing pgf");
parameter = new G4UIparameter("format",'s',true);
parameter->SetDefaultValue("gl2ps_eps");
cmd_format->SetParameter (parameter);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
cmd_file = new G4UIcommand("/vis/tsg/offscreen/set/file", this);
cmd_file->SetGuidance("Set file name.");
cmd_file->SetGuidance("Default file name is \"auto\" and default format is zb_png.");
cmd_file->SetGuidance("If file name is \"auto\", the output file name is built from");
cmd_file->SetGuidance("a viewer index counter with the form:");
cmd_file->SetGuidance(" g4tsg_offscreen_<format>_<index>.<format extension>");
cmd_file->SetGuidance("For example:");
cmd_file->SetGuidance(" g4tsg_offscreen_zb_png_1.png");
cmd_file->SetGuidance(" g4tsg_offscreen_zb_png_2.png");
cmd_file->SetGuidance(" ...");
cmd_file->SetGuidance("or if format is changed to \"gl2ps_pdf\":");
cmd_file->SetGuidance(" g4tsg_offscreen_gl2ps_pdf_3.pdf");
cmd_file->SetGuidance("If a prefix parameter is given, the output file name is built from");
cmd_file->SetGuidance("a global index counter with the form:");
cmd_file->SetGuidance(" <prefix><index>.<format extension>");
cmd_file->SetGuidance("For example:");
cmd_file->SetGuidance(" /vis/tsg/offscreen/set/file auto my_prefix_");
cmd_file->SetGuidance("will produce:");
cmd_file->SetGuidance(" my_prefix_1.png");
cmd_file->SetGuidance(" my_prefix_2.png");
cmd_file->SetGuidance(" ...");
cmd_file->SetGuidance("You can reset the index by specifying true as last argument:");
cmd_file->SetGuidance(" /vis/tsg/offscreen/set/file auto other_prefix_ true");
cmd_file->SetGuidance("will produce:");
cmd_file->SetGuidance(" other_prefix_1.png");
cmd_file->SetGuidance(" other_prefix_2.png");
cmd_file->SetGuidance(" ...");
parameter = new G4UIparameter("file",'s',true);
parameter->SetDefaultValue("auto");
cmd_file->SetParameter (parameter);
parameter = new G4UIparameter("prefix",'s',true);
parameter->SetDefaultValue("auto");
cmd_file->SetParameter (parameter);
parameter = new G4UIparameter("reset_index",'b',true);
parameter->SetDefaultValue("false");
cmd_file->SetParameter (parameter);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
cmd_size = new G4UIcommand("/vis/tsg/offscreen/set/size", this);
cmd_size->SetGuidance("Set viewer size in pixels.");
cmd_size->SetGuidance
("If width and/or height is set to zero, the viewer size specified with /vis/viewer/create (/vis/open) is taken.");
cmd_size->SetGuidance(" About the picture size, note that the gl2ps files will grow with the number of primitives");
cmd_size->SetGuidance("(gl2ps does not have a zbuffer logic). The \"zb\" files will not grow with the number of");
cmd_size->SetGuidance("primitives, but with the size of the viewer. It should be preferred for scenes with");
cmd_size->SetGuidance("a lot of objects to render. With zb, to have a better rendering, do not hesitate to");
cmd_size->SetGuidance("have a large viewer size.");
parameter = new G4UIparameter("width",'i',false);
parameter->SetDefaultValue("0");
cmd_size->SetParameter (parameter);
parameter = new G4UIparameter("height",'i',false);
parameter->SetDefaultValue("0");
cmd_size->SetParameter (parameter);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
cmd_do_transparency = new G4UIcmdWithABool("/vis/tsg/offscreen/set/transparency", this);
cmd_do_transparency->SetGuidance("True/false to enable/disable rendering of transparent objects.");
cmd_do_transparency->SetGuidance("This may be usefull if using file formats, as the gl2ps ones, unable to handle transparency.");
cmd_do_transparency->SetParameterName("transparency-enabled",true);
cmd_do_transparency->SetDefaultValue(true);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
cmd_gl2ps_sort = new G4UIcommand("/vis/tsg/offscreen/gl2ps/set/sort", this);
cmd_gl2ps_sort->SetGuidance("Set gl2ps sort algorithm when creating the file.");
cmd_gl2ps_sort->SetGuidance("The sort argument could be:");
cmd_gl2ps_sort->SetGuidance(" NO_SORT");
cmd_gl2ps_sort->SetGuidance(" SIMPLE_SORT");
cmd_gl2ps_sort->SetGuidance(" BSP_SORT");
cmd_gl2ps_sort->SetGuidance("The default being BSP_SORT");
parameter = new G4UIparameter("sort",'s',true);
parameter->SetDefaultValue("BSP_SORT");
cmd_gl2ps_sort->SetParameter (parameter);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
cmd_gl2ps_opts = new G4UIcommand("/vis/tsg/offscreen/gl2ps/set/options", this);
cmd_gl2ps_opts->SetGuidance("Set gl2ps options passed when creating the file.");
cmd_gl2ps_opts->SetGuidance("Options is a list of items separated by |. An item can be:");
cmd_gl2ps_opts->SetGuidance(" NONE");
cmd_gl2ps_opts->SetGuidance(" DRAW_BACKGROUND");
cmd_gl2ps_opts->SetGuidance(" SIMPLE_LINE_OFFSET");
cmd_gl2ps_opts->SetGuidance(" SILENT");
cmd_gl2ps_opts->SetGuidance(" BEST_ROOT");
cmd_gl2ps_opts->SetGuidance(" OCCLUSION_CULL");
cmd_gl2ps_opts->SetGuidance(" NO_TEXT");
cmd_gl2ps_opts->SetGuidance(" LANDSCAPE");
cmd_gl2ps_opts->SetGuidance(" NO_PS3_SHADING");
cmd_gl2ps_opts->SetGuidance(" NO_PIXMAP");
cmd_gl2ps_opts->SetGuidance(" USE_CURRENT_VIEWPORT");
cmd_gl2ps_opts->SetGuidance(" COMPRESS");
cmd_gl2ps_opts->SetGuidance(" NO_BLENDING");
cmd_gl2ps_opts->SetGuidance(" TIGHT_BOUNDING_BOX");
cmd_gl2ps_opts->SetGuidance(" NO_OPENGL_CONTEXT");
cmd_gl2ps_opts->SetGuidance(" NO_TEX_FONTSIZE");
cmd_gl2ps_opts->SetGuidance(" PORTABLE_SORT");
cmd_gl2ps_opts->SetGuidance("The default (typical) list of options is:");
cmd_gl2ps_opts->SetGuidance(" SILENT|OCCLUSION_CULL|BEST_ROOT|DRAW_BACKGROUND");
parameter = new G4UIparameter("options",'s',true);
parameter->SetDefaultValue("SILENT|OCCLUSION_CULL|BEST_ROOT|DRAW_BACKGROUND");
cmd_gl2ps_opts->SetParameter (parameter);
}
virtual ~Messenger() {
delete cmd_format;
delete cmd_file;
delete cmd_size;
delete cmd_do_transparency;
delete cmd_gl2ps_sort;
delete cmd_gl2ps_opts;
}
public:
virtual void SetNewValue(G4UIcommand* a_cmd,G4String a_value) {
G4VisManager::Verbosity verbosity = GetVisManager()->GetVerbosity();
G4VViewer* viewer = GetVisManager()->GetCurrentViewer();
if (!viewer) {
if (verbosity >= G4VisManager::errors) G4cerr << "ERROR: No current viewer." << G4endl;
return;
}
G4ToolsSGOffscreenViewer* tsg_viewer = dynamic_cast<G4ToolsSGOffscreenViewer*>(viewer);
if(!tsg_viewer) {
G4cout << "G4ToolsSGOffscreenViewer::Messenger::SetNewValue:"
<< " current viewer is not a G4ToolsSGOffscreenViewer." << G4endl;
return;
}
std::vector<std::string> args;
tools::double_quotes_tokenize(a_value,args);
if(args.size()!=a_cmd->GetParameterEntries()) return;
if(a_cmd==cmd_format) {
if(!IsKnownFormat(args[0])) {
G4cout << "G4ToolsSGOffscreenViewer::Messenger::SetNewValue:"
<< " unknown file format " << args[0] << "." << G4endl;
return;
}
tsg_viewer->SetFileFormat(args[0]);
} else if(a_cmd==cmd_file) {
G4bool reset_index = G4UIcommand::ConvertToBool(args[2].c_str());
tsg_viewer->SetFileName(args[0],args[1],reset_index);
} else if(a_cmd==cmd_size) {
unsigned int w,h;
if(!tools::to(args[0],w)) w = 0;
if(!tools::to(args[1],h)) h = 0;
tsg_viewer->SetSize(w,h);
} else if(a_cmd==cmd_do_transparency) {
G4bool _do = a_cmd->ConvertToBool(args[0].c_str());
tsg_viewer->SetDoTransparency(_do);
} else if(a_cmd==cmd_gl2ps_sort) {
tsg_viewer->SetGL2PSSort(args[0]);
} else if(a_cmd==cmd_gl2ps_opts) {
tsg_viewer->SetGL2PSOptions(args[0]);
}
}
private:
G4UIcommand* cmd_format;
G4UIcommand* cmd_file;
G4UIcommand* cmd_size;
G4UIcmdWithABool* cmd_do_transparency;
G4UIcommand* cmd_gl2ps_sort;
G4UIcommand* cmd_gl2ps_opts;
};
protected:
unsigned int GetFileIndex() {
if(fResetFileIndex) {fFileIndex = 0;fResetFileIndex = false;}
fFileIndex++;
return fFileIndex;
}
static bool IsKnownFormat(const std::string& a_format) {
if(a_format=="gl2ps_eps") return true;
if(a_format=="gl2ps_ps") return true;
if(a_format=="gl2ps_pdf") return true;
if(a_format=="gl2ps_svg") return true;
if(a_format=="gl2ps_tex") return true;
if(a_format=="gl2ps_pgf") return true;
if(a_format=="zb_ps") return true;
if(a_format=="zb_png") return true;
if(a_format=="zb_jpeg") return true;
return false;
}
static bool GetFormatExtension(const std::string& a_format,std::string& a_ext) {
if(a_format=="gl2ps_eps") {a_ext = "eps";return true;}
if(a_format=="gl2ps_ps") {a_ext = "ps";return true;}
if(a_format=="gl2ps_pdf") {a_ext = "pdf";return true;}
if(a_format=="gl2ps_svg") {a_ext = "svg";return true;}
if(a_format=="gl2ps_tex") {a_ext = "tex";return true;}
if(a_format=="gl2ps_pgf") {a_ext = "pgf";return true;}
if(a_format=="zb_ps") {a_ext = "ps";return true;}
if(a_format=="zb_png") {a_ext = "png";return true;}
if(a_format=="zb_jpeg") {a_ext = "jpeg";return true;}
a_ext.clear();
return false;
}
protected:
std::string fFileName;
std::string fFilePrefix;
unsigned int fFileIndex;
bool fResetFileIndex;
};
#endif
Reference in New Issue View Git Blame Copy Permalink