G4ToolsSGSceneHandler Class Reference

#include <G4ToolsSGSceneHandler.hh>

Inheritance diagram for G4ToolsSGSceneHandler:

Classes
class	Messenger

Public Member Functions
virtual void	AddPrimitive (const G4Polyline &)
virtual void	AddPrimitive (const G4Text &)
virtual void	AddPrimitive (const G4Circle &)
virtual void	AddPrimitive (const G4Square &)
virtual void	AddPrimitive (const G4Polymarker &)
virtual void	AddPrimitive (const G4Polyhedron &)
virtual void	AddPrimitive (const G4Plotter &)
virtual void	AddCompound (const G4Mesh &)
virtual void	ClearStore ()
virtual void	ClearTransientStore ()
	G4ToolsSGSceneHandler (G4VGraphicsSystem &system, const G4String &name)
virtual	~G4ToolsSGSceneHandler ()
tools::sg::separator &	GetTransient2DObjects ()
tools::sg::separator &	GetPersistent2DObjects ()
tools::sg::separator &	GetTransient3DObjects ()
tools::sg::separator &	GetPersistent3DObjects ()
void	TouchPlotters (tools::sg::node &)
void	SetMarkerScale (double)
virtual void	AddCompound (const G4VTrajectory &)
virtual void	AddCompound (const G4VHit &)
virtual void	AddCompound (const G4VDigi &)
virtual void	AddCompound (const G4THitsMap< G4double > &)
virtual void	AddCompound (const G4THitsMap< G4StatDouble > &)
Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
virtual	~G4VSceneHandler ()
virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
virtual void	PostAddSolid ()
virtual void	AddSolid (const G4Box &)
virtual void	AddSolid (const G4Cons &)
virtual void	AddSolid (const G4Orb &)
virtual void	AddSolid (const G4Para &)
virtual void	AddSolid (const G4Sphere &)
virtual void	AddSolid (const G4Torus &)
virtual void	AddSolid (const G4Trap &)
virtual void	AddSolid (const G4Trd &)
virtual void	AddSolid (const G4Tubs &)
virtual void	AddSolid (const G4Ellipsoid &)
virtual void	AddSolid (const G4Polycone &)
virtual void	AddSolid (const G4Polyhedra &)
virtual void	AddSolid (const G4TessellatedSolid &)
virtual void	AddSolid (const G4VSolid &)
virtual void	BeginModeling ()
virtual void	EndModeling ()
virtual void	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())
virtual void	EndPrimitives ()
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())
virtual void	EndPrimitives2D ()
virtual const G4VisExtent &	GetExtent () const
const G4String &	GetName () const
G4int	GetSceneHandlerId () const
G4int	GetViewCount () const
G4VGraphicsSystem *	GetGraphicsSystem () const
G4Scene *	GetScene () const
const G4ViewerList &	GetViewerList () const
G4VModel *	GetModel () const
G4VViewer *	GetCurrentViewer () const
G4bool	GetMarkForClearingTransientStore () const
G4bool	IsReadyForTransients () const
G4bool	GetTransientsDrawnThisEvent () const
G4bool	GetTransientsDrawnThisRun () const
const G4Transform3D &	GetObjectTransformation () const
void	SetName (const G4String &)
void	SetCurrentViewer (G4VViewer *)
virtual void	SetScene (G4Scene *)
G4ViewerList &	SetViewerList ()
void	SetModel (G4VModel *)
void	SetMarkForClearingTransientStore (G4bool)
void	SetTransientsDrawnThisEvent (G4bool)
void	SetTransientsDrawnThisRun (G4bool)
void	SetObjectTransformation (const G4Transform3D &)
const G4Colour &	GetColour ()
const G4Colour &	GetColor ()
const G4Colour &	GetColour (const G4Visible &)
const G4Colour &	GetColor (const G4Visible &)
const G4Colour &	GetTextColour (const G4Text &)
const G4Colour &	GetTextColor (const G4Text &)
G4double	GetLineWidth (const G4VisAttributes *)
G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)
G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const
G4bool	GetAuxEdgeVisible (const G4VisAttributes *)
G4int	GetNoOfSides (const G4VisAttributes *)
G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)
G4ModelingParameters *	CreateModelingParameters ()
void	DrawEvent (const G4Event *)
void	DrawEndOfRunModels ()
template<class T>
void	AddSolidT (const T &solid)
template<class T>
void	AddSolidWithAuxiliaryEdges (const T &solid)
G4int	IncrementViewCount ()
void	AddViewerToList (G4VViewer *pView)
void	RemoveViewerFromList (G4VViewer *pView)
Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()
virtual	~G4VGraphicsScene ()
G4int	GetMaxGeometryDepth () const
void	SetMaxGeometryDepth (G4int maxDepth)

Protected Types
using	Region_h1 = std::pair<unsigned int,int>
using	Region_h2 = std::pair<unsigned int,int>

Protected Member Functions
	G4ToolsSGSceneHandler (const G4ToolsSGSceneHandler &)
G4ToolsSGSceneHandler &	operator= (const G4ToolsSGSceneHandler &)
void	CreateSG ()
void	EstablishBaseNodes ()
tools::sg::separator *	GetOrCreateNode ()
void	SetPlotterHistograms (tools::sg::plots &)
Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()
virtual void	ProcessTransients ()
virtual void	RequestPrimitives (const G4VSolid &solid)
virtual G4DisplacedSolid *	CreateSectionSolid ()
virtual G4DisplacedSolid *	CreateCutawaySolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
void	StandardSpecialMeshRendering (const G4Mesh &)
void	Draw3DRectMeshAsDots (const G4Mesh &)
void	Draw3DRectMeshAsSurfaces (const G4Mesh &)
void	DrawTetMeshAsDots (const G4Mesh &)
void	DrawTetMeshAsSurfaces (const G4Mesh &)
G4ThreeVector	GetPointInBox (const G4ThreeVector &pos, G4double halfX, G4double halfY, G4double halfZ) const
G4ThreeVector	GetPointInTet (const std::vector< G4ThreeVector > &vertices) const

Protected Attributes
tools::sg::separator	fpTransient2DObjects
tools::sg::separator	fpPersistent2DObjects
tools::sg::separator	fpTransient3DObjects
tools::sg::separator	fpPersistent3DObjects
std::vector< G4ToolsSGNode * >	fpPhysicalVolumeObjects
tools::sg::base_freetype *	fFreetypeNode
double	fMarkerScale
std::vector< Region_h1 >	fRegionH1s
std::vector< Region_h2 >	fRegionH2s
Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem &	fSystem
const G4int	fSceneHandlerId
G4String	fName
G4int	fViewCount
G4ViewerList	fViewerList
G4VViewer *	fpViewer
G4Scene *	fpScene
G4bool	fMarkForClearingTransientStore
G4bool	fReadyForTransients
G4bool	fTransientsDrawnThisEvent
G4bool	fTransientsDrawnThisRun
G4bool	fProcessingSolid
G4bool	fProcessing2D
G4VModel *	fpModel
G4Transform3D	fObjectTransformation
G4int	fNestingDepth
const G4VisAttributes *	fpVisAttribs
const G4Transform3D	fIdentityTransformation
std::map< G4VPhysicalVolume *, G4String >	fProblematicVolumes
Protected Attributes inherited from G4VGraphicsScene
G4int	fMaxGeometryDepth = 0

Static Protected Attributes
static G4int	fSceneIdCount = 0

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world , screen }

Detailed Description

Definition at line 44 of file G4ToolsSGSceneHandler.hh.

Member Typedef Documentation

Region_h1

using G4ToolsSGSceneHandler::Region_h1 = std::pair<unsigned int,int>

protected

Definition at line 97 of file G4ToolsSGSceneHandler.hh.

Region_h2

using G4ToolsSGSceneHandler::Region_h2 = std::pair<unsigned int,int>

protected

Definition at line 98 of file G4ToolsSGSceneHandler.hh.

Constructor & Destructor Documentation

G4ToolsSGSceneHandler() [1/2]

G4ToolsSGSceneHandler::G4ToolsSGSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name )

Definition at line 76 of file G4ToolsSGSceneHandler.cc.

:parent(system, fSceneIdCount++, name)
,fFreetypeNode(0)
,fMarkerScale(1)
{
  //::printf("debug : G4ToolsSGSceneHandler : %lu, %s\n",this,name.c_str());
  EstablishBaseNodes();
#if defined(TOOLS_USE_FREETYPE)
  fFreetypeNode = new toolx::sg::text_freetype();
  fFreetypeNode->add_embedded_font(tools::sg::font_lato_regular_ttf(),tools::font::lato_regular_ttf);
  fFreetypeNode->add_embedded_font(tools::sg::font_roboto_bold_ttf(),tools::font::roboto_bold_ttf);
#else  
  fFreetypeNode = new tools::sg::dummy_freetype();
#endif
  Messenger::Create();
}

Referenced by G4ToolsSGSceneHandler(), operator=(), and G4ToolsSGSceneHandler::Messenger::SetNewValue().

~G4ToolsSGSceneHandler()

G4ToolsSGSceneHandler::~G4ToolsSGSceneHandler ( )

virtual

Definition at line 94 of file G4ToolsSGSceneHandler.cc.

{
  //::printf("debug : ~G4ToolsSGSceneHandler : %lu\n",this);
  //WARNING : nodes may refer graphics managers (as tools/sg/[GL_manager,gl2ps_manager,zb_manager]
  //          used by viewers) to handle gstos (for GPU) or textures, then we have to delete them first.
  //          It is assumed that we pass here BEFORE the attached/managed viewers are deleted.
  fpTransient2DObjects.clear();
  fpPersistent2DObjects.clear();
  fpTransient3DObjects.clear();
  fpPersistent3DObjects.clear();
  delete fFreetypeNode;
}

G4ToolsSGSceneHandler() [2/2]

G4ToolsSGSceneHandler::G4ToolsSGSceneHandler ( const G4ToolsSGSceneHandler & )

protected

Member Function Documentation

AddCompound() [1/6]

void G4ToolsSGSceneHandler::AddCompound ( const G4Mesh & mesh )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 593 of file G4ToolsSGSceneHandler.cc.

{
  StandardSpecialMeshRendering(mesh);
}

AddCompound() [2/6]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4double > & hits )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 133 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(const auto& i : scoreMap) {
      const G4String& scoreMapName = i.first;
      if (scoreMapName == mapNam) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
  }
}

AddCompound() [3/6]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > & hits )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 134 of file G4VSceneHandler.cc.

                                                                       {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(const auto& i : scoreMap) {
      const G4String& scoreMapName = i.first;
      const G4THitsMap<G4StatDouble>* foundHits = i.second;
      if (foundHits == &hits) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4StatDouble>&>(hits).DrawAllHits();
  }
}

AddCompound() [4/6]

void G4VSceneHandler::AddCompound ( const G4VDigi & digi )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 132 of file G4VSceneHandler.cc.

                                                      {
  // Cast away const because Draw is non-const!!!!
  const_cast<G4VDigi&>(digi).Draw();
}

AddCompound() [5/6]

void G4VSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 131 of file G4VSceneHandler.cc.

                                                    {
  // Cast away const because Draw is non-const!!!!
  const_cast<G4VHit&>(hit).Draw();
}

AddCompound() [6/6]

void G4VSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 130 of file G4VSceneHandler.cc.

                                                            {
  G4TrajectoriesModel* trajectoriesModel =
    dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajectoriesModel)
    traj.DrawTrajectory();
  else {
    G4Exception
    ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
     "visman0105", FatalException, "Not a G4TrajectoriesModel.");
  }
}

AddPrimitive() [1/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Circle & a_circle )

virtual

Implements G4VSceneHandler.

Definition at line 421 of file G4ToolsSGSceneHandler.cc.

{
  G4Polymarker oneCircle(a_circle);
  oneCircle.push_back(a_circle.GetPosition());
  oneCircle.SetMarkerType(G4Polymarker::circles);
  // Call this AddPrimitive to avoid re-doing sub-class code.
  G4ToolsSGSceneHandler::AddPrimitive(oneCircle);
}

AddPrimitive() [2/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Plotter & a_plotter )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 820 of file G4ToolsSGSceneHandler.cc.

{
//G4cout << "debug : G4ToolsSGSceneHandler::AddPrimitive : 004" << std::endl;
  if(!fpViewer) return;
  
  auto currentNode = GetOrCreateNode();
  if (!currentNode) return;  // Node not available
 
  currentNode->add(new tools::sg::light_off());
  
  tools::sg::plots* _plots = new tools::sg::plots(*fFreetypeNode);
  currentNode->add(_plots);
  
  _plots->view_border = false;
  _plots->set_regions(a_plotter.GetColumns(),a_plotter.GetRows());
 
 {tools::sg::event_dispatcher* dpt = new tools::sg::event_dispatcher;
  dpt->add_callback(new plots_cbk(*_plots));
  currentNode->add(dpt);}
 
  SetPlotterStyles(*_plots,a_plotter.GetStyles(),a_plotter.GetRegionStyles());
 
  tools::sg::cmaps_t _cmaps;
  _cmaps["default"] = tools::sg::style_default_colormap();
  _cmaps["ROOT"] = tools::sg::style_ROOT_colormap();
  
  SetPlotterParameters(_cmaps,*_plots,a_plotter.GetRegionParameters());
 
  fRegionH1s = a_plotter.GetRegionH1s();
  fRegionH2s = a_plotter.GetRegionH2s();
 
  SetPlotterHistograms(*_plots);
}

AddPrimitive() [3/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Polyhedron & a_polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 439 of file G4ToolsSGSceneHandler.cc.

{
  if (a_polyhedron.GetNoFacets() == 0) return;
 
  //::printf("debug : G4ToolsSGSceneHandler::AddPrimitive(const G4Polyhedron&) : %d\n",a_polyhedron.GetNoFacets());
  
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(a_polyhedron.GetVisAttributes());
 
  // Roll out vertices and normals for the faces. Note that this means vertices
  // are duplicated. For example a box has 8 vertices, but to define 6 faces
  // you need 12 triangles and 36 vertices. If it was just a matter of vertices
  // we could restrict the number to 8 and use the indices to define the
  // triangles, but we also have to consider the normals. A vertex can be have
  // more than one normal, depending on which face it is being used to define.
  // So we roll out all the vertices and normals for each triangle.
  std::vector<G4Point3D> vertices;
  std::vector<G4Normal3D> normals;
 
  // Also roll out edges (as lines) for wireframe. Avoid duplicate lines,
  // including those that differ only in the order of vertices.
  typedef std::pair<G4Point3D,G4Point3D> Line;
  std::vector<Line> lines;
  auto insertIfNew = [&lines](const Line& newLine) {
//    for (const auto& line: lines) {
//      if ((newLine.first==line.first && newLine.second==line.second) ||
//          (newLine.first==line.second && newLine.second==line.first))
//      return;
//    }
    lines.push_back(newLine);
  };
 
  G4bool isAuxilaryEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible();
  G4bool notLastFace;
  do {
    G4int      nEdges;
    G4Point3D  vertex  [4];
    G4int      edgeFlag[4];
    G4Normal3D normal  [4];
    notLastFace = a_polyhedron.GetNextFacet(nEdges, vertex, edgeFlag, normal);
    vertices.push_back(vertex[0]);
    vertices.push_back(vertex[1]);
    vertices.push_back(vertex[2]);
    normals.push_back(normal[0]);
    normals.push_back(normal[1]);
    normals.push_back(normal[2]);
    if(isAuxilaryEdgeVisible||edgeFlag[0]>0)insertIfNew(Line(vertex[0],vertex[1]));
    if(isAuxilaryEdgeVisible||edgeFlag[1]>0)insertIfNew(Line(vertex[1],vertex[2]));
    if (nEdges == 3) {
      // Face is a triangle
      // One more line for wireframe, triangles for surfaces are complete
      if(isAuxilaryEdgeVisible||edgeFlag[2]>0)insertIfNew(Line(vertex[2],vertex[0]));
    } else if (nEdges == 4) {
      // Face is a quadrilateral
      // Create another triangle for surfaces, add two more lines for wireframe
      vertices.push_back(vertex[2]);
      vertices.push_back(vertex[3]);
      vertices.push_back(vertex[0]);
      normals.push_back(normal[2]);
      normals.push_back(normal[3]);
      normals.push_back(normal[0]);
      if(isAuxilaryEdgeVisible||edgeFlag[2]>0)insertIfNew(Line(vertex[2],vertex[3]));
      if(isAuxilaryEdgeVisible||edgeFlag[3]>0)insertIfNew(Line(vertex[3],vertex[0]));
    } else {
      G4cerr
        << "G4ToolsSGSceneHandler::AddPrimitive(G4Polyhedron): WARNING:"
        << "\n G4Polyhedron facet with unexpected number of edges (" << nEdges << ")."
        << G4endl;
      return;
    }
  } while (notLastFace);
 
  G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (fpVisAttribs);
  switch (drawing_style) {
    case G4ViewParameters::wireframe:
      //vertices.clear();
      break;
    case G4ViewParameters::hlr:
      break;
    case G4ViewParameters::hsr:
      //lines.clear();
      break;
    case G4ViewParameters::hlhsr:
      break;
    case G4ViewParameters::cloud:
      // Shouldn't happen in this function (it's a polyhedron!) - ignore
      return;
  }
 
  auto currentNode = GetOrCreateNode();
  if (!currentNode) return;  // Node not available
  
  tools::sg::separator* sep = new tools::sg::separator;
  currentNode->add(sep);
 
  // Transformation
 {tools::sg::matrix* mtx = new tools::sg::matrix;
  G4Transform3D& elem = fObjectTransformation;
  mtx->mtx.value().set_matrix(elem(0,0),elem(0,1),elem(0,2),elem(0,3),
                              elem(1,0),elem(1,1),elem(1,2),elem(1,3),
                              elem(2,0),elem(2,1),elem(2,2),elem(2,3),
                                      0,        0,        0,        1);
  sep->add(mtx);}
 
 {const auto& colour = GetColour(a_polyhedron);
  tools::sg::rgba* mat = new tools::sg::rgba();
  mat->color =
    tools::colorf(float(colour.GetRed()),
                  float(colour.GetGreen()),
                  float(colour.GetBlue()),
                  float(colour.GetAlpha()));
  sep->add(mat);}
 
  if (drawing_style == G4ViewParameters::hlr ||
      drawing_style == G4ViewParameters::hsr ||
      drawing_style == G4ViewParameters::hlhsr) {
 
   {tools::sg::draw_style* ds = new tools::sg::draw_style;
    ds->style = tools::sg::draw_filled;
  //ds->cull_face = true;
    sep->add(ds);}
 
    tools::sg::atb_vertices* vtxs = new tools::sg::atb_vertices;
    vtxs->mode = tools::gl::triangles();
    sep->add(vtxs);
    
    const auto nVerts = vertices.size();
    for (size_t i = 0; i < nVerts; i++) {
      vtxs->add(float(vertices[i].x()),float(vertices[i].y()),float(vertices[i].z()));
      vtxs->add_normal(float(normals[i].x()),float(normals[i].y()),float(normals[i].z()));
    }
  }
 
  if (drawing_style == G4ViewParameters::wireframe ||
      drawing_style == G4ViewParameters::hlr ||
      drawing_style == G4ViewParameters::hlhsr) {
 
   {tools::sg::draw_style* ds = new tools::sg::draw_style;
    ds->style = tools::sg::draw_lines;
    auto visAtts = GetCurrentViewer()->GetApplicableVisAttributes(a_polyhedron.GetVisAttributes());
    ds->line_width = GetLineWidth(visAtts);  // Multiplies by GetGlobalLineWidthScale
    sep->add(ds);}
 
    tools::sg::vertices* vtxs = new tools::sg::vertices;
    vtxs->mode = tools::gl::lines();  //segments
    sep->add(vtxs);
    
    for (const auto& line: lines) {
      vtxs->add(float(line.first.x()),float(line.first.y()),float(line.first.z()));
      vtxs->add(float(line.second.x()),float(line.second.y()),float(line.second.z()));
    }
  
  }
}

AddPrimitive() [4/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Polyline & a_polyline )

virtual

Implements G4VSceneHandler.

Definition at line 215 of file G4ToolsSGSceneHandler.cc.

{
  //G4cout << "debug : G4ToolsSGSceneHandler::AddPrimitive(const G4Polyline&) : \n" << a_polyline << G4endl;
  if (a_polyline.size() == 0) return;
 
  tools::sg::separator* parentNode = 0;
  if(fProcessing2D) {
    parentNode = new tools::sg::separator;
    if (fReadyForTransients) {
      fpTransient2DObjects.add(parentNode);
    } else {
      fpPersistent2DObjects.add(parentNode);
    }
 
  } else {
    parentNode = GetOrCreateNode();
    if(!parentNode) return;
 
    tools::sg::matrix* mtx = new tools::sg::matrix;
    G4Transform3D& elem = fObjectTransformation;
    mtx->mtx.value().set_matrix(elem(0,0),elem(0,1),elem(0,2),elem(0,3),
                                elem(1,0),elem(1,1),elem(1,2),elem(1,3),
                                elem(2,0),elem(2,1),elem(2,2),elem(2,3),
                                        0,        0,        0,        1);
    parentNode->add(mtx);
  }
 
 {const auto& colour = GetColour(a_polyline);
  tools::sg::rgba* mat = new tools::sg::rgba();
  mat->color =
    tools::colorf(float(colour.GetRed()),
                  float(colour.GetGreen()),
                  float(colour.GetBlue()),
                  float(colour.GetAlpha()));
  parentNode->add(mat);}
 
 {tools::sg::draw_style* ds = new tools::sg::draw_style;
  ds->style = tools::sg::draw_lines;
  auto visAtts = GetCurrentViewer()->GetApplicableVisAttributes(a_polyline.GetVisAttributes());
  ds->line_width = GetLineWidth(visAtts);  // Multiplies by GetGlobalLineWidthScale
  parentNode->add(ds);}
 
  tools::sg::vertices* vtxs = new tools::sg::vertices;
  vtxs->mode = tools::gl::line_strip();  //polyline
  parentNode->add(vtxs);
  
 {for (const auto& i : a_polyline) {
    vtxs->add(float(i.x()),float(i.y()),float(i.z()));
  }}
  
}

Referenced by AddPrimitive(), and AddPrimitive().

AddPrimitive() [5/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Polymarker & a_polymarker )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 267 of file G4ToolsSGSceneHandler.cc.

{
  //::printf("debug G4ToolsSGSceneHandler::AddPrimitive(const G4Polymarker&) : %lu, type %d\n",
  //       a_polymarker.size(),a_polymarker.GetMarkerType());
  if (a_polymarker.size() == 0) return;
  auto currentNode = GetOrCreateNode();
  if (!currentNode) return;  // Node not available
 
  // Transformation
 {tools::sg::matrix* mtx = new tools::sg::matrix;
  G4Transform3D& elem = fObjectTransformation;
  mtx->mtx.value().set_matrix(elem(0,0),elem(0,1),elem(0,2),elem(0,3),
                              elem(1,0),elem(1,1),elem(1,2),elem(1,3),
                              elem(2,0),elem(2,1),elem(2,2),elem(2,3),
                                      0,        0,        0,        1);
  currentNode->add(mtx);}
 
 {const auto& colour = GetColour(a_polymarker);
  tools::sg::rgba* mat = new tools::sg::rgba();
  mat->color =
    tools::colorf(float(colour.GetRed()),
                  float(colour.GetGreen()),
                  float(colour.GetBlue()),
                  float(colour.GetAlpha()));
  currentNode->add(mat);}
 
  MarkerSizeType markerSizeType;
  G4double markerSize = GetMarkerSize(a_polymarker, markerSizeType);
 
  switch (a_polymarker.GetMarkerType()) {
    default:
    case G4Polymarker::dots:{
      tools::sg::draw_style* ds = new tools::sg::draw_style;
      ds->style = tools::sg::draw_points;
      ds->point_size = markerSize;
      ds->point_smooth = fpViewer->GetViewParameters().IsDotsSmooth()?true:false;
      currentNode->add(ds);
 
      tools::sg::vertices* vtxs = new tools::sg::vertices;
      vtxs->mode = tools::gl::points();
     {for (const auto& i : a_polymarker) {
        vtxs->add(float(i.x()),float(i.y()),float(i.z()));
      }}
      currentNode->add(vtxs);
    }break;
    case G4Polymarker::circles:{
     {tools::sg::markers* markers = new tools::sg::markers;
      G4double diameter = markerSize;  // OK for "screen-size" (the usual case)
      if (markerSizeType == G4VSceneHandler::world ) {
        const G4double scale = 200.;  // Roughly pixels per scene
        diameter *= fpScene->GetExtent().GetExtentRadius()/scale;
      }
      markers->size = diameter;
      markers->style = tools::sg::marker_circle_filled;
      for (const auto& i : a_polymarker) {
        markers->add(float(i.x()),float(i.y()),float(i.z()));
      }
      currentNode->add(markers);}
    }break;
  case G4Polymarker::squares:{
     {tools::sg::markers* markers = new tools::sg::markers;
      G4double side = markerSize;  // OK for "screen-size" (the usual case)
      if (markerSizeType == G4VSceneHandler::world ) {
        const G4double scale = 200.;  // Roughly pixels per scene
        side *= fpScene->GetExtent().GetExtentRadius()/scale;
      }
      markers->size = side;
      markers->style = tools::sg::marker_square_filled;
      for (const auto& i : a_polymarker) {
        markers->add(float(i.x()),float(i.y()),float(i.z()));
      }
      currentNode->add(markers);}
  }break;
  }
}

AddPrimitive() [6/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Square & a_square )

virtual

Implements G4VSceneHandler.

Definition at line 430 of file G4ToolsSGSceneHandler.cc.

{
  G4Polymarker oneSquare(a_square);
  oneSquare.push_back(a_square.GetPosition());
  oneSquare.SetMarkerType(G4Polymarker::squares);
  // Call this AddPrimitive to avoid re-doing sub-class code.
  G4ToolsSGSceneHandler::AddPrimitive(oneSquare);
}

AddPrimitive() [7/7]

void G4ToolsSGSceneHandler::AddPrimitive ( const G4Text & a_text )

virtual

Implements G4VSceneHandler.

Definition at line 346 of file G4ToolsSGSceneHandler.cc.

{
  //::printf("debug : G4ToolsSGSceneHandler::AddPrimitive(const G4Text&) : 000 : \"%s\"\n",a_text.GetText().c_str());
  //::printf("debug : G4ToolsSGSceneHandler::AddPrimitive(const G4Text&) : 2D ? %d\n",fProcessing2D);
  auto pos = a_text.GetPosition();
  //::printf("debug : Add Text : pos %g %g %g\n",pos.x(),pos.y(),pos.z());
 
  tools::sg::separator* parentNode = 0;
  if(fProcessing2D) {
    parentNode = new tools::sg::separator;
    if (fReadyForTransients) {
      fpTransient2DObjects.add(parentNode);
    } else {
      fpPersistent2DObjects.add(parentNode);
    }
 
    tools::sg::matrix* mtx = new tools::sg::matrix;
    mtx->set_translate(pos.x(),pos.y(),pos.z());
    parentNode->add(mtx);
 
  } else {
    parentNode = GetOrCreateNode();
    if (!parentNode) return;
 
    tools::sg::matrix* mtx = new tools::sg::matrix;
    auto elem = fObjectTransformation*G4Translate3D(pos);
    mtx->mtx.value().set_matrix(elem(0,0),elem(0,1),elem(0,2),elem(0,3),
                                elem(1,0),elem(1,1),elem(1,2),elem(1,3),
                                elem(2,0),elem(2,1),elem(2,2),elem(2,3),
                                        0,        0,        0,        1);
    parentNode->add(mtx);
  }
 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize(a_text, sizeType);
  size *= fMarkerScale;
  
 {const auto& colour = GetTextColour(a_text);
  tools::sg::rgba* mat = new tools::sg::rgba();
  mat->color =
    tools::colorf(float(colour.GetRed()),
                  float(colour.GetGreen()),
                  float(colour.GetBlue()),
                  float(colour.GetAlpha()));
  parentNode->add(mat);}
 
#ifdef TOOLS_USE_FREETYPE
  toolx::sg::text_freetype_marker* text = new toolx::sg::text_freetype_marker;
  text->add_embedded_font(tools::sg::font_lato_regular_ttf(),tools::font::lato_regular_ttf);
  text->font = tools::sg::font_lato_regular_ttf();
  text->front_face = tools::sg::winding_cw;
//text->modeling = tools::sg::font_pixmap; //problem with Qt/GL. It slows rendering!
#else
  tools::sg::text_hershey_marker* text = new tools::sg::text_hershey_marker;
//text->encoding.value(a_encoding);
#endif
  text->height = float(size); //pixels
  text->strings.add(a_text.GetText());
 {switch (a_text.GetLayout()) {
  default:
  case G4Text::left:
    text->hjust = tools::sg::left;
    break;
  case G4Text::centre:
    text->hjust = tools::sg::center;
    break;
  case G4Text::right:
    text->hjust = tools::sg::right;
    break;
  }}
//text->vjust.value(a_vjust);
  parentNode->add(text);
 
}

ClearStore()

void G4ToolsSGSceneHandler::ClearStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 194 of file G4ToolsSGSceneHandler.cc.

{
  fpTransient2DObjects.clear();
  fpPersistent2DObjects.clear();
  fpTransient3DObjects.clear();
  fpPersistent3DObjects.clear();
  EstablishBaseNodes();
}

ClearTransientStore()

void G4ToolsSGSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 205 of file G4ToolsSGSceneHandler.cc.

{
  fpTransient2DObjects.clear();
  fpTransient3DObjects.clear();
  if(fpViewer) {
    G4ToolsSG_viewer* tsg_viewer = dynamic_cast<G4ToolsSG_viewer*>(fpViewer);
    if(tsg_viewer) tsg_viewer->EmitWindowRender();
  }
}

CreateSG()

void G4ToolsSGSceneHandler::CreateSG ( )

protected

EstablishBaseNodes()

void G4ToolsSGSceneHandler::EstablishBaseNodes ( )

protected

Definition at line 107 of file G4ToolsSGSceneHandler.cc.

{
  // Physical volume objects for each world hang from POs
  G4TransportationManager* transportationManager = G4TransportationManager::GetTransportationManager ();
  size_t nWorlds = transportationManager->GetNoWorlds();
  std::vector<G4VPhysicalVolume*>::iterator iterWorld = transportationManager->GetWorldsIterator();
  fpPhysicalVolumeObjects.resize(nWorlds);
  for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
    G4VPhysicalVolume* _world = (*iterWorld);
    auto entity = new G4ToolsSGNode;
    fpPersistent3DObjects.add(entity);
    entity->SetPVNodeID(G4PhysicalVolumeModel::G4PhysicalVolumeNodeID(_world));
    fpPhysicalVolumeObjects[i] = entity;
  }
}

Referenced by ClearStore(), and G4ToolsSGSceneHandler().

GetOrCreateNode()

tools::sg::separator * G4ToolsSGSceneHandler::GetOrCreateNode ( )

protected

Definition at line 123 of file G4ToolsSGSceneHandler.cc.

{ // Retrieve or create a G4ToolsSGNode node suitable for next solid or primitive
 
  if (fReadyForTransients) {  // All transients hang from this node
    tools::sg::separator* sep = new tools::sg::separator;
    fpTransient3DObjects.add(sep);
    return sep;
  }
 
  auto* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
 
  if (!pPVModel) {  // Persistent objects (e.g., axes)
    tools::sg::separator* sep = new tools::sg::separator;
    fpPersistent3DObjects.add(sep);
    return sep;
  }
 
  // So this is a G4PhysicalVolumeModel
  typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
  typedef std::vector<PVNodeID> PVPath;
  //const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
  const PVPath& fullPVPath  = pPVModel->GetFullPVPath();
  //G4int currentDepth = pPVModel->GetCurrentDepth();
  //G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
  //G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
  //G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
  // Note: pCurrentMaterial may be zero (parallel world).
 
  // Find appropriate root
  const size_t nWorlds = fpPhysicalVolumeObjects.size();
  size_t iWorld = 0;
  for (; iWorld < nWorlds; ++iWorld) {
    if (fullPVPath[0].GetPhysicalVolume() ==
        fpPhysicalVolumeObjects[iWorld]->GetPVNodeID().GetPhysicalVolume()) break;
  }
  if (iWorld == nWorlds) {
    G4Exception("G4ToolsSGSceneHandler::GetOrCreateNode", "ToolsSG-0000", FatalException,
                "World mis-match - not possible(!?)");
  }
 
  // (Re-)establish pv path of root entity
  G4ToolsSGNode* _world = fpPhysicalVolumeObjects[iWorld];
  _world->SetPVNodeID(fullPVPath[0]);
 
  // Provide nodes as required - may be a new node or a pre-existing node
  G4ToolsSGNode* node = _world;  // Working variable - default to world
  const size_t depth = fullPVPath.size();
  size_t iDepth = 1;
  while (iDepth < depth) {
    const auto& children = node->children();
    const G4int nChildren = (G4int)children.size();
    G4int iChild = 0;
    G4ToolsSGNode* child = nullptr;
    for (; iChild < nChildren; ++iChild) {
      child = static_cast<G4ToolsSGNode*>(children[iChild]);
      if (child->GetPVNodeID() == fullPVPath[iDepth]) break;
    }
    if (iChild != nChildren) {  // Existing node found
      node = child;  // Must be the ancestor of new node (subsequent iteration)
    } else {
      // Add a new node as child of node
      G4ToolsSGNode* newNode = new G4ToolsSGNode;
      node->add(newNode);
      newNode->SetPVNodeID(fullPVPath[iDepth]);
      node = newNode;
    }
    ++iDepth;
  }
  return node;
}

Referenced by AddPrimitive(), AddPrimitive(), AddPrimitive(), AddPrimitive(), and AddPrimitive().

GetPersistent2DObjects()

tools::sg::separator & G4ToolsSGSceneHandler::GetPersistent2DObjects ( )

inline

Definition at line 65 of file G4ToolsSGSceneHandler.hh.

{return fpPersistent2DObjects;}

GetPersistent3DObjects()

tools::sg::separator & G4ToolsSGSceneHandler::GetPersistent3DObjects ( )

inline

Definition at line 67 of file G4ToolsSGSceneHandler.hh.

{return fpPersistent3DObjects;}

GetTransient2DObjects()

tools::sg::separator & G4ToolsSGSceneHandler::GetTransient2DObjects ( )

inline

Definition at line 64 of file G4ToolsSGSceneHandler.hh.

{return fpTransient2DObjects;}

GetTransient3DObjects()

tools::sg::separator & G4ToolsSGSceneHandler::GetTransient3DObjects ( )

inline

Definition at line 66 of file G4ToolsSGSceneHandler.hh.

{return fpTransient3DObjects;}

operator=()

G4ToolsSGSceneHandler & G4ToolsSGSceneHandler::operator= ( const G4ToolsSGSceneHandler & )

inlineprotected

Definition at line 75 of file G4ToolsSGSceneHandler.hh.

{return *this;}

SetMarkerScale()

void G4ToolsSGSceneHandler::SetMarkerScale

(

double

a_scale

)

Definition at line 344 of file G4ToolsSGSceneHandler.cc.

{fMarkerScale = a_scale;}

SetPlotterHistograms()

void G4ToolsSGSceneHandler::SetPlotterHistograms ( tools::sg::plots & a_plots )

protected

Definition at line 712 of file G4ToolsSGSceneHandler.cc.

                                                                      {
  a_plots.clear();
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
 
  for(const auto& [region, hid] : fRegionH1s) {
    tools::sg::plotter* _plotter = a_plots.find_plotter(region);
    if(_plotter) {
      std::ostringstream os;
      os << hid;
      std::string cmd("/analysis/h1/get ");
      cmd += std::string(os.str());
      auto keepControlVerbose = UI->GetVerboseLevel(); 
      UI->SetVerboseLevel(0);
      G4int status = UI->ApplyCommand(cmd.c_str());
      UI->SetVerboseLevel(keepControlVerbose);
      if(status==G4UIcommandStatus::fCommandSucceeded) {
        G4String hexString = UI->GetCurrentValues("/analysis/h1/get");
        if(hexString.size()) {
          void* ptr;
          std::istringstream is(hexString);
          is >> ptr;
          tools::histo::h1d* _h = (tools::histo::h1d*)ptr;
          tools::sg::plottable* p = new tools::sg::h1d2plot_cp(*_h);
          _plotter->add_plottable(p); //give ownership of p to sg::plotter.
        }
      } else {
        G4cerr <<
        "G4ToolsSGSceneHandler::SetPlotterHistograms: cannot get histogram - maybe doesn't exist?"
        "\n  Maybe this app does not do analysis at all?"
        << G4endl;
      }
    }
  }
 
  for(const auto& [region, hid] : fRegionH2s) {
    tools::sg::plotter* _plotter = a_plots.find_plotter(region);
    if(_plotter) {
      std::ostringstream os;
      os << hid;
      std::string cmd("/analysis/h2/get ");
      cmd += std::string(os.str());
      auto keepControlVerbose = UI->GetVerboseLevel();
      UI->SetVerboseLevel(0);
      G4int status = UI->ApplyCommand(cmd.c_str());
      UI->SetVerboseLevel(keepControlVerbose);
      if(status==G4UIcommandStatus::fCommandSucceeded) {
        G4String hexString = UI->GetCurrentValues("/analysis/h2/get");
        if(hexString.size()) {
          void* ptr;
          std::istringstream is(hexString);
          is >> ptr;
          tools::histo::h2d* _h = (tools::histo::h2d*)ptr;
          tools::sg::plottable* p = new tools::sg::h2d2plot_cp(*_h);
          _plotter->add_plottable(p); //give ownership of p to sg::plotter.
        }
      } else {
        G4cerr <<
        "G4ToolsSGSceneHandler::SetPlotterHistograms: cannot get histogram - maybe doesn't exist?"
        "\n  Maybe this app does not do analysis at all?"
        << G4endl;
      }
    }
  }
}

Referenced by AddPrimitive(), and TouchPlotters().

TouchPlotters()

void G4ToolsSGSceneHandler::TouchPlotters

(

tools::sg::node &

a_sg

)

Definition at line 809 of file G4ToolsSGSceneHandler.cc.

                                                           {
  tools::sg::search_action sa(G4cout);
  const tools::sg::search_action::paths_t& paths = tools::sg::find_paths<tools::sg::plots>(sa,a_sg);
  for(const auto& path : paths) {
    tools::sg::plots* _plots = tools::sg::tail<tools::sg::plots>(path);
    if(_plots) {
      SetPlotterHistograms(*_plots);
    }
  }
}

Member Data Documentation

fFreetypeNode

tools::sg::base_freetype* G4ToolsSGSceneHandler::fFreetypeNode

protected

Definition at line 94 of file G4ToolsSGSceneHandler.hh.

Referenced by AddPrimitive(), G4ToolsSGSceneHandler(), and ~G4ToolsSGSceneHandler().

fMarkerScale

double G4ToolsSGSceneHandler::fMarkerScale

protected

Definition at line 95 of file G4ToolsSGSceneHandler.hh.

Referenced by AddPrimitive(), G4ToolsSGSceneHandler(), and SetMarkerScale().

fpPersistent2DObjects

tools::sg::separator G4ToolsSGSceneHandler::fpPersistent2DObjects

protected

Definition at line 87 of file G4ToolsSGSceneHandler.hh.

Referenced by AddPrimitive(), AddPrimitive(), ClearStore(), GetPersistent2DObjects(), and ~G4ToolsSGSceneHandler().

fpPersistent3DObjects

tools::sg::separator G4ToolsSGSceneHandler::fpPersistent3DObjects

protected

Definition at line 90 of file G4ToolsSGSceneHandler.hh.

Referenced by ClearStore(), EstablishBaseNodes(), GetOrCreateNode(), GetPersistent3DObjects(), and ~G4ToolsSGSceneHandler().

fpPhysicalVolumeObjects

std::vector<G4ToolsSGNode*> G4ToolsSGSceneHandler::fpPhysicalVolumeObjects

protected

Definition at line 92 of file G4ToolsSGSceneHandler.hh.

Referenced by EstablishBaseNodes(), and GetOrCreateNode().

fpTransient2DObjects

tools::sg::separator G4ToolsSGSceneHandler::fpTransient2DObjects

protected

Definition at line 86 of file G4ToolsSGSceneHandler.hh.

Referenced by AddPrimitive(), AddPrimitive(), ClearStore(), ClearTransientStore(), GetTransient2DObjects(), and ~G4ToolsSGSceneHandler().

fpTransient3DObjects

tools::sg::separator G4ToolsSGSceneHandler::fpTransient3DObjects

protected

Definition at line 89 of file G4ToolsSGSceneHandler.hh.

Referenced by ClearStore(), ClearTransientStore(), GetOrCreateNode(), GetTransient3DObjects(), and ~G4ToolsSGSceneHandler().

fRegionH1s

std::vector<Region_h1> G4ToolsSGSceneHandler::fRegionH1s

protected

Definition at line 99 of file G4ToolsSGSceneHandler.hh.

Referenced by AddPrimitive(), and SetPlotterHistograms().

fRegionH2s

std::vector<Region_h2> G4ToolsSGSceneHandler::fRegionH2s

protected

Definition at line 100 of file G4ToolsSGSceneHandler.hh.

Referenced by AddPrimitive(), and SetPlotterHistograms().

fSceneIdCount

G4int G4ToolsSGSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 84 of file G4ToolsSGSceneHandler.hh.

Referenced by G4ToolsSGSceneHandler().

---

The documentation for this class was generated from the following files:

• G4ToolsSGSceneHandler.hh
• G4ToolsSGSceneHandler.cc