G4VtkQtSceneHandler Class Reference

#include <G4VtkQtSceneHandler.hh>

Inheritance diagram for G4VtkQtSceneHandler:

Public Types
enum	MarkerSizeType { world , screen }

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

Protected Member Functions
virtual G4DisplacedSolid *	CreateCutawaySolid ()
virtual G4DisplacedSolid *	CreateSectionSolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
virtual void	ProcessScene ()
virtual void	RequestPrimitives (const G4VSolid &solid)

Protected Attributes
std::map< std::size_t, vtkSmartPointer< vtkPoints > >	circleDataMap
std::map< std::size_t, vtkSmartPointer< vtkVertexGlyphFilter > >	circleFilterMap
std::map< std::size_t, vtkSmartPointer< vtkActor > >	circlePolyDataActorMap
std::map< std::size_t, vtkSmartPointer< vtkPolyData > >	circlePolyDataMap
std::map< std::size_t, vtkSmartPointer< vtkPolyDataMapper > >	circlePolyDataMapperMap
std::map< std::size_t, const G4VisAttributes * >	circleVisAttributesMap
const G4Transform3D	fIdentityTransformation
G4bool	fMarkForClearingTransientStore
G4String	fName
G4int	fNestingDepth
G4Transform3D	fObjectTransformation
G4VModel *	fpModel
G4bool	fProcessing2D
G4bool	fProcessingSolid
G4Scene *	fpScene
G4VViewer *	fpViewer
const G4VisAttributes *	fpVisAttribs
G4bool	fReadyForTransients
const G4int	fSceneHandlerId
G4VGraphicsSystem &	fSystem
G4bool	fTransientsDrawnThisEvent
G4bool	fTransientsDrawnThisRun
G4int	fViewCount
G4ViewerList	fViewerList
std::map< std::size_t, vtkSmartPointer< vtkActor > >	instanceActorMap
std::map< std::size_t, vtkSmartPointer< vtkDoubleArray > >	instanceColoursMap
std::map< std::size_t, vtkSmartPointer< vtkPolyData > >	instancePolyDataMap
std::map< std::size_t, vtkSmartPointer< vtkPoints > >	instancePositionMap
std::map< std::size_t, vtkSmartPointer< vtkDoubleArray > >	instanceRotationMap
std::map< std::size_t, vtkSmartPointer< vtkTensorGlyphColor > >	instanceTensorGlyphMap
std::map< std::size_t, vtkSmartPointer< vtkPoints > >	polyhedronDataMap
std::map< std::size_t, std::size_t >	polyhedronPolyDataCountMap
std::map< std::size_t, vtkSmartPointer< vtkPolyData > >	polyhedronPolyDataMap
std::map< std::size_t, vtkSmartPointer< vtkCellArray > >	polyhedronPolyMap
std::map< std::size_t, const G4VisAttributes * >	polyhedronVisAttributesMap
std::map< std::size_t, vtkSmartPointer< vtkPoints > >	polylineDataMap
std::map< std::size_t, vtkSmartPointer< vtkCellArray > >	polylineLineMap
std::map< std::size_t, vtkSmartPointer< vtkActor > >	polylinePolyDataActorMap
std::map< std::size_t, vtkSmartPointer< vtkPolyData > >	polylinePolyDataMap
std::map< std::size_t, vtkSmartPointer< vtkPolyDataMapper > >	polylinePolyDataMapperMap
std::map< std::size_t, const G4VisAttributes * >	polylineVisAttributesMap
std::map< std::size_t, vtkSmartPointer< vtkPoints > >	squareDataMap
std::map< std::size_t, vtkSmartPointer< vtkVertexGlyphFilter > >	squareFilterMap
std::map< std::size_t, vtkSmartPointer< vtkActor > >	squarePolyDataActorMap
std::map< std::size_t, vtkSmartPointer< vtkPolyData > >	squarePolyDataMap
std::map< std::size_t, vtkSmartPointer< vtkPolyDataMapper > >	squarePolyDataMapperMap
std::map< std::size_t, const G4VisAttributes * >	squareVisAttributesMap

Static Protected Attributes
static G4int	fSceneIdCount = 0

Friends
class	G4VtkQtViewer

Detailed Description

Definition at line 38 of file G4VtkQtSceneHandler.hh.

Member Enumeration Documentation

MarkerSizeType

enum G4VSceneHandler::MarkerSizeType

inherited

Enumerator
world
screen

Definition at line 58 of file G4VSceneHandler.hh.

{world, screen};

Constructor & Destructor Documentation

G4VtkQtSceneHandler()

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

Definition at line 46 of file G4VtkQtSceneHandler.cc.

                                                               :
  G4VtkSceneHandler(system, name)
{}

~G4VtkQtSceneHandler()

G4VtkQtSceneHandler::~G4VtkQtSceneHandler ( )

virtual

Definition at line 51 of file G4VtkQtSceneHandler.cc.

{}

Member Function Documentation

AddCompound() [1/6]

void G4VtkSceneHandler::AddCompound ( const G4Mesh &  mesh )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 763 of file G4VtkSceneHandler.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkSceneHandler::AddCompound" << G4endl;
#endif 
 
  if(mesh.GetMeshType() != G4Mesh::rectangle || mesh.GetMeshDepth() != 3)
  {
    G4VSceneHandler::AddCompound(mesh);
  }
 
  auto container = mesh.GetContainerVolume();
  auto rep1 = container->GetLogicalVolume()->GetDaughter(0);
  auto rep2 = rep1->GetLogicalVolume()->GetDaughter(0);
  auto rep3 = rep2->GetLogicalVolume()->GetDaughter(0);
 
  EAxis    rep1_axis, rep2_axis, rep3_axis;
  G4int    rep1_nReplicas, rep2_nReplicas, rep3_nReplicas;
  G4double rep1_width, rep2_width, rep3_width;
  G4double rep1_offset, rep2_offset, rep3_offset;
  G4bool   rep1_consuming, rep2_consuming, rep3_consuming;
 
  rep1->GetReplicationData(rep1_axis,rep1_nReplicas, rep1_width, rep1_offset, rep1_consuming);
  rep2->GetReplicationData(rep2_axis,rep2_nReplicas, rep2_width, rep2_offset, rep2_consuming);
  rep3->GetReplicationData(rep3_axis,rep3_nReplicas, rep3_width, rep3_offset, rep3_consuming);
 
  // Instantiate a temporary G4PhysicalVolumeModel
  G4ModelingParameters tmpMP;
  tmpMP.SetCulling(false);            // This avoids drawing transparent...
  tmpMP.SetCullingInvisible(false);   // ... or invisble volumes.
  const G4bool useFullExtent = false;  // To avoid calculating the extent
 
  G4PhysicalVolumeModel tmpPVModel(container, G4PhysicalVolumeModel::UNLIMITED,
                                   G4Transform3D(), &tmpMP, useFullExtent);
 
  // Instantiate a pseudo scene so that we can make a "private" descent and fill vtkImageData
  vtkSmartPointer<vtkImageData> imagedata = vtkSmartPointer<vtkImageData>::New();
  imagedata->SetDimensions(rep1_nReplicas+1,rep2_nReplicas+1,rep3_nReplicas+1);
  imagedata->SetSpacing(rep1_width,rep2_width,rep2_width);
  imagedata->SetOrigin(0,0,0);
  imagedata->AllocateScalars(VTK_DOUBLE, 1);
 
  G4double halfX = 0., halfY = 0., halfZ = 0.;
  struct PseudoScene : public G4PseudoScene
  {
    PseudoScene(
      G4PhysicalVolumeModel* pvModel,  // input...the following are output
      vtkImageData *vtkId,
      G4int nx, G4int ny, G4int nz,
      G4double& halfX, G4double& halfY, G4double& halfZ) : fpPVModel(pvModel)
      , fVtkId(vtkId)
      , fNx(nx)
      , fNy(ny)
      , fNz(nz)
      , fHalfX(halfX)
      , fHalfY(halfY)
      , fHalfZ(halfZ)
    {}
    using G4PseudoScene::AddSolid;  // except for...
    void AddSolid(const G4Box& box)
    {
      const G4Colour& colour = fpPVModel->GetCurrentLV()->GetVisAttributes()->GetColour();
      // G4double density = fpPVModel->GetCurrentLV()->GetMaterial()->GetDensity();
      const G4ThreeVector& position = fpCurrentObjectTransformation->getTranslation();
      fHalfX = box.GetXHalfLength();
      fHalfY = box.GetYHalfLength();
      fHalfZ = box.GetZHalfLength();
      fVtkId->SetScalarComponentFromDouble(int(position.x()/(2*fHalfX))+fNx,
                                           int(position.y()/(2*fHalfY))+fNy,
                                           int(position.z()/(2*fHalfZ))+fNz,
                                           0,
                                           (colour.GetRed() + colour.GetBlue() + colour.GetGreen())/3.0);
    }
    G4PhysicalVolumeModel* fpPVModel;
    vtkImageData *fVtkId;
    G4int fNx, fNy, fNz;
    G4double &fHalfX, &fHalfY, &fHalfZ;
  }
  // construct the pseudoScene
  pseudoScene(&tmpPVModel, imagedata, rep1_nReplicas, rep2_nReplicas, rep3_nReplicas, halfX, halfY, halfZ);
 
  // Make private descent into the nested parameterisation
  tmpPVModel.DescribeYourselfTo(pseudoScene);
 
  vtkSmartPointer<vtkOpenGLGPUVolumeRayCastMapper> volumeMapper = vtkSmartPointer<vtkOpenGLGPUVolumeRayCastMapper>::New();
  volumeMapper->SetInputData(imagedata);
 
  vtkNew<vtkVolume> volume;
  volume->SetMapper(volumeMapper);
 
  vtkSmartPointer<vtkMatrix4x4> vtkMatrix = vtkSmartPointer<vtkMatrix4x4>::New();
 
  vtkMatrix->SetElement(0,0,fObjectTransformation.xx());
  vtkMatrix->SetElement(0,1,fObjectTransformation.xy());
  vtkMatrix->SetElement(0,2,fObjectTransformation.xz());
 
  vtkMatrix->SetElement(1,0,fObjectTransformation.yx());
  vtkMatrix->SetElement(1,1,fObjectTransformation.yy());
  vtkMatrix->SetElement(1,2,fObjectTransformation.yz());
 
  vtkMatrix->SetElement(2,0,fObjectTransformation.zx());
  vtkMatrix->SetElement(2,1,fObjectTransformation.zy());
  vtkMatrix->SetElement(2,2,fObjectTransformation.zz());
 
  vtkMatrix->SetElement(3,0, fObjectTransformation.dx());
  vtkMatrix->SetElement(3,1, fObjectTransformation.dy());
  vtkMatrix->SetElement(3,2, fObjectTransformation.dz());
  vtkMatrix->SetElement(3,3, 1);
 
  volume->SetUserMatrix(vtkMatrix);
 
  auto *pVtkViewer = dynamic_cast<G4VtkViewer *>(fpViewer);
  pVtkViewer->renderer->AddVolume(volume);
}

References G4VSceneHandler::AddCompound(), G4VtkSceneHandler::AddSolid(), G4PseudoScene::AddSolid(), G4PhysicalVolumeModel::DescribeYourselfTo(), HepGeom::Transform3D::dx(), HepGeom::Transform3D::dy(), HepGeom::Transform3D::dz(), G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4cout, G4endl, G4Colour::GetBlue(), G4Colour::GetColour(), G4Mesh::GetContainerVolume(), G4LogicalVolume::GetDaughter(), G4Colour::GetGreen(), G4VPhysicalVolume::GetLogicalVolume(), G4Mesh::GetMeshDepth(), G4Mesh::GetMeshType(), G4Colour::GetRed(), G4VPhysicalVolume::GetReplicationData(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), G4Mesh::rectangle, G4VtkViewer::renderer, G4ModelingParameters::SetCulling(), G4ModelingParameters::SetCullingInvisible(), G4PhysicalVolumeModel::UNLIMITED, HepGeom::Transform3D::xx(), HepGeom::Transform3D::xy(), HepGeom::Transform3D::xz(), HepGeom::Transform3D::yx(), HepGeom::Transform3D::yy(), HepGeom::Transform3D::yz(), HepGeom::Transform3D::zx(), HepGeom::Transform3D::zy(), and HepGeom::Transform3D::zz().

AddCompound() [2/6]

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

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 340 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(MeshScoreMap::const_iterator i = scoreMap.begin();
        i != scoreMap.end(); ++i) {
      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();
  }
}

References G4VScoringMesh::DrawMesh(), G4cout, G4endl, G4ScoringManager::GetMesh(), G4VSceneHandler::GetName(), G4ScoringManager::GetNumberOfMesh(), G4VScoringMesh::GetScoreMap(), G4ScoringManager::GetScoringManagerIfExist(), and G4VScoringMesh::IsActive().

AddCompound() [3/6]

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

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 383 of file G4VSceneHandler.cc.

                                                                       {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(MeshScoreMap::const_iterator i = scoreMap.begin();
        i != scoreMap.end(); ++i) {
      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();
  }
}

References G4VScoringMesh::DrawMesh(), G4cout, G4endl, G4ScoringManager::GetMesh(), G4ScoringManager::GetNumberOfMesh(), G4VScoringMesh::GetScoreMap(), G4ScoringManager::GetScoringManagerIfExist(), and G4VScoringMesh::IsActive().

AddCompound() [4/6]

void G4VSceneHandler::AddCompound ( const G4VDigi &  digi )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 335 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 )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 330 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 )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 318 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.");
  }
}

References G4VTrajectory::DrawTrajectory(), FatalException, G4VSceneHandler::fpModel, and G4Exception().

Referenced by G4Qt3DSceneHandler::AddCompound(), G4VtkSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddCompound(), and G4GMocrenFileSceneHandler::AddCompound().

AddPrimitive() [1/7]

void G4VtkSceneHandler::AddPrimitive ( const G4Circle &  circle )

virtualinherited

Implements G4VSceneHandler.

Definition at line 285 of file G4VtkSceneHandler.cc.

                                                           {
 
  MarkerSizeType sizeType;
  G4double size= GetMarkerSize(circle, sizeType);
  if(fProcessing2D) {sizeType = screen;}
  else              {sizeType = world;}
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes *pVA = fpViewer->GetApplicableVisAttributes(circle.GetVisAttributes());
  G4Color colour = pVA->GetColour();
  G4double opacity = colour.GetAlpha();
  // G4bool isVisible = pVA->IsVisible();
 
#ifdef G4VTKDEBUG
  G4cout << "=================================" << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Circle& circle) called>           " << " radius:" << size << " sizeType:" << sizeType << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Circle& circle) called>   colour: " << colour.GetRed() << " " << colour.GetBlue() << " " << colour.GetGreen()  << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Circle& circle) called>    alpha: " << colour.GetAlpha() << G4endl;
#endif
 
  if (sizeType == world) {
    std::size_t hash = std::hash<G4VisAttributes>{}(*pVA);
    if (circleVisAttributesMap.find(hash) == circleVisAttributesMap.end()) {
      circleVisAttributesMap.insert(std::pair<std::size_t, const G4VisAttributes *>(hash, pVA));
 
      vtkSmartPointer<vtkPoints> data = vtkSmartPointer<vtkPoints>::New();
      vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
      vtkSmartPointer<vtkVertexGlyphFilter> filter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
      vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
      vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
 
      polyData->SetPoints(data);
      filter->SetInputData(polyData);
      mapper->SetInputConnection(filter->GetOutputPort());
      actor->SetMapper(mapper);
 
      // Setup actor and mapper
      actor->GetProperty()->SetColor(colour.GetRed(), colour.GetGreen(), colour.GetBlue());
      actor->GetProperty()->SetOpacity(opacity);
      actor->SetVisibility(1);
      actor->GetProperty()->SetRenderPointsAsSpheres(true);
      actor->GetProperty()->SetPointSize(size*5);
 
      auto *pVtkViewer = dynamic_cast<G4VtkViewer *>(fpViewer);
      pVtkViewer->renderer->AddActor(actor);
 
      circleDataMap.insert(std::pair<std::size_t,vtkSmartPointer<vtkPoints>>(hash, data));
      circlePolyDataMap.insert(std::pair<std::size_t, vtkSmartPointer < vtkPolyData>>(hash, polyData));
      circleFilterMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkVertexGlyphFilter>>(hash, filter));
      circlePolyDataMapperMap.insert(std::pair<std::size_t, vtkSmartPointer < vtkPolyDataMapper>>(hash, mapper));
      circlePolyDataActorMap.insert(std::pair<std::size_t, vtkSmartPointer < vtkActor>>(hash, actor));
    }
 
    // Data data point
    const CLHEP::HepRotation rot = fObjectTransformation.getRotation();
    G4Point3D posPrime = rot*circle.GetPosition();
    circleDataMap[hash]->InsertNextPoint(fObjectTransformation.dx() + posPrime.x(),
                                         fObjectTransformation.dy() + posPrime.y(),
                                         fObjectTransformation.dz() + posPrime.z());
  }
  else if (sizeType == screen) {
 
  }
}

References G4VtkSceneHandler::circleDataMap, G4VtkSceneHandler::circleFilterMap, G4VtkSceneHandler::circlePolyDataActorMap, G4VtkSceneHandler::circlePolyDataMap, G4VtkSceneHandler::circlePolyDataMapperMap, G4VtkSceneHandler::circleVisAttributesMap, HepGeom::Transform3D::dx(), HepGeom::Transform3D::dy(), HepGeom::Transform3D::dz(), G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fProcessing2D, G4VSceneHandler::fpViewer, G4cout, G4endl, G4Colour::GetAlpha(), G4VViewer::GetApplicableVisAttributes(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4Colour::GetGreen(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4Colour::GetRed(), HepGeom::Transform3D::getRotation(), G4Visible::GetVisAttributes(), hash(), G4VtkViewer::renderer, G4VSceneHandler::screen, G4VSceneHandler::world, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

AddPrimitive() [2/7]

void G4VSceneHandler::AddPrimitive ( const G4Plotter &  )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VTreeSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 501 of file G4VSceneHandler.cc.

                                                    {
  G4cerr << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
  G4cerr << "  Open a plotter-aware graphics system or remove plotter with" << G4endl;
  G4cerr << "  /vis/scene/removeModel Plotter" << G4endl;
}

References G4VSceneHandler::fSystem, G4cerr, G4endl, and G4VGraphicsSystem::GetName().

AddPrimitive() [3/7]

void G4VtkSceneHandler::AddPrimitive ( const G4Polyhedron &  polyhedron )

virtualinherited

Implements G4VSceneHandler.

Definition at line 417 of file G4VtkSceneHandler.cc.

                                                                   {
  AddPrimitiveTensorGlyph(polyhedron);
}

References G4VtkSceneHandler::AddPrimitiveTensorGlyph().

AddPrimitive() [4/7]

void G4VtkSceneHandler::AddPrimitive ( const G4Polyline &  polyline )

virtualinherited

Implements G4VSceneHandler.

Definition at line 144 of file G4VtkSceneHandler.cc.

                                                               {
 
  G4VSceneHandler::MarkerSizeType sizeType;
  // GetMarkerSize(text,sizeType);
  if(fProcessing2D) {sizeType = screen;}
  else              {sizeType = world;}
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA = fpViewer -> GetApplicableVisAttributes(polyline.GetVisAttributes());
  G4Color  colour            = pVA->GetColour();
  G4double opacity           = colour.GetAlpha();
  G4double lineWidth         = pVA->GetLineWidth();
 
#ifdef G4VTKDEBUG
  G4cout << "=================================" << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called>             vis hash: " << sizeType << " " << std::hash<G4VisAttributes>{}(*pVA) << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called>             sizeType: " << sizeType << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called>            isVisible: " << pVA->IsVisible() << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called> isDaughtersInvisible: " << pVA->IsDaughtersInvisible() << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called>               colour: " << colour.GetRed() << " " << colour.GetGreen() << " " << colour.GetBlue()  << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called>                alpha: " << colour.GetAlpha() << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyline& polyline) called>            lineWidth: " << lineWidth << G4endl;
#endif
 
  if(sizeType == world) {
    std::size_t hash = std::hash<G4VisAttributes>{}(*pVA);
    if (polylineVisAttributesMap.find(hash) == polylineVisAttributesMap.end()) {
      polylineVisAttributesMap.insert(std::pair<std::size_t, const G4VisAttributes *>(hash, pVA));
 
      vtkSmartPointer <vtkPoints> data = vtkSmartPointer<vtkPoints>::New();
      vtkSmartPointer <vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
      vtkSmartPointer <vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
      vtkSmartPointer <vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
      vtkSmartPointer <vtkActor> actor = vtkSmartPointer<vtkActor>::New();
 
      polyData->SetPoints(data);
      polyData->SetLines(lines);
      mapper->SetInputData(polyData);
      actor->SetMapper(mapper);
 
      // Setup actor and mapper
      actor->GetProperty()->SetLineWidth(lineWidth);
      actor->GetProperty()->SetColor(colour.GetRed(), colour.GetGreen(),
                                     colour.GetBlue());
      actor->GetProperty()->SetOpacity(opacity);
      actor->SetVisibility(1);
      // actor->GetProperty()->BackfaceCullingOn();
      // actor->GetProperty()->FrontfaceCullingOn();
 
      auto pVtkViewer = dynamic_cast<G4VtkViewer*>(fpViewer);
      pVtkViewer->renderer->AddActor(actor);
 
      polylineDataMap.insert(
        std::pair<std::size_t, vtkSmartPointer<vtkPoints>>(hash, data));
      polylineLineMap.insert(
        std::pair<std::size_t, vtkSmartPointer<vtkCellArray>>(hash, lines));
      polylinePolyDataMap.insert(
        std::pair<std::size_t, vtkSmartPointer<vtkPolyData>>(hash, polyData));
      polylinePolyDataMapperMap.insert(
        std::pair<std::size_t, vtkSmartPointer<vtkPolyDataMapper>>(hash,
                                                                   mapper));
      polylinePolyDataActorMap.insert(
        std::pair<std::size_t, vtkSmartPointer<vtkActor>>(hash, actor));
    }
 
    // Data data
    const size_t nLines = polyline.size();
 
    for (size_t i = 0; i < nLines; ++i) {
      auto id = polylineDataMap[hash]->InsertNextPoint(polyline[i].x(),
                                                       polyline[i].y(),
                                                       polyline[i].z());
      if (i < nLines - 1) {
        vtkSmartPointer <vtkLine> line = vtkSmartPointer<vtkLine>::New();
        line->GetPointIds()->SetId(0, id);
        line->GetPointIds()->SetId(1, id + 1);
        polylineLineMap[hash]->InsertNextCell(line);
      }
    }
  }
  else if (sizeType == screen ) {
 
  }
}

References G4VSceneHandler::fProcessing2D, G4VSceneHandler::fpViewer, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4Colour::GetGreen(), G4VisAttributes::GetLineWidth(), G4Colour::GetRed(), G4Visible::GetVisAttributes(), hash(), G4VisAttributes::IsDaughtersInvisible(), G4VisAttributes::IsVisible(), G4VtkSceneHandler::polylineDataMap, G4VtkSceneHandler::polylineLineMap, G4VtkSceneHandler::polylinePolyDataActorMap, G4VtkSceneHandler::polylinePolyDataMap, G4VtkSceneHandler::polylinePolyDataMapperMap, G4VtkSceneHandler::polylineVisAttributesMap, G4VtkViewer::renderer, G4VSceneHandler::screen, and G4VSceneHandler::world.

AddPrimitive() [5/7]

void G4VtkSceneHandler::AddPrimitive ( const G4Polymarker &  polymarker )

inlinevirtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 97 of file G4VtkSceneHandler.hh.

  {
#ifdef G4VTKDEBUG
    G4cout << "=================================" << G4endl;
    G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polymarker& polymarker) called." << G4endl;
#endif
    G4VSceneHandler::AddPrimitive (polymarker);
  }

References G4VSceneHandler::AddPrimitive(), G4cout, and G4endl.

AddPrimitive() [6/7]

void G4VtkSceneHandler::AddPrimitive ( const G4Square &  square )

virtualinherited

Implements G4VSceneHandler.

Definition at line 350 of file G4VtkSceneHandler.cc.

                                                           {
 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize (square, sizeType);
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA = fpViewer -> GetApplicableVisAttributes(square.GetVisAttributes());
  G4Color colour    = pVA->GetColour();
  G4double opacity  = colour.GetAlpha();
  // G4bool  isVisible = pVA->IsVisible();
 
  // Draw in world coordinates.
  vtkSmartPointer<vtkRegularPolygonSource> polygonSource = vtkSmartPointer<vtkRegularPolygonSource>::New();
  polygonSource->SetNumberOfSides(4);
  polygonSource->SetRadius(size);
 
 
#ifdef G4VTKDEBUG
  G4cout << "=================================" << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Square& square) called" << G4endl;
  G4cout << square.GetPosition().x() << " " << square.GetPosition().y() << " " << square.GetPosition().z() << G4endl;
  //PrintThings();
#endif
 
  if (sizeType == world) {
    std::size_t hash = std::hash<G4VisAttributes>{}(*pVA);
    if (squareVisAttributesMap.find(hash) == squareVisAttributesMap.end()) {
      squareVisAttributesMap.insert(std::pair<std::size_t, const G4VisAttributes *>(hash, pVA));
 
      vtkSmartPointer<vtkPoints>              data = vtkSmartPointer<vtkPoints>::New();
      vtkSmartPointer<vtkPolyData>        polyData = vtkSmartPointer<vtkPolyData>::New();
      vtkSmartPointer<vtkVertexGlyphFilter> filter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
      vtkSmartPointer<vtkPolyDataMapper>    mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
      vtkSmartPointer<vtkActor>              actor = vtkSmartPointer<vtkActor>::New();
 
      polyData->SetPoints(data);
      filter->SetInputData(polyData);
      mapper->SetInputConnection(filter->GetOutputPort());
      actor->SetMapper(mapper);
 
      // Setup actor and mapper
      actor->GetProperty()->SetColor(colour.GetRed(), colour.GetGreen(), colour.GetBlue());
      actor->GetProperty()->SetOpacity(opacity);
      actor->SetVisibility(1);
      actor->GetProperty()->SetPointSize(size*5);
 
      auto *pVtkViewer = dynamic_cast<G4VtkViewer *>(fpViewer);
      pVtkViewer->renderer->AddActor(actor);
 
      squareDataMap.insert(std::pair<std::size_t,vtkSmartPointer<vtkPoints>>(hash, data));
      squarePolyDataMap.insert(std::pair<std::size_t, vtkSmartPointer < vtkPolyData>>(hash, polyData));
      squareFilterMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkVertexGlyphFilter>>(hash, filter));
      squarePolyDataMapperMap.insert(std::pair<std::size_t, vtkSmartPointer < vtkPolyDataMapper>>(hash, mapper));
      squarePolyDataActorMap.insert(std::pair<std::size_t, vtkSmartPointer < vtkActor>>(hash, actor));
    }
 
    // Data data point
    const CLHEP::HepRotation rot = fObjectTransformation.getRotation();
    G4Point3D posPrime = rot*square.GetPosition();
    squareDataMap[hash]->InsertNextPoint(fObjectTransformation.dx() + posPrime.x(),
                                         fObjectTransformation.dy() + posPrime.y(),
                                         fObjectTransformation.dz() + posPrime.z());
  }
  else if (sizeType == screen) {
 
  }
}

References HepGeom::Transform3D::dx(), HepGeom::Transform3D::dy(), HepGeom::Transform3D::dz(), G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4Colour::GetGreen(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4Colour::GetRed(), HepGeom::Transform3D::getRotation(), G4Visible::GetVisAttributes(), hash(), G4VtkViewer::renderer, G4VSceneHandler::screen, G4VtkSceneHandler::squareDataMap, G4VtkSceneHandler::squareFilterMap, G4VtkSceneHandler::squarePolyDataActorMap, G4VtkSceneHandler::squarePolyDataMap, G4VtkSceneHandler::squarePolyDataMapperMap, G4VtkSceneHandler::squareVisAttributesMap, G4VSceneHandler::world, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

AddPrimitive() [7/7]

void G4VtkSceneHandler::AddPrimitive ( const G4Text &  text )

virtualinherited

Implements G4VSceneHandler.

Definition at line 229 of file G4VtkSceneHandler.cc.

                                                       {
 
  G4VSceneHandler::MarkerSizeType sizeType;
  if(fProcessing2D) {sizeType = screen;}
  else              {sizeType = world;}
 
  const G4VisAttributes* pVA = fpViewer -> GetApplicableVisAttributes(text.GetVisAttributes());
  G4Color colour             = pVA->GetColour();
  G4double opacity           = colour.GetAlpha();
  // G4Text::Layout layout      = text.GetLayout();
  // G4double xOffset           = text.GetXOffset();
  // G4double yOffset           = text.GetYOffset();
 
  double x = text.GetPosition().x();
  double y = text.GetPosition().y();
  double z = text.GetPosition().z();
 
#ifdef G4VTKDEBUG
  G4cout << "=================================" << G4endl;
  G4cout << "G4VtkSeneHandler::AddPrimitive(const G4Text& text) called>     text: " << text.GetText() << " sizeType:" << sizeType << " " << fProcessing2D << G4endl;
  G4cout << "G4VtkSeneHandler::AddPrimitive(const G4Text& text) called>   colour: " << colour.GetRed() << " " << colour.GetBlue() << " " << colour.GetGreen()  << G4endl;
  G4cout << "G4VtkSeneHandler::AddPrimitive(const G4Text& text) called>    alpha: " << colour.GetAlpha() << G4endl;
  G4cout << "G4VtkSeneHandler::AddPrimitive(const G4Text& text) called> position: " << x << " " << y << " " << z << G4endl;
#endif
 
  switch (sizeType) {
    default:
    case (screen): {
      vtkSmartPointer <vtkTextActor> actor = vtkSmartPointer<vtkTextActor>::New();
      actor->SetInput(text.GetText().c_str());
      actor->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport();
      // actor->SetTextScaleModeToViewport();
      actor->SetPosition((x+1.)/2.0, (y+1.)/2.);
      actor->GetTextProperty()->SetFontSize(text.GetScreenSize());
      actor->GetTextProperty()->SetColor(colour.GetRed(), colour.GetBlue(), colour.GetGreen());
      actor->GetTextProperty()->SetOpacity(opacity);
 
      auto *pVtkViewer = dynamic_cast<G4VtkViewer *>(fpViewer);
      pVtkViewer->renderer->AddActor(actor);
      break;
    }
    case world: {
      vtkSmartPointer <vtkBillboardTextActor3D> actor = vtkSmartPointer<vtkBillboardTextActor3D>::New();
      actor->SetInput(text.GetText().c_str());
      actor->SetPosition(x, y, z);
      actor->GetTextProperty()->SetFontSize(text.GetScreenSize());
      actor->GetTextProperty()->SetColor(colour.GetRed(), colour.GetBlue(), colour.GetGreen());
      actor->GetTextProperty()->SetOpacity(opacity);
 
      auto *pVtkViewer = dynamic_cast<G4VtkViewer*>(fpViewer);
      pVtkViewer->renderer->AddActor(actor);
      break;
    }
  }
}

References G4VSceneHandler::fProcessing2D, G4VSceneHandler::fpViewer, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4Colour::GetGreen(), G4VMarker::GetPosition(), G4Colour::GetRed(), G4VMarker::GetScreenSize(), G4Text::GetText(), G4Visible::GetVisAttributes(), G4VtkViewer::renderer, G4VSceneHandler::screen, G4VSceneHandler::world, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

AddPrimitiveBakedTransform()

void G4VtkSceneHandler::AddPrimitiveBakedTransform ( const G4Polyhedron &  polyhedron )

inherited

Definition at line 589 of file G4VtkSceneHandler.cc.

{
  // only have a single polydata object for each LV but bake in the PV
  // transformation so clippers and cutters can be implemented
  AddPrimitiveTensorGlyph(polyhedron);
}

References G4VtkSceneHandler::AddPrimitiveTensorGlyph().

AddPrimitiveTensorGlyph()

void G4VtkSceneHandler::AddPrimitiveTensorGlyph ( const G4Polyhedron &  polyhedron )

inherited

Definition at line 421 of file G4VtkSceneHandler.cc.

                                                                              {
  // only have a single polydata object for each LV but bake in the PV
  // transformation so clippers and cutters can be implemented
 
  //Get colour, etc..
  if (polyhedron.GetNoFacets() == 0) {return;}
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes *pVA = fpViewer->GetApplicableVisAttributes(polyhedron.GetVisAttributes());
  G4Color                       colour = pVA->GetColour();
  // G4bool                     isVisible = pVA->IsVisible();
  // G4double                   lineWidth = pVA->GetLineWidth();
  // G4VisAttributes::LineStyle lineStyle = pVA->GetLineStyle();
 
  // G4double lineWidthScale = drawing_style.GetGlobalLineWidthScale();
 
  // Get view parameters that the user can force through the vis attributes, thereby over-riding the current view parameter.
  G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle(pVA);
  //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
 
#ifdef G4VTKDEBUG
  G4cout << "=================================" << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called> " << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called>     colour:" << colour.GetRed() << " " << colour.GetBlue() << " " << colour.GetGreen() << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called>      alpha:" << colour.GetAlpha() << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called>  lineWidth:" << lineWidth << G4endl;
  G4cout << "G4VtkSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called>  lineStyle:" << lineStyle << G4endl;
#endif
 
  //std::size_t vhash = std::hash<G4VisAttributes>{}(*pVA);
 
  std::size_t vhash = 0;
  std::hash_combine(vhash,static_cast<int>(drawing_style));
 
  std::size_t phash = std::hash<G4Polyhedron>{}(polyhedron);
 
  std::size_t hash = 0;
  std::hash_combine(hash, phash);
  std::hash_combine(hash, vhash);
 
  if (polyhedronPolyDataMap.find(hash) == polyhedronPolyDataMap.end()) {
 
    vtkSmartPointer<vtkPoints>     points = vtkSmartPointer<vtkPoints>::New();
    vtkSmartPointer<vtkCellArray>   polys = vtkSmartPointer<vtkCellArray>::New();
    vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
 
    G4bool notLastFace;
    int iVert = 0;
    do {
      G4Point3D vertex[4];
      G4int edgeFlag[4];
      G4Normal3D normals[4];
      G4int nEdges;
      notLastFace = polyhedron.GetNextFacet(nEdges, vertex, edgeFlag, normals);
 
      vtkSmartPointer<vtkIdList> poly = vtkSmartPointer<vtkIdList>::New();
      // loop over vertices
      for (int i = 0; i < nEdges; i++) {
        points->InsertNextPoint(vertex[i].x(), vertex[i].y(), vertex[i].z());
        poly->InsertNextId(iVert);
        iVert++;
      }
      polys->InsertNextCell(poly);
 
    } while (notLastFace);
 
    polydata->SetPoints(points);
    polydata->SetPolys(polys);
 
    polyhedronDataMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkPoints>>(hash, points));
    polyhedronPolyMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkCellArray>>(hash, polys));
    polyhedronPolyDataMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkPolyData>>(hash, polydata));
    polyhedronPolyDataCountMap.insert(std::pair<std::size_t, std::size_t>(hash, 0));
 
    vtkSmartPointer<vtkPoints>          instancePosition = vtkSmartPointer<vtkPoints>::New();
    vtkSmartPointer<vtkDoubleArray>     instanceRotation = vtkSmartPointer<vtkDoubleArray>::New();
    vtkSmartPointer<vtkDoubleArray>       instanceColors = vtkSmartPointer<vtkDoubleArray>::New();
    vtkSmartPointer<vtkPolyDataMapper>    instanceMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    vtkSmartPointer<vtkActor>              instanceActor = vtkSmartPointer<vtkActor>::New();
    instanceColors->SetName("colors");
 
    instanceColors->SetNumberOfComponents(4);
    instanceRotation->SetNumberOfComponents(9);
 
    vtkSmartPointer<vtkPolyData> instancePolyData = vtkSmartPointer<vtkPolyData>::New();
    instancePolyData->SetPoints(instancePosition);
    instancePolyData->GetPointData()->SetTensors(instanceRotation);
    instancePolyData->GetPointData()->SetVectors(instanceColors);
    instancePolyData->GetPointData()->SetScalars(instanceColors);
 
    vtkSmartPointer<vtkCleanPolyData> filterClean = vtkSmartPointer<vtkCleanPolyData>::New();
    filterClean->PointMergingOn();
    filterClean->AddInputData(polydata);
 
    vtkSmartPointer<vtkTriangleFilter> filterTriangle = vtkSmartPointer<vtkTriangleFilter>::New();
    filterTriangle->SetInputConnection(filterClean->GetOutputPort());
 
    vtkSmartPointer<vtkPolyDataNormals> filterNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
    filterNormals->SetFeatureAngle(45);
    filterNormals->SetInputConnection(filterTriangle->GetOutputPort());
 
    vtkSmartPointer<vtkFeatureEdges> filterEdge = vtkSmartPointer<vtkFeatureEdges>::New();
    filterEdge->SetFeatureEdges(1);
    filterEdge->SetManifoldEdges(0);
    filterEdge->SetBoundaryEdges(0);
    filterEdge->SetFeatureAngle(45);  // TODO need to have a function and command to set  this
    filterEdge->SetInputConnection(filterTriangle->GetOutputPort());
 
    vtkSmartPointer<vtkTensorGlyphColor> tensorGlyph = vtkSmartPointer<vtkTensorGlyphColor>::New();
    tensorGlyph->SetInputData(instancePolyData);
    tensorGlyph->SetSourceConnection(filterNormals->GetOutputPort());
    tensorGlyph->ColorGlyphsOn();
    tensorGlyph->ScalingOff();
    tensorGlyph->ThreeGlyphsOff();
    tensorGlyph->ExtractEigenvaluesOff();
    tensorGlyph->SetColorModeToScalars();
    tensorGlyph->Update();
 
    instanceMapper->SetInputData(tensorGlyph->GetOutput());
    instanceMapper->SetColorModeToDirectScalars();
 
    instanceActor->SetMapper(instanceMapper);
    // instanceActor->GetProperty()->SetLineWidth(10);
    instanceActor->SetVisibility(1);
 
    if(drawing_style == G4ViewParameters::hsr) {
 
    }
 
    if(drawing_style == G4ViewParameters::hlr) {
    }
 
    if(drawing_style == G4ViewParameters::wireframe) {
      instanceActor->GetProperty()->SetRepresentationToWireframe();
    }
 
    auto *pVtkViewer = dynamic_cast<G4VtkViewer *>(fpViewer);
    pVtkViewer->renderer->AddActor(instanceActor);
 
    instancePositionMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkPoints>>(hash, instancePosition));
    instanceRotationMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkDoubleArray>>(hash, instanceRotation));
    instanceColoursMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkDoubleArray>>(hash, instanceColors));
    instancePolyDataMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkPolyData>>(hash,instancePolyData));
    instanceActorMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkActor>>(hash, instanceActor));
    instanceTensorGlyphMap.insert(std::pair<std::size_t, vtkSmartPointer<vtkTensorGlyphColor>>(hash, tensorGlyph));
  }
 
  polyhedronPolyDataCountMap[hash]++;
 
  double red   = colour.GetRed();
  double green = colour.GetGreen();
  double blue  = colour.GetBlue();
  double alpha = colour.GetAlpha();
 
  instanceColoursMap[hash]->InsertNextTuple4(red, green, blue, alpha);
 
  instancePositionMap[hash]->InsertNextPoint(fObjectTransformation.dx(),
                                              fObjectTransformation.dy(),
                                              fObjectTransformation.dz());
 
  G4Transform3D fInvObjTrans = fObjectTransformation.inverse();
 
  instanceRotationMap[hash]->InsertNextTuple9(fInvObjTrans.xx(), fInvObjTrans.xy(),fInvObjTrans.xz(),
                                               fInvObjTrans.yx(), fInvObjTrans.yy(),fInvObjTrans.yz(),
                                               fInvObjTrans.zx(), fInvObjTrans.zy(),fInvObjTrans.zz());
 
}

References alpha, HepGeom::Transform3D::dx(), HepGeom::Transform3D::dy(), HepGeom::Transform3D::dz(), G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4cout, G4endl, G4Colour::GetAlpha(), G4VViewer::GetApplicableVisAttributes(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4VSceneHandler::GetDrawingStyle(), G4Colour::GetGreen(), HepPolyhedron::GetNextFacet(), HepPolyhedron::GetNoFacets(), G4Colour::GetRed(), G4Visible::GetVisAttributes(), hash(), std::hash_combine(), G4ViewParameters::hlr, G4ViewParameters::hsr, G4VtkSceneHandler::instanceActorMap, G4VtkSceneHandler::instanceColoursMap, G4VtkSceneHandler::instancePolyDataMap, G4VtkSceneHandler::instancePositionMap, G4VtkSceneHandler::instanceRotationMap, G4VtkSceneHandler::instanceTensorGlyphMap, HepGeom::Transform3D::inverse(), G4VtkSceneHandler::polyhedronDataMap, G4VtkSceneHandler::polyhedronPolyDataCountMap, G4VtkSceneHandler::polyhedronPolyDataMap, G4VtkSceneHandler::polyhedronPolyMap, G4VtkViewer::renderer, G4ViewParameters::wireframe, HepGeom::Transform3D::xx(), HepGeom::Transform3D::xy(), HepGeom::Transform3D::xz(), HepGeom::Transform3D::yx(), HepGeom::Transform3D::yy(), HepGeom::Transform3D::yz(), HepGeom::Transform3D::zx(), HepGeom::Transform3D::zy(), and HepGeom::Transform3D::zz().

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::AddPrimitiveBakedTransform().

AddSolid() [1/14]

void G4VtkSceneHandler::AddSolid ( const G4Box &  box )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 724 of file G4VtkSceneHandler.cc.

                                                  {
 
  G4VSceneHandler::AddSolid(box);
 
#if 0
  return;
 
  const G4VModel* pv_model = GetModel();
  if (!pv_model) { return ; }
 
  G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (!pPVModel) { return ; }
 
  //-- debug information
  if(1) {
    G4VPhysicalVolume *pv = pPVModel->GetCurrentPV();
    G4LogicalVolume   *lv = pv->GetLogicalVolume();
    G4cout << "name=" << box.GetName() << " volumeType=" << pv->VolumeType() << " pvName=" << pv->GetName() << " lvName=" << lv->GetName() << " multiplicity=" << pv->GetMultiplicity() << " isparametrised=" << pv->IsParameterised() << " isreplicated=" << pv->IsReplicated() << " parametrisation=" << pv->GetParameterisation() << G4endl;
  }
 
  if(0) {
    G4Material *mat = pPVModel->GetCurrentMaterial();
    G4String name   = mat->GetName();
    G4double dens   = mat->GetDensity()/(g/cm3);
    G4int copyNo    = pPVModel->GetCurrentPV()->GetCopyNo();
    G4int depth     = pPVModel->GetCurrentDepth();
    G4cout << "    name    : " << box.GetName() << G4endl;
    G4cout << "    copy no.: " << copyNo << G4endl;
    G4cout << "    depth   : " << depth << G4endl;
    G4cout << "    density : " << dens << " [g/cm3]" << G4endl;
    G4cout << "    location: " << pPVModel->GetCurrentPV()->GetObjectTranslation() << G4endl;
    G4cout << "    Multiplicity        : " << pPVModel->GetCurrentPV()->GetMultiplicity() << G4endl;
    G4cout << "    Is replicated?      : " << pPVModel->GetCurrentPV()->IsReplicated() << G4endl;
    G4cout << "    Is parameterised?   : " << pPVModel->GetCurrentPV()->IsParameterised() << G4endl;
    G4cout << "    top phys. vol. name : " << pPVModel->GetTopPhysicalVolume()->GetName() << G4endl;
  }
#endif
}

References G4VSceneHandler::AddSolid(), cm3, G4VSceneHandler::fpModel, g, G4cout, G4endl, G4VPhysicalVolume::GetCopyNo(), G4PhysicalVolumeModel::GetCurrentDepth(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4PhysicalVolumeModel::GetCurrentPV(), G4Material::GetDensity(), G4VPhysicalVolume::GetLogicalVolume(), G4VSceneHandler::GetModel(), G4VPhysicalVolume::GetMultiplicity(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4Material::GetName(), G4VPhysicalVolume::GetObjectTranslation(), G4VPhysicalVolume::GetParameterisation(), G4PhysicalVolumeModel::GetTopPhysicalVolume(), G4VPhysicalVolume::IsParameterised(), G4VPhysicalVolume::IsReplicated(), G4InuclParticleNames::name(), and G4VPhysicalVolume::VolumeType().

Referenced by G4VtkSceneHandler::AddCompound().

AddSolid() [2/14]

void G4VSceneHandler::AddSolid ( const G4Cons &  cons )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 266 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (cons);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [3/14]

void G4VSceneHandler::AddSolid ( const G4Ellipsoid &  ellipsoid )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 298 of file G4VSceneHandler.cc.

                                                            {
  AddSolidWithAuxiliaryEdges (ellipsoid);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [4/14]

void G4VSceneHandler::AddSolid ( const G4Orb &  orb )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 270 of file G4VSceneHandler.cc.

                                                {
  AddSolidWithAuxiliaryEdges (orb);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [5/14]

void G4VSceneHandler::AddSolid ( const G4Para &  para )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 274 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (para);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [6/14]

void G4VSceneHandler::AddSolid ( const G4Polycone &  polycone )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 302 of file G4VSceneHandler.cc.

                                                          {
  AddSolidT (polycone);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [7/14]

void G4VSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 306 of file G4VSceneHandler.cc.

                                                            {
  AddSolidT (polyhedra);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [8/14]

void G4VSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 278 of file G4VSceneHandler.cc.

                                                      {
  AddSolidWithAuxiliaryEdges (sphere);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [9/14]

void G4VSceneHandler::AddSolid ( const G4TessellatedSolid &  tess )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 310 of file G4VSceneHandler.cc.

                                                              {
  AddSolidT (tess);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [10/14]

void G4VSceneHandler::AddSolid ( const G4Torus &  torus )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 282 of file G4VSceneHandler.cc.

                                                    {
  AddSolidWithAuxiliaryEdges (torus);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [11/14]

void G4VSceneHandler::AddSolid ( const G4Trap &  trap )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 286 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (trap);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [12/14]

void G4VSceneHandler::AddSolid ( const G4Trd &  trd )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 290 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (trd);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [13/14]

void G4VSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 294 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (tubs);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [14/14]

void G4VSceneHandler::AddSolid ( const G4VSolid &  solid )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, G4VRML2FileSceneHandler, G4DAWNFILESceneHandler, and G4GMocrenFileSceneHandler.

Definition at line 314 of file G4VSceneHandler.cc.

                                                     {
  AddSolidT (solid);
}

References G4VSceneHandler::AddSolidT().

AddSolidT()

template<class T >

void G4VSceneHandler::AddSolidT ( const T &  solid )

inherited

Definition at line 220 of file G4VSceneHandler.cc.

{
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  RequestPrimitives (solid);
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), and G4VSceneHandler::RequestPrimitives().

Referenced by G4VSceneHandler::AddSolid().

AddSolidWithAuxiliaryEdges()

template<class T >

void G4VSceneHandler::AddSolidWithAuxiliaryEdges ( const T &  solid )

inherited

Definition at line 228 of file G4VSceneHandler.cc.

{
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  // Draw with auxiliary edges unless otherwise specified.
  if (!fpVisAttribs->IsForceAuxEdgeVisible()) {
    // Create a vis atts object for the modified vis atts.
    // It is static so that we may return a reliable pointer to it.
    static G4VisAttributes visAttsWithAuxEdges;
    // Initialise it with the current vis atts and reset the pointer.
    visAttsWithAuxEdges = *fpVisAttribs;
    // Force auxiliary edges visible.
    visAttsWithAuxEdges.SetForceAuxEdgeVisible();
    fpVisAttribs = &visAttsWithAuxEdges;
  }
  RequestPrimitives (solid);
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), G4VisAttributes::IsForceAuxEdgeVisible(), G4VSceneHandler::RequestPrimitives(), and G4VisAttributes::SetForceAuxEdgeVisible().

Referenced by G4VSceneHandler::AddSolid().

AddViewerToList()

void G4VSceneHandler::AddViewerToList ( G4VViewer *  pView )

inherited

Definition at line 454 of file G4VSceneHandler.cc.

                                                         {
  fViewerList.push_back (pViewer);
}

References G4VSceneHandler::fViewerList.

BeginModeling()

void G4VSceneHandler::BeginModeling ( )

virtualinherited

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLStoredSceneHandler, G4ASCIITreeSceneHandler, G4VTreeSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 208 of file G4VSceneHandler.cc.

                                     {
}

Referenced by G4GMocrenFileSceneHandler::BeginModeling(), G4HepRepFileSceneHandler::BeginModeling(), G4OpenGLImmediateSceneHandler::BeginModeling(), G4OpenGLStoredSceneHandler::BeginModeling(), G4VTreeSceneHandler::BeginModeling(), G4GMocrenFileSceneHandler::GFBeginModeling(), and G4VSceneHandler::ProcessScene().

BeginPrimitives()

void G4VSceneHandler::BeginPrimitives ( const G4Transform3D &  objectTransformation = G4Transform3D() )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 160 of file G4VSceneHandler.cc.

                                            {
  //static G4int count = 0;
  //G4cout << "G4VSceneHandler::BeginPrimitives: " << count++ << G4endl;
  fNestingDepth++;
  if (fNestingDepth > 1)
    G4Exception
      ("G4VSceneHandler::BeginPrimitives",
       "visman0101", FatalException,
       "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
  fObjectTransformation = objectTransformation;
}

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fObjectTransformation, and G4Exception().

Referenced by G4GMocrenFileSceneHandler::BeginPrimitives(), G4OpenGLSceneHandler::BeginPrimitives(), G4OpenInventorSceneHandler::BeginPrimitives(), G4Qt3DSceneHandler::BeginPrimitives(), and G4VSceneHandler::RequestPrimitives().

BeginPrimitives2D()

void G4VSceneHandler::BeginPrimitives2D ( const G4Transform3D &  objectTransformation = G4Transform3D() )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, and G4Qt3DSceneHandler.

Definition at line 184 of file G4VSceneHandler.cc.

                                            {
  fNestingDepth++;
  if (fNestingDepth > 1)
    G4Exception
      ("G4VSceneHandler::BeginPrimitives2D",
       "visman0103", FatalException,
       "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
  fObjectTransformation = objectTransformation;
  fProcessing2D = true;
}

References G4VSceneHandler::fNestingDepth, and G4Exception().

Referenced by G4HepRepFileSceneHandler::BeginPrimitives2D(), G4OpenGLSceneHandler::BeginPrimitives2D(), and G4Qt3DSceneHandler::BeginPrimitives2D().

Clear()

void G4VtkSceneHandler::Clear ( )

inherited

Definition at line 679 of file G4VtkSceneHandler.cc.

                              {
 
  polylineVisAttributesMap.clear();
  polylineDataMap.clear();
  polylineLineMap.clear();
  polylinePolyDataMap.clear();
  polylinePolyDataMapperMap.clear();
  polylinePolyDataActorMap.clear();
 
  for (auto& v : polylineDataMap)
    {v.second->Reset();}
  for (auto& v : polylineLineMap)
    {v.second->Reset();}
 
  circleVisAttributesMap.clear();
  circleDataMap.clear();
  circlePolyDataMap.clear();
  circleFilterMap.clear();
  circlePolyDataMapperMap.clear();
  circlePolyDataActorMap.clear();
 
  squareVisAttributesMap.clear();
  squareDataMap.clear();
  squarePolyDataMap.clear();
  squareFilterMap.clear();
  squarePolyDataMapperMap.clear();
  squarePolyDataActorMap.clear();
 
  for (auto& v : squareDataMap)
    {v.second->Reset();}
 
  polyhedronVisAttributesMap.clear();
  polyhedronDataMap.clear();
  polyhedronPolyMap.clear();
  polyhedronPolyDataMap.clear();
  polyhedronPolyDataCountMap.clear();
 
  instancePositionMap.clear();
  instanceRotationMap.clear();
  instanceColoursMap.clear();
  instancePolyDataMap.clear();
  instanceTensorGlyphMap.clear();
  instanceActorMap.clear();
}

References G4VtkSceneHandler::circleDataMap, G4VtkSceneHandler::circleFilterMap, G4VtkSceneHandler::circlePolyDataActorMap, G4VtkSceneHandler::circlePolyDataMap, G4VtkSceneHandler::circlePolyDataMapperMap, G4VtkSceneHandler::circleVisAttributesMap, G4VtkSceneHandler::instanceActorMap, G4VtkSceneHandler::instanceColoursMap, G4VtkSceneHandler::instancePolyDataMap, G4VtkSceneHandler::instancePositionMap, G4VtkSceneHandler::instanceRotationMap, G4VtkSceneHandler::instanceTensorGlyphMap, G4VtkSceneHandler::polyhedronDataMap, G4VtkSceneHandler::polyhedronPolyDataCountMap, G4VtkSceneHandler::polyhedronPolyDataMap, G4VtkSceneHandler::polyhedronPolyMap, G4VtkSceneHandler::polyhedronVisAttributesMap, G4VtkSceneHandler::polylineDataMap, G4VtkSceneHandler::polylineLineMap, G4VtkSceneHandler::polylinePolyDataActorMap, G4VtkSceneHandler::polylinePolyDataMap, G4VtkSceneHandler::polylinePolyDataMapperMap, G4VtkSceneHandler::polylineVisAttributesMap, G4VtkSceneHandler::squareDataMap, G4VtkSceneHandler::squareFilterMap, G4VtkSceneHandler::squarePolyDataActorMap, G4VtkSceneHandler::squarePolyDataMap, G4VtkSceneHandler::squarePolyDataMapperMap, and G4VtkSceneHandler::squareVisAttributesMap.

Referenced by G4VtkViewer::ClearView().

ClearStore()

void G4VSceneHandler::ClearStore ( )

virtualinherited

Reimplemented in G4OpenGLStoredQtSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, and G4ToolsSGSceneHandler.

Definition at line 216 of file G4VSceneHandler.cc.

{}

Referenced by G4OpenGLStoredSceneHandler::ClearStore(), G4VisManager::GeometryHasChanged(), G4VisManager::NotifyHandlers(), G4VViewer::ProcessView(), and G4OpenGLSceneHandler::~G4OpenGLSceneHandler().

ClearTransientStore()

void G4VSceneHandler::ClearTransientStore ( )

virtualinherited

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLStoredQtSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 218 of file G4VSceneHandler.cc.

{}

Referenced by G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::GeometryHasChanged(), G4VisManager::NotifyHandlers(), G4VisCommandViewerClearTransients::SetNewValue(), and G4VisCommandViewerRebuild::SetNewValue().

CreateCutawaySolid()

G4DisplacedSolid * G4VSceneHandler::CreateCutawaySolid ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 904 of file G4VSceneHandler.cc.

{
  // To be reviewed.
  return 0;
  /*** An alternative way of getting a cutaway is to use
  Command /vis/scene/add/volume
  Guidance :
  Adds a physical volume to current scene, with optional clipping volume.
  If physical-volume-name is "world" (the default), the top of the
  main geometry tree (material world) is added.  If "worlds", the
  top of all worlds - material world and parallel worlds, if any - are
    added.  Otherwise a search of all worlds is made, taking the first
    matching occurrence only.  To see a representation of the geometry
    hierarchy of the worlds, try "/vis/drawTree [worlds]" or one of the
    driver/browser combinations that have the required functionality, e.g., HepRep.
    If clip-volume-type is specified, the subsequent parameters are used to
    to define a clipping volume.  For example,
    "/vis/scene/add/volume ! ! ! -box km 0 1 0 1 0 1" will draw the world
    with the positive octant cut away.  (If the Boolean Processor issues
    warnings try replacing 0 by 0.000000001 or something.)
    If clip-volume-type is prepended with '-', the clip-volume is subtracted
    (cutaway). (This is the default if there is no prepended character.)
    If '*' is prepended, the intersection of the physical-volume and the
    clip-volume is made. (You can make a section/DCUT with a thin box, for
    example).
    For "box", the parameters are xmin,xmax,ymin,ymax,zmin,zmax.
    Only "box" is programmed at present.
   ***/
}

Referenced by G4VSceneHandler::CreateModelingParameters().

CreateModelingParameters()

G4ModelingParameters * G4VSceneHandler::CreateModelingParameters ( )

inherited

Definition at line 798 of file G4VSceneHandler.cc.

{
  // Create modeling parameters from View Parameters...
  if (!fpViewer) return NULL;
 
  const G4ViewParameters& vp = fpViewer -> GetViewParameters ();
 
  // Convert drawing styles...
  G4ModelingParameters::DrawingStyle modelDrawingStyle =
  G4ModelingParameters::wf;
  switch (vp.GetDrawingStyle ()) {
    default:
    case G4ViewParameters::wireframe:
      modelDrawingStyle = G4ModelingParameters::wf;
      break;
    case G4ViewParameters::hlr:
      modelDrawingStyle = G4ModelingParameters::hlr;
      break;
    case G4ViewParameters::hsr:
      modelDrawingStyle = G4ModelingParameters::hsr;
      break;
    case G4ViewParameters::hlhsr:
      modelDrawingStyle = G4ModelingParameters::hlhsr;
      break;
    case G4ViewParameters::cloud:
      modelDrawingStyle = G4ModelingParameters::cloud;
      break;
  }
 
  // Decide if covered daughters are really to be culled...
  G4bool reallyCullCovered =
    vp.IsCullingCovered()   // Culling daughters depends also on...
    && !vp.IsSection ()     // Sections (DCUT) not requested.
    && !vp.IsCutaway ()     // Cutaways not requested.
    ;
 
  G4ModelingParameters* pModelingParams = new G4ModelingParameters
    (vp.GetDefaultVisAttributes (),
     modelDrawingStyle,
     vp.IsCulling (),
     vp.IsCullingInvisible (),
     vp.IsDensityCulling (),
     vp.GetVisibleDensity (),
     reallyCullCovered,
     vp.GetNoOfSides ()
     );
 
  pModelingParams->SetNumberOfCloudPoints(vp.GetNumberOfCloudPoints());
  pModelingParams->SetWarning
    (G4VisManager::GetVerbosity() >= G4VisManager::warnings);
 
  pModelingParams->SetCBDAlgorithmNumber(vp.GetCBDAlgorithmNumber());
  pModelingParams->SetCBDParameters(vp.GetCBDParameters());
 
  pModelingParams->SetExplodeFactor(vp.GetExplodeFactor());
  pModelingParams->SetExplodeCentre(vp.GetExplodeCentre());
 
  pModelingParams->SetSectionSolid(CreateSectionSolid());
  pModelingParams->SetCutawaySolid(CreateCutawaySolid());
  // The polyhedron objects are deleted in the modeling parameters destructor.
  
  pModelingParams->SetVisAttributesModifiers(vp.GetVisAttributesModifiers());
 
  pModelingParams->SetSpecialMeshRendering(vp.IsSpecialMeshRendering());
  pModelingParams->SetSpecialMeshVolumes(vp.GetSpecialMeshVolumes());
 
  return pModelingParams;
}

References G4ViewParameters::cloud, G4ModelingParameters::cloud, G4VSceneHandler::CreateCutawaySolid(), G4VSceneHandler::CreateSectionSolid(), G4VSceneHandler::fpViewer, G4ViewParameters::GetCBDAlgorithmNumber(), G4ViewParameters::GetCBDParameters(), G4ViewParameters::GetDefaultVisAttributes(), G4ViewParameters::GetDrawingStyle(), G4ViewParameters::GetExplodeCentre(), G4ViewParameters::GetExplodeFactor(), G4ViewParameters::GetNoOfSides(), G4ViewParameters::GetNumberOfCloudPoints(), G4ViewParameters::GetSpecialMeshVolumes(), G4VisManager::GetVerbosity(), G4ViewParameters::GetVisAttributesModifiers(), G4ViewParameters::GetVisibleDensity(), G4ViewParameters::hlhsr, G4ModelingParameters::hlhsr, G4ViewParameters::hlr, G4ModelingParameters::hlr, G4ViewParameters::hsr, G4ModelingParameters::hsr, G4ViewParameters::IsCulling(), G4ViewParameters::IsCullingCovered(), G4ViewParameters::IsCullingInvisible(), G4ViewParameters::IsCutaway(), G4ViewParameters::IsDensityCulling(), G4ViewParameters::IsSection(), G4ViewParameters::IsSpecialMeshRendering(), G4ModelingParameters::SetCBDAlgorithmNumber(), G4ModelingParameters::SetCBDParameters(), G4ModelingParameters::SetCutawaySolid(), G4ModelingParameters::SetExplodeCentre(), G4ModelingParameters::SetExplodeFactor(), G4ModelingParameters::SetNumberOfCloudPoints(), G4ModelingParameters::SetSectionSolid(), G4ModelingParameters::SetSpecialMeshRendering(), G4ModelingParameters::SetSpecialMeshVolumes(), G4ModelingParameters::SetVisAttributesModifiers(), G4ModelingParameters::SetWarning(), G4VisManager::warnings, G4ModelingParameters::wf, and G4ViewParameters::wireframe.

Referenced by G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), and G4VSceneHandler::ProcessScene().

CreateSectionSolid()

G4DisplacedSolid * G4VSceneHandler::CreateSectionSolid ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 867 of file G4VSceneHandler.cc.

{
  G4DisplacedSolid* sectioner = 0;
 
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  if (vp.IsSection () ) {
 
    G4double radius = fpScene->GetExtent().GetExtentRadius();
    G4double safe = radius + fpScene->GetExtent().GetExtentCentre().mag();
    G4VSolid* sectionBox =
      new G4Box("_sectioner", safe, safe, 1.e-5 * radius);  // Thin in z-plane...
    const G4Normal3D originalNormal(0,0,1);  // ...so this is original normal.
 
    const G4Plane3D& sp = vp.GetSectionPlane ();
    const G4double& a = sp.a();
    const G4double& b = sp.b();
    const G4double& c = sp.c();
    const G4double& d = sp.d();
    const G4Normal3D newNormal(a,b,c);
 
    G4Transform3D requiredTransform;
    // Rotate
    if (newNormal != originalNormal) {
      const G4double& angle = std::acos(newNormal.dot(originalNormal));
      const G4Vector3D& axis = originalNormal.cross(newNormal);
      requiredTransform = G4Rotate3D(angle, axis);
    }
    // Translate
    requiredTransform = requiredTransform * G4TranslateZ3D(-d);
 
    sectioner = new G4DisplacedSolid
      ("_displaced_sectioning_box", sectionBox, requiredTransform);
  }
  
  return sectioner;
}

References angle, HepGeom::BasicVector3D< T >::cross(), HepGeom::BasicVector3D< T >::dot(), G4VSceneHandler::fpScene, G4VSceneHandler::fpViewer, G4Scene::GetExtent(), G4VisExtent::GetExtentCentre(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetSectionPlane(), G4VViewer::GetViewParameters(), G4ViewParameters::IsSection(), HepGeom::BasicVector3D< T >::mag(), and G4InuclParticleNames::sp.

Referenced by G4VSceneHandler::CreateModelingParameters(), and G4OpenGLSceneHandler::CreateSectionSolid().

DrawEndOfRunModels()

void G4VSceneHandler::DrawEndOfRunModels ( )

inherited

Definition at line 777 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EORModelList =
    fpScene -> GetEndOfRunModelList ();
  size_t nModels = EORModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(0);
    for (size_t i = 0; i < nModels; i++) {
      if (EORModelList[i].fActive) {
        fpModel = EORModelList[i].fpModel;
    fpModel -> SetModelingParameters(pMP);
    fpModel -> DescribeYourselfTo (*this);
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

References G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, and G4ModelingParameters::SetEvent().

Referenced by G4VisManager::EndOfRun(), and G4VSceneHandler::ProcessScene().

DrawEvent()

void G4VSceneHandler::DrawEvent ( const G4Event *  event )

inherited

Definition at line 756 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EOEModelList =
    fpScene -> GetEndOfEventModelList ();
  size_t nModels = EOEModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(event);
    for (size_t i = 0; i < nModels; i++) {
      if (EOEModelList[i].fActive) {
    fpModel = EOEModelList[i].fpModel;
    fpModel -> SetModelingParameters(pMP);
    fpModel -> DescribeYourselfTo (*this);
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

References G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, and G4ModelingParameters::SetEvent().

Referenced by G4VisManager::EndOfEvent(), and G4VSceneHandler::ProcessScene().

EndModeling()

void G4VSceneHandler::EndModeling ( )

virtualinherited

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLStoredSceneHandler, G4ASCIITreeSceneHandler, G4VTreeSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 211 of file G4VSceneHandler.cc.

{
  fpModel = 0;
}

References G4VSceneHandler::fpModel.

Referenced by G4GMocrenFileSceneHandler::EndModeling(), G4HepRepFileSceneHandler::EndModeling(), G4OpenGLImmediateSceneHandler::EndModeling(), G4OpenGLStoredSceneHandler::EndModeling(), G4VTreeSceneHandler::EndModeling(), G4GMocrenFileSceneHandler::GFEndModeling(), and G4VSceneHandler::ProcessScene().

EndPrimitives()

void G4VSceneHandler::EndPrimitives ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4Qt3DSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 173 of file G4VSceneHandler.cc.

                                     {
  if (fNestingDepth <= 0)
    G4Exception("G4VSceneHandler::EndPrimitives",
        "visman0102", FatalException, "Nesting error.");
  fNestingDepth--;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
}

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, G4VSceneHandler::fTransientsDrawnThisRun, and G4Exception().

Referenced by G4GMocrenFileSceneHandler::EndPrimitives(), G4OpenGLSceneHandler::EndPrimitives(), G4Qt3DSceneHandler::EndPrimitives(), and G4VSceneHandler::RequestPrimitives().

EndPrimitives2D()

void G4VSceneHandler::EndPrimitives2D ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, and G4Qt3DSceneHandler.

Definition at line 196 of file G4VSceneHandler.cc.

                                       {
  if (fNestingDepth <= 0)
    G4Exception("G4VSceneHandler::EndPrimitives2D",
        "visman0104", FatalException, "Nesting error.");
  fNestingDepth--;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
  fProcessing2D = false;
}

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fProcessing2D, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, G4VSceneHandler::fTransientsDrawnThisRun, and G4Exception().

Referenced by G4HepRepFileSceneHandler::EndPrimitives2D(), G4OpenGLSceneHandler::EndPrimitives2D(), and G4Qt3DSceneHandler::EndPrimitives2D().

GetAuxEdgeVisible()

G4bool G4VSceneHandler::GetAuxEdgeVisible ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1081 of file G4VSceneHandler.cc.

                                                                             {
  G4bool isAuxEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible ();
  if (pVisAttribs -> IsForceAuxEdgeVisible()) {
    isAuxEdgeVisible = pVisAttribs->IsForcedAuxEdgeVisible();
  }
  return isAuxEdgeVisible;
}

References G4VSceneHandler::fpViewer, G4VViewer::GetViewParameters(), G4ViewParameters::IsAuxEdgeVisible(), and G4VisAttributes::IsForcedAuxEdgeVisible().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), and G4OpenInventorSceneHandler::AddProperties().

GetColor() [1/2]

const G4Colour & G4VSceneHandler::GetColor ( )

inherited

GetColor() [2/2]

const G4Colour & G4VSceneHandler::GetColor ( const G4Visible &  )

inherited

GetColour() [1/2]

const G4Colour & G4VSceneHandler::GetColour ( )

inherited

Definition at line 994 of file G4VSceneHandler.cc.

                                            {
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  const G4Colour& colour = fpVisAttribs -> GetColour ();
  return colour;
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), and G4VSceneHandler::GetColour().

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VSceneHandler::GetColour(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

GetColour() [2/2]

const G4Colour & G4VSceneHandler::GetColour ( const G4Visible &  visible )

inherited

Definition at line 1000 of file G4VSceneHandler.cc.

                                                                    {
  auto pVA = visible.GetVisAttributes();
  if (!pVA) pVA = fpViewer->GetViewParameters().GetDefaultVisAttributes();
  return pVA->GetColour();
}

References G4VSceneHandler::fpViewer, G4VisAttributes::GetColour(), G4ViewParameters::GetDefaultVisAttributes(), G4VViewer::GetViewParameters(), and G4Visible::GetVisAttributes().

GetCurrentViewer()

G4VViewer * G4VSceneHandler::GetCurrentViewer ( ) const

inherited

GetDrawingStyle()

G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1021 of file G4VSceneHandler.cc.

                                     {
  // Drawing style is normally determined by the view parameters, but
  // it can be overriddden by the ForceDrawingStyle flag in the vis
  // attributes.
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  const G4ViewParameters::DrawingStyle viewerStyle = vp.GetDrawingStyle();
  G4ViewParameters::DrawingStyle resultantStyle = viewerStyle;
  if (pVisAttribs -> IsForceDrawingStyle ()) {
    G4VisAttributes::ForcedDrawingStyle forcedStyle =
    pVisAttribs -> GetForcedDrawingStyle ();
    // This is complicated because if hidden line and surface removal
    // has been requested we wish to preserve this sometimes.
    switch (forcedStyle) {
      case (G4VisAttributes::solid):
        switch (viewerStyle) {
          case (G4ViewParameters::hlr):
            resultantStyle = G4ViewParameters::hlhsr;
            break;
          case (G4ViewParameters::wireframe):
            resultantStyle = G4ViewParameters::hsr;
            break;
          case (G4ViewParameters::cloud):
            resultantStyle = G4ViewParameters::hsr;
            break;
          case (G4ViewParameters::hlhsr):
          case (G4ViewParameters::hsr):
            break;
        }
        break;
      case (G4VisAttributes::cloud):
        resultantStyle = G4ViewParameters::cloud;
        break;
      case (G4VisAttributes::wireframe):
      default:
        // But if forced style is wireframe, do it, because one of its
        // main uses is in displaying the consituent solids of a Boolean
        // solid and their surfaces overlap with the resulting Booean
        // solid, making a mess if hlr is specified.
        resultantStyle = G4ViewParameters::wireframe;
        break;
    }
  }
  return resultantStyle;
}

References G4VisAttributes::cloud, G4ViewParameters::cloud, G4VSceneHandler::fpViewer, G4ViewParameters::GetDrawingStyle(), G4VViewer::GetViewParameters(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, G4VisAttributes::solid, G4VisAttributes::wireframe, and G4ViewParameters::wireframe.

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4OpenInventorSceneHandler::GeneratePrerequisites(), and G4VSceneHandler::RequestPrimitives().

GetExtent()

const G4VisExtent & G4VSceneHandler::GetExtent ( ) const

virtualinherited

Reimplemented from G4VGraphicsScene.

Definition at line 134 of file G4VSceneHandler.cc.

{
  if (fpScene) {
    return fpScene->GetExtent();
  } else {
    static const G4VisExtent defaultExtent = G4VisExtent();
    return defaultExtent;
  }
}

References G4VSceneHandler::fpScene, and G4Scene::GetExtent().

Referenced by G4VtkViewer::SetView().

GetGraphicsSystem()

G4VGraphicsSystem * G4VSceneHandler::GetGraphicsSystem ( ) const

inherited

Referenced by G4ASCIITreeSceneHandler::BeginModeling(), G4ASCIITreeSceneHandler::EndModeling(), G4OpenInventorViewer::G4OpenInventorViewer(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VisCommandViewerList::SetNewValue(), and G4ASCIITreeSceneHandler::WriteHeader().

GetLineWidth()

G4double G4VSceneHandler::GetLineWidth ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1012 of file G4VSceneHandler.cc.

{
  G4double lineWidth = pVisAttribs->GetLineWidth();
  if (lineWidth < 1.) lineWidth = 1.;
  lineWidth *= fpViewer -> GetViewParameters().GetGlobalLineWidthScale();
  if (lineWidth < 1.) lineWidth = 1.;
  return lineWidth;
}

References G4VSceneHandler::fpViewer, and G4VisAttributes::GetLineWidth().

Referenced by G4OpenGLSceneHandler::AddPrimitive().

GetMarkerDiameter()

G4double G4VSceneHandler::GetMarkerDiameter ( const G4VMarker &  , MarkerSizeType &    )

inherited

GetMarkerRadius()

G4double G4VSceneHandler::GetMarkerRadius ( const G4VMarker &  , MarkerSizeType &    )

inherited

GetMarkerSize()

G4double G4VSceneHandler::GetMarkerSize ( const G4VMarker &  marker, G4VSceneHandler::MarkerSizeType &  markerSizeType  )

inherited

Definition at line 1089 of file G4VSceneHandler.cc.

{
  G4bool userSpecified = marker.GetWorldSize() || marker.GetScreenSize();
  const G4VMarker& defaultMarker =
    fpViewer -> GetViewParameters().GetDefaultMarker();
  G4double size = userSpecified ?
    marker.GetWorldSize() : defaultMarker.GetWorldSize();
  if (size) {
    // Draw in world coordinates.
    markerSizeType = world;
  }
  else {
    size = userSpecified ?
      marker.GetScreenSize() : defaultMarker.GetScreenSize();
    // Draw in screen coordinates.
    markerSizeType = screen;
  }
  size *= fpViewer -> GetViewParameters().GetGlobalMarkerScale();
  if (markerSizeType == screen && size < 1.) size = 1.;
  return size;
}

References G4VSceneHandler::fpViewer, G4VMarker::GetScreenSize(), G4VMarker::GetWorldSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4Qt3DSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), and G4OpenGLXViewer::DrawText().

GetMarkForClearingTransientStore()

G4bool G4VSceneHandler::GetMarkForClearingTransientStore ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

GetModel()

G4VModel * G4VSceneHandler::GetModel ( ) const

inherited

Referenced by G4GMocrenFileSceneHandler::AddDetector(), G4GMocrenFileSceneHandler::AddSolid(), and G4VtkSceneHandler::AddSolid().

GetName()

const G4String & G4VSceneHandler::GetName ( ) const

inherited

Referenced by G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddSolid(), G4VViewer::G4VViewer(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), G4VisCommandSceneHandlerList::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), and G4VisCommandViewerUpdate::SetNewValue().

GetNoOfSides()

G4int G4VSceneHandler::GetNoOfSides ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1113 of file G4VSceneHandler.cc.

{
  // No. of sides (lines segments per circle) is normally determined
  // by the view parameters, but it can be overriddden by the
  // ForceLineSegmentsPerCircle in the vis attributes.
  G4int lineSegmentsPerCircle = fpViewer->GetViewParameters().GetNoOfSides();
  if (pVisAttribs) {
    if (pVisAttribs->IsForceLineSegmentsPerCircle())
      lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
    if (lineSegmentsPerCircle < pVisAttribs->GetMinLineSegmentsPerCircle()) {
      lineSegmentsPerCircle = pVisAttribs->GetMinLineSegmentsPerCircle();
      G4cout <<
    "G4VSceneHandler::GetNoOfSides: attempt to set the"
    "\nnumber of line segments per circle < " << lineSegmentsPerCircle
         << "; forced to " << pVisAttribs->GetMinLineSegmentsPerCircle() << G4endl;
    }
  }
  return lineSegmentsPerCircle;
}

References G4VSceneHandler::fpViewer, G4cout, G4endl, G4VisAttributes::GetForcedLineSegmentsPerCircle(), G4VisAttributes::GetMinLineSegmentsPerCircle(), G4ViewParameters::GetNoOfSides(), G4VViewer::GetViewParameters(), and G4VisAttributes::IsForceLineSegmentsPerCircle().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), and G4VSceneHandler::RequestPrimitives().

GetNumberOfCloudPoints()

G4int G4VSceneHandler::GetNumberOfCloudPoints ( const G4VisAttributes *  pVisAttribs ) const

inherited

Definition at line 1067 of file G4VSceneHandler.cc.

                                           {
  // Returns no of cloud points from current view parameters, unless the user
  // has forced through the vis attributes, thereby over-riding the
  // current view parameter.
  G4int numberOfCloudPoints = fpViewer->GetViewParameters().GetNumberOfCloudPoints();
  if (pVisAttribs -> IsForceDrawingStyle() &&
      pVisAttribs -> GetForcedDrawingStyle() == G4VisAttributes::cloud &&
      pVisAttribs -> GetForcedNumberOfCloudPoints() > 0) {
    numberOfCloudPoints = pVisAttribs -> GetForcedNumberOfCloudPoints();
  }
  return numberOfCloudPoints;
}

References G4VisAttributes::cloud, G4VSceneHandler::fpViewer, G4ViewParameters::GetNumberOfCloudPoints(), and G4VViewer::GetViewParameters().

Referenced by G4VSceneHandler::RequestPrimitives().

GetObjectTransformation()

const G4Transform3D & G4VSceneHandler::GetObjectTransformation ( ) const

inherited

Referenced by G4VisManager::DrawT(), and G4VisManager::DrawT2D().

GetScene()

G4Scene * G4VSceneHandler::GetScene ( ) const

inherited

Referenced by G4OpenGLXmViewer::actions_callback(), G4VVisCommand::CheckSceneAndNotifyHandlers(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4GMocrenFileSceneHandler::GFBeginModeling(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLXmViewer::left_right_pan_callback(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4VVisCommand::RefreshIfRequired(), G4OpenGLXmViewer::ResetView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4DAWNFILEViewer::SendViewParameters(), G4VRML2FileViewer::SendViewParameters(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetShift(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4OpenGLXmViewer::up_down_pan_callback(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

GetSceneHandlerId()

G4int G4VSceneHandler::GetSceneHandlerId ( ) const

inherited

Referenced by G4OpenGLXmViewer::actions_callback(), and G4OpenGLXmViewer::misc_callback().

GetTextColor()

const G4Colour & G4VSceneHandler::GetTextColor ( const G4Text &  )

inherited

GetTextColour()

const G4Colour & G4VSceneHandler::GetTextColour ( const G4Text &  text )

inherited

Definition at line 1006 of file G4VSceneHandler.cc.

                                                                  {
  auto pVA = text.GetVisAttributes();
  if (!pVA) pVA = fpViewer->GetViewParameters().GetDefaultTextVisAttributes();
  return pVA->GetColour();
}

References G4VSceneHandler::fpViewer, G4VisAttributes::GetColour(), G4ViewParameters::GetDefaultTextVisAttributes(), G4VViewer::GetViewParameters(), and G4Visible::GetVisAttributes().

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), and G4OpenGLXViewer::DrawText().

GetTransientsDrawnThisEvent()

G4bool G4VSceneHandler::GetTransientsDrawnThisEvent ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

GetTransientsDrawnThisRun()

G4bool G4VSceneHandler::GetTransientsDrawnThisRun ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

GetViewCount()

G4int G4VSceneHandler::GetViewCount ( ) const

inherited

GetViewerList()

const G4ViewerList & G4VSceneHandler::GetViewerList ( ) const

inherited

IncrementViewCount()

G4int G4VSceneHandler::IncrementViewCount ( )

inherited

IsReadyForTransients()

G4bool G4VSceneHandler::IsReadyForTransients ( ) const

inherited

LoadAtts()

void G4VSceneHandler::LoadAtts ( const G4Visible &  visible, G4AttHolder *  holder  )

protectedinherited

Definition at line 934 of file G4VSceneHandler.cc.

{
  // Load G4Atts from G4VisAttributes, if any...
  const G4VisAttributes* va = visible.GetVisAttributes();
  if (va) {
    const std::map<G4String,G4AttDef>* vaDefs =
      va->GetAttDefs();
    if (vaDefs) {
      holder->AddAtts(visible.GetVisAttributes()->CreateAttValues(), vaDefs);
    }
  }
 
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (pPVModel) {
    // Load G4Atts from G4PhysicalVolumeModel...
    const std::map<G4String,G4AttDef>* pvDefs = pPVModel->GetAttDefs();
    if (pvDefs) {
      holder->AddAtts(pPVModel->CreateCurrentAttValues(), pvDefs);
    }
  }
 
  G4TrajectoriesModel* trajModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajModel) {
    // Load G4Atts from trajectory model...
    const std::map<G4String,G4AttDef>* trajModelDefs = trajModel->GetAttDefs();
    if (trajModelDefs) {
      holder->AddAtts(trajModel->CreateCurrentAttValues(), trajModelDefs);
    }
    // Load G4Atts from trajectory...
    const G4VTrajectory* traj = trajModel->GetCurrentTrajectory();
    if (traj) {
      const std::map<G4String,G4AttDef>* trajDefs = traj->GetAttDefs();
      if (trajDefs) {
        holder->AddAtts(traj->CreateAttValues(), trajDefs);
      }
      G4int nPoints = traj->GetPointEntries();
      for (G4int i = 0; i < nPoints; ++i) {
        G4VTrajectoryPoint* trajPoint = traj->GetPoint(i);
        if (trajPoint) {
          const std::map<G4String,G4AttDef>* pointDefs = trajPoint->GetAttDefs();
          if (pointDefs) {
            holder->AddAtts(trajPoint->CreateAttValues(), pointDefs);
          }
        }
      }
    }
  }
 
  G4HitsModel* hitsModel = dynamic_cast<G4HitsModel*>(fpModel);
  if (hitsModel) {
    // Load G4Atts from hit...
    const G4VHit* hit = hitsModel->GetCurrentHit();
    const std::map<G4String,G4AttDef>* hitsDefs = hit->GetAttDefs();
    if (hitsDefs) {
      holder->AddAtts(hit->CreateAttValues(), hitsDefs);
    }
  }
}

References G4AttHolder::AddAtts(), G4VHit::CreateAttValues(), G4VisAttributes::CreateAttValues(), G4VTrajectory::CreateAttValues(), G4VTrajectoryPoint::CreateAttValues(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4TrajectoriesModel::CreateCurrentAttValues(), G4VSceneHandler::fpModel, G4VHit::GetAttDefs(), G4VisAttributes::GetAttDefs(), G4VTrajectory::GetAttDefs(), G4VTrajectoryPoint::GetAttDefs(), G4PhysicalVolumeModel::GetAttDefs(), G4TrajectoriesModel::GetAttDefs(), G4HitsModel::GetCurrentHit(), G4TrajectoriesModel::GetCurrentTrajectory(), G4VTrajectory::GetPoint(), G4VTrajectory::GetPointEntries(), and G4Visible::GetVisAttributes().

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal().

Modified()

void G4VtkSceneHandler::Modified ( )

inherited

Definition at line 595 of file G4VtkSceneHandler.cc.

                                 {
  for (auto it = polylineDataMap.begin(); it != polylineDataMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for (auto it = polylineLineMap.begin(); it != polylineLineMap.end(); it++)
  {
    it->second->Modified();
  }
  for (auto it = circleDataMap.begin(); it != circleDataMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for (auto it = squareDataMap.begin(); it != squareDataMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for(auto it = instancePositionMap.begin(); it != instancePositionMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for(auto it = instanceRotationMap.begin(); it != instanceRotationMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for(auto it = instanceColoursMap.begin(); it != instanceColoursMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for(auto it = instancePolyDataMap.begin(); it != instancePolyDataMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for(auto it = instanceActorMap.begin(); it != instanceActorMap.end(); it++)
  {
    it->second->Modified();
  }
 
  for(auto it = instanceTensorGlyphMap.begin(); it != instanceTensorGlyphMap.end(); it++)
  {
    it->second->Update();
  }
 
#ifdef G4VTKDEBUG
  G4cout << "G4VtkSceneHandler::Modified()    polyline styles: " << polylineVisAttributesMap.size() << G4endl;
  for (auto it = polylineLineMap.begin(); it != polylineLineMap.end(); it++)
  {
    G4cout << "G4VtkSceneHandler::Modified()   polyline segments: "
           << it->second->GetNumberOfCells() << G4endl;
  }
  G4cout << "G4VtkSceneHandler::Modified()       circle styles: " << circleVisAttributesMap.size() << G4endl;
  for (auto it = circleDataMap.begin(); it != circleDataMap.end(); it++)
  {
    G4cout << "G4VtkSceneHandler::Modified()             circles: "
           << it->second->GetNumberOfPoints() << G4endl;
  }
 
  G4cout << "G4VtkSceneHandler::Modified()      square styles: " << squareVisAttributesMap.size() << G4endl;
  for (auto it = squareDataMap.begin(); it != squareDataMap.end(); it++)
  {
    G4cout << "G4VtkSceneHanler::Modified()           squares: "
           << it->second->GetNumberOfPoints() << G4endl;
  }
 
  G4cout << "G4VtkSceneHandler::Modified()   unique polyhedra: " << polyhedronDataMap.size() << G4endl;
 
  int nPlacements = 0;
  int nCells = 0;
  for (auto it = polyhedronPolyDataMap.begin(); it != polyhedronPolyDataMap.end(); it++) {
    G4cout << "G4VtkSceneHandler::Modified()  polyhedronPolyData: " << it->second->GetPoints()->GetNumberOfPoints() << " " << it->second->GetPolys()->GetNumberOfCells() << " " << polyhedronPolyDataCountMap[it->first] <<G4endl;
    nCells      += it->second->GetPolys()->GetNumberOfCells()*polyhedronPolyDataCountMap[it->first];
    nPlacements += polyhedronPolyDataCountMap[it->first];
  }
  G4cout << "G4VtkSceneHandler::Modified()  polyhedronPolyData: " << nPlacements << " " << nCells << G4endl;
#endif
}

References G4VtkSceneHandler::circleDataMap, G4VtkSceneHandler::circleVisAttributesMap, G4cout, G4endl, G4VtkSceneHandler::instanceActorMap, G4VtkSceneHandler::instanceColoursMap, G4VtkSceneHandler::instancePolyDataMap, G4VtkSceneHandler::instancePositionMap, G4VtkSceneHandler::instanceRotationMap, G4VtkSceneHandler::instanceTensorGlyphMap, G4VtkSceneHandler::polyhedronDataMap, G4VtkSceneHandler::polyhedronPolyDataCountMap, G4VtkSceneHandler::polyhedronPolyDataMap, G4VtkSceneHandler::polylineDataMap, G4VtkSceneHandler::polylineLineMap, G4VtkSceneHandler::polylineVisAttributesMap, G4VtkSceneHandler::squareDataMap, and G4VtkSceneHandler::squareVisAttributesMap.

Referenced by G4VtkViewer::FinishView(), and G4VtkViewer::ShowView().

PostAddSolid()

void G4VSceneHandler::PostAddSolid ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4Qt3DSceneHandler, and G4VTreeSceneHandler.

Definition at line 151 of file G4VSceneHandler.cc.

                                    {
  fpVisAttribs = 0;
  fProcessingSolid = false;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
}

References G4VSceneHandler::fProcessingSolid, G4VSceneHandler::fpVisAttribs, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, and G4VSceneHandler::fTransientsDrawnThisRun.

Referenced by G4VSceneHandler::AddCompound(), and G4Qt3DSceneHandler::PostAddSolid().

PreAddSolid()

void G4VSceneHandler::PreAddSolid ( const G4Transform3D &  objectTransformation, const G4VisAttributes &  visAttribs  )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4OpenGLSceneHandler, G4Qt3DSceneHandler, G4VTreeSceneHandler, and G4OpenInventorSceneHandler.

Definition at line 144 of file G4VSceneHandler.cc.

                                                      {
  fObjectTransformation = objectTransformation;
  fpVisAttribs = &visAttribs;
  fProcessingSolid = true;
}

References G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fProcessingSolid, and G4VSceneHandler::fpVisAttribs.

Referenced by G4VSceneHandler::AddCompound(), G4OpenGLSceneHandler::PreAddSolid(), G4Qt3DSceneHandler::PreAddSolid(), G4VTreeSceneHandler::PreAddSolid(), and G4OpenInventorSceneHandler::PreAddSolid().

ProcessScene()

void G4VSceneHandler::ProcessScene ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 612 of file G4VSceneHandler.cc.

{
  // Assumes graphics database store has already been cleared if
  // relevant for the particular scene handler.
 
  if(!fpScene)
    return;
 
  if(fpScene->GetExtent() == G4VisExtent::GetNullExtent())
  {
    G4Exception("G4VSceneHandler::ProcessScene", "visman0106", JustWarning,
                "The scene has no extent.");
  }
 
  G4VisManager* visManager = G4VisManager::GetInstance();
 
  if(!visManager->GetConcreteInstance())
    return;
 
  G4VisManager::Verbosity verbosity = visManager->GetVerbosity();
 
  fReadyForTransients = false;
 
  // Reset fMarkForClearingTransientStore. (Leaving
  // fMarkForClearingTransientStore true causes problems with
  // recomputing transients below.)  Restore it again at end...
  G4bool tmpMarkForClearingTransientStore = fMarkForClearingTransientStore;
  fMarkForClearingTransientStore          = false;
 
  // Traverse geometry tree and send drawing primitives to window(s).
 
  const std::vector<G4Scene::Model>& runDurationModelList =
    fpScene->GetRunDurationModelList();
 
  if(runDurationModelList.size())
  {
    if(verbosity >= G4VisManager::confirmations)
    {
      G4cout << "Traversing scene data..." << G4endl;
    }
 
    BeginModeling();
 
    // Create modeling parameters from view parameters...
    G4ModelingParameters* pMP = CreateModelingParameters();
 
    for(size_t i = 0; i < runDurationModelList.size(); i++)
    {
      if(runDurationModelList[i].fActive)
      {
    fpModel = runDurationModelList[i].fpModel;
    fpModel->SetModelingParameters(pMP);
    fpModel->DescribeYourselfTo(*this);
    // To see the extents of each model represented as wireframe boxes,
    // uncomment the next line and DrawExtent in namespace above
    // DrawExtent(fpModel);
    fpModel->SetModelingParameters(0);
      }
    }
 
    fpModel = 0;
    delete pMP;
 
    EndModeling();
  }
 
  fReadyForTransients = true;
 
  // Refresh event from end-of-event model list.
  // Allow only in Idle or GeomClosed state...
  G4StateManager* stateManager = G4StateManager::GetStateManager();
  G4ApplicationState state     = stateManager->GetCurrentState();
  if(state == G4State_Idle || state == G4State_GeomClosed)
  {
    visManager->SetEventRefreshing(true);
 
    if(visManager->GetRequestedEvent())
    {
      DrawEvent(visManager->GetRequestedEvent());
    }
    else
    {
      G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
      if(runManager)
      {
        const G4Run* run = runManager->GetCurrentRun();
        const std::vector<const G4Event*>* events =
          run ? run->GetEventVector() : 0;
        size_t nKeptEvents = 0;
        if(events)
          nKeptEvents = events->size();
        if(nKeptEvents)
        {
          if(fpScene->GetRefreshAtEndOfEvent())
          {
            if(verbosity >= G4VisManager::confirmations)
            {
              G4cout << "Refreshing event..." << G4endl;
            }
            const G4Event* event = 0;
            if(events && events->size())
              event = events->back();
            if(event)
              DrawEvent(event);
          }
          else
          {  // Accumulating events.
 
            if(verbosity >= G4VisManager::confirmations)
            {
              G4cout << "Refreshing events in run..." << G4endl;
            }
            for(const auto& event : *events)
            {
              if(event)
                DrawEvent(event);
            }
 
            if(!fpScene->GetRefreshAtEndOfRun())
            {
              if(verbosity >= G4VisManager::warnings)
              {
                G4cout << "WARNING: Cannot refresh events accumulated over more"
                          "\n  than one runs.  Refreshed just the last run."
                       << G4endl;
              }
            }
          }
        }
      }
    }
    visManager->SetEventRefreshing(false);
  }
 
  // Refresh end-of-run model list.
  // Allow only in Idle or GeomClosed state...
  if(state == G4State_Idle || state == G4State_GeomClosed)
  {
    DrawEndOfRunModels();
  }
 
  fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
}

References G4VSceneHandler::BeginModeling(), G4VisManager::confirmations, G4VSceneHandler::CreateModelingParameters(), G4VModel::DescribeYourselfTo(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4VSceneHandler::EndModeling(), G4VSceneHandler::fMarkForClearingTransientStore, G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, G4VSceneHandler::fReadyForTransients, G4cout, G4endl, G4Exception(), G4State_GeomClosed, G4State_Idle, G4VVisManager::GetConcreteInstance(), G4RunManager::GetCurrentRun(), G4StateManager::GetCurrentState(), G4Scene::GetExtent(), G4VisManager::GetInstance(), G4RunManagerFactory::GetMasterRunManager(), G4VisExtent::GetNullExtent(), G4Scene::GetRefreshAtEndOfEvent(), G4Scene::GetRefreshAtEndOfRun(), G4VisManager::GetRequestedEvent(), G4Scene::GetRunDurationModelList(), G4StateManager::GetStateManager(), G4VisManager::GetVerbosity(), JustWarning, G4VisManager::SetEventRefreshing(), G4VModel::SetModelingParameters(), and G4VisManager::warnings.

Referenced by G4OpenGLSceneHandler::ProcessScene(), and G4VViewer::ProcessView().

RemoveViewerFromList()

void G4VSceneHandler::RemoveViewerFromList ( G4VViewer *  pView )

inherited

Definition at line 493 of file G4VSceneHandler.cc.

                                                              {
  fViewerList.remove(pViewer);  // Does nothing if already removed
  // And reset current viewer
  auto visManager = G4VisManager::GetInstance();
  visManager->SetCurrentViewer(nullptr);
}

References G4VSceneHandler::fViewerList, G4VisManager::GetInstance(), and G4ViewerList::remove().

Referenced by G4VViewer::~G4VViewer().

RequestPrimitives()

void G4VSceneHandler::RequestPrimitives ( const G4VSolid &  solid )

protectedvirtualinherited

Reimplemented in G4ASCIITreeSceneHandler, and G4RayTracerSceneHandler.

Definition at line 516 of file G4VSceneHandler.cc.

{
  const G4ViewParameters::DrawingStyle style = GetDrawingStyle(fpVisAttribs);
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
 
  switch (style) {
    default:
    case G4ViewParameters::wireframe:
    case G4ViewParameters::hlr:
    case G4ViewParameters::hsr:
    case G4ViewParameters::hlhsr:
    {
      // Use polyhedral representation
      G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (fpVisAttribs));
      G4Polyhedron* pPolyhedron = solid.GetPolyhedron ();
      G4Polyhedron::ResetNumberOfRotationSteps ();
      if (pPolyhedron) {
        pPolyhedron -> SetVisAttributes (fpVisAttribs);
        BeginPrimitives (fObjectTransformation);
        AddPrimitive (*pPolyhedron);
        EndPrimitives ();
        break;
      } else {  // Print warnings and drop through to cloud
        G4VisManager::Verbosity verbosity = G4VisManager::GetVerbosity();
        static std::set<const G4VSolid*> problematicSolids;
        if (verbosity >= G4VisManager::errors &&
            problematicSolids.find(&solid) == problematicSolids.end()) {
          problematicSolids.insert(&solid);
          G4cerr <<
          "ERROR: G4VSceneHandler::RequestPrimitives"
          "\n  Polyhedron not available for " << solid.GetName ();
          G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
          if (pPVModel) {
            G4cerr << "\n  Touchable path: " << pPVModel->GetFullPVPath();
          }
          static G4bool explanation = false;
          if (!explanation) {
            explanation = true;
            G4cerr <<
            "\n  This means it cannot be visualized in the usual way on most systems."
            "\n  1) The solid may not have implemented the CreatePolyhedron method."
            "\n  2) For Boolean solids, the BooleanProcessor, which attempts to create"
            "\n     the resultant polyhedron, may have failed."
            "\n  Try RayTracer. It uses Geant4's tracking algorithms instead.";
          }
          G4cerr << "\n  Drawing solid with cloud of points.";
          G4cerr << G4endl;
        }
      }
    }
      [[fallthrough]];
 
    case G4ViewParameters::cloud:
    {
      // Form solid out of cloud of dots on surface of solid
      G4Polymarker dots;
      // Note: OpenGL has a fast implementation of polymarker so it's better
      // to build a polymarker rather than add a succession of circles.
      // And anyway, in Qt, in the latter case each circle would be a scene-tree
      // entry, something we would want to avoid.
      dots.SetVisAttributes(fpVisAttribs);
      dots.SetMarkerType(G4Polymarker::dots);
      dots.SetSize(G4VMarker::screen,1.);
      G4int numberOfCloudPoints = GetNumberOfCloudPoints(fpVisAttribs);
      if (numberOfCloudPoints <= 0) numberOfCloudPoints = vp.GetNumberOfCloudPoints();
      for (G4int i = 0; i < numberOfCloudPoints; ++i) {
    G4ThreeVector p = solid.GetPointOnSurface();
    dots.push_back(p);
      }
      BeginPrimitives (fObjectTransformation);
      AddPrimitive(dots);
      EndPrimitives ();
      break;
    }
  }
}

References G4VSceneHandler::AddPrimitive(), G4VSceneHandler::BeginPrimitives(), G4ViewParameters::cloud, G4Polymarker::dots, G4VSceneHandler::EndPrimitives(), G4VisManager::errors, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpModel, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cerr, G4endl, G4VSceneHandler::GetDrawingStyle(), G4PhysicalVolumeModel::GetFullPVPath(), G4VSolid::GetName(), G4VSceneHandler::GetNoOfSides(), G4ViewParameters::GetNumberOfCloudPoints(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSolid::GetPointOnSurface(), G4VSolid::GetPolyhedron(), G4VisManager::GetVerbosity(), G4VViewer::GetViewParameters(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, HepPolyhedron::ResetNumberOfRotationSteps(), G4VMarker::screen, G4Polymarker::SetMarkerType(), HepPolyhedron::SetNumberOfRotationSteps(), G4VMarker::SetSize(), G4Visible::SetVisAttributes(), and G4ViewParameters::wireframe.

Referenced by G4VSceneHandler::AddSolidT(), and G4VSceneHandler::AddSolidWithAuxiliaryEdges().

SetCurrentViewer()

void G4VSceneHandler::SetCurrentViewer ( G4VViewer *  )

inherited

SetMarkForClearingTransientStore()

void G4VSceneHandler::SetMarkForClearingTransientStore ( G4bool  )

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandViewerClearTransients::SetNewValue().

SetModel()

void G4VSceneHandler::SetModel ( G4VModel *  )

inherited

SetName()

void G4VSceneHandler::SetName ( const G4String &  )

inherited

SetObjectTransformation()

void G4VSceneHandler::SetObjectTransformation ( const G4Transform3D &  )

inherited

SetScene()

void G4VSceneHandler::SetScene ( G4Scene *  pScene )

virtualinherited

Reimplemented in G4OpenGLStoredQtSceneHandler.

Definition at line 507 of file G4VSceneHandler.cc.

                                               {
  fpScene = pScene;
  // Notify all viewers that a kernel visit is required.
  G4ViewerListIterator i;
  for (i = fViewerList.begin(); i != fViewerList.end(); i++) {
    (*i) -> SetNeedKernelVisit (true);
  }
}

References G4VSceneHandler::fpScene, and G4VSceneHandler::fViewerList.

Referenced by G4OpenGLStoredQtSceneHandler::SetScene().

SetTransientsDrawnThisEvent()

void G4VSceneHandler::SetTransientsDrawnThisEvent ( G4bool  )

inherited

Referenced by G4VisManager::BeginOfEvent().

SetTransientsDrawnThisRun()

void G4VSceneHandler::SetTransientsDrawnThisRun ( G4bool  )

inherited

Referenced by G4VisManager::BeginOfRun().

SetViewerList()

G4ViewerList & G4VSceneHandler::SetViewerList ( )

inherited

Friends And Related Function Documentation

G4VtkQtViewer

friend class G4VtkQtViewer

friend

Definition at line 39 of file G4VtkQtSceneHandler.hh.

Field Documentation

circleDataMap

std::map<std::size_t, vtkSmartPointer<vtkPoints> > G4VtkSceneHandler::circleDataMap

protectedinherited

Definition at line 134 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

circleFilterMap

std::map<std::size_t, vtkSmartPointer<vtkVertexGlyphFilter> > G4VtkSceneHandler::circleFilterMap

protectedinherited

Definition at line 136 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

circlePolyDataActorMap

std::map<std::size_t, vtkSmartPointer<vtkActor> > G4VtkSceneHandler::circlePolyDataActorMap

protectedinherited

Definition at line 138 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

circlePolyDataMap

std::map<std::size_t, vtkSmartPointer<vtkPolyData> > G4VtkSceneHandler::circlePolyDataMap

protectedinherited

Definition at line 135 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

circlePolyDataMapperMap

std::map<std::size_t, vtkSmartPointer<vtkPolyDataMapper> > G4VtkSceneHandler::circlePolyDataMapperMap

protectedinherited

Definition at line 137 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

circleVisAttributesMap

std::map<std::size_t, const G4VisAttributes*> G4VtkSceneHandler::circleVisAttributesMap

protectedinherited

Definition at line 133 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

fIdentityTransformation

const G4Transform3D G4VSceneHandler::fIdentityTransformation

protectedinherited

Definition at line 364 of file G4VSceneHandler.hh.

fMarkForClearingTransientStore

G4bool G4VSceneHandler::fMarkForClearingTransientStore

protectedinherited

Definition at line 352 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::ProcessScene().

fName

G4String G4VSceneHandler::fName

protectedinherited

Definition at line 347 of file G4VSceneHandler.hh.

fNestingDepth

G4int G4VSceneHandler::fNestingDepth

protectedinherited

Definition at line 362 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::BeginPrimitives(), G4VSceneHandler::BeginPrimitives2D(), G4VSceneHandler::EndPrimitives(), and G4VSceneHandler::EndPrimitives2D().

fObjectTransformation

G4Transform3D G4VSceneHandler::fObjectTransformation

protectedinherited

Definition at line 360 of file G4VSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddDetector(), G4VtkSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4HepRepFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4OpenInventorSceneHandler::AddTransform(), G4VSceneHandler::BeginPrimitives(), G4VSceneHandler::PreAddSolid(), and G4VSceneHandler::RequestPrimitives().

fpModel

G4VModel* G4VSceneHandler::fpModel

protectedinherited

Definition at line 359 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddCompound(), G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddDetector(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4Qt3DSceneHandler::CreateNewNode(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4VSceneHandler::EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::LoadAtts(), G4VTreeSceneHandler::PreAddSolid(), G4VSceneHandler::ProcessScene(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), and G4OpenGLSceneHandler::ScaledFlush().

fProcessing2D

G4bool G4VSceneHandler::fProcessing2D

protectedinherited

Definition at line 358 of file G4VSceneHandler.hh.

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4OpenGLSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VSceneHandler::EndPrimitives2D(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), and G4OpenGLStoredQtSceneHandler::ExtraTOProcessing().

fProcessingSolid

G4bool G4VSceneHandler::fProcessingSolid

protectedinherited

Definition at line 357 of file G4VSceneHandler.hh.

Referenced by G4OpenInventorSceneHandler::BeginPrimitives(), G4VSceneHandler::PostAddSolid(), and G4VSceneHandler::PreAddSolid().

fpScene

G4Scene* G4VSceneHandler::fpScene

protectedinherited

Definition at line 351 of file G4VSceneHandler.hh.

Referenced by G4Qt3DSceneHandler::AddPrimitive(), G4VSceneHandler::CreateSectionSolid(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4ASCIITreeSceneHandler::EndModeling(), G4RayTracerSceneHandler::G4RayTracerSceneHandler(), G4VSceneHandler::GetExtent(), G4Qt3DViewer::mouseMoveEvent(), G4VSceneHandler::ProcessScene(), G4OpenGLSceneHandler::ScaledFlush(), G4VSceneHandler::SetScene(), and G4OpenGLStoredQtSceneHandler::SetScene().

fpViewer

G4VViewer* G4VSceneHandler::fpViewer

protectedinherited

Definition at line 350 of file G4VSceneHandler.hh.

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4VtkSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4OpenInventorSceneHandler::AddTransform(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredQtSceneHandler::ClearStore(), G4GMocrenFileSceneHandler::ClearTransientStore(), G4HepRepFileSceneHandler::ClearTransientStore(), G4OpenGLImmediateSceneHandler::ClearTransientStore(), G4OpenGLStoredQtSceneHandler::ClearTransientStore(), G4OpenGLStoredSceneHandler::ClearTransientStore(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::CreateSectionSolid(), G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetAuxEdgeVisible(), G4VSceneHandler::GetColour(), G4VSceneHandler::GetDrawingStyle(), G4VSceneHandler::GetLineWidth(), G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::GetNoOfSides(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSceneHandler::GetTextColour(), G4GMocrenFileSceneHandler::IsVisible(), G4VSceneHandler::RequestPrimitives(), and G4OpenGLStoredQtSceneHandler::SetScene().

fpVisAttribs

const G4VisAttributes* G4VSceneHandler::fpVisAttribs

protectedinherited

Definition at line 363 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetColour(), G4GMocrenFileSceneHandler::IsVisible(), G4VSceneHandler::PostAddSolid(), G4VSceneHandler::PreAddSolid(), and G4VSceneHandler::RequestPrimitives().

fReadyForTransients

G4bool G4VSceneHandler::fReadyForTransients

protectedinherited

Definition at line 353 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::BeginPrimitives(), G4OpenGLStoredSceneHandler::BeginPrimitives2D(), G4Qt3DSceneHandler::CreateNewNode(), G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::PostAddSolid(), G4VSceneHandler::ProcessScene(), and G4OpenGLSceneHandler::ScaledFlush().

fSceneHandlerId

const G4int G4VSceneHandler::fSceneHandlerId

protectedinherited

Definition at line 346 of file G4VSceneHandler.hh.

fSceneIdCount

G4int G4VtkQtSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 46 of file G4VtkQtSceneHandler.hh.

fSystem

G4VGraphicsSystem& G4VSceneHandler::fSystem

protectedinherited

Definition at line 345 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddPrimitive().

fTransientsDrawnThisEvent

G4bool G4VSceneHandler::fTransientsDrawnThisEvent

protectedinherited

Definition at line 355 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), and G4VSceneHandler::PostAddSolid().

fTransientsDrawnThisRun

G4bool G4VSceneHandler::fTransientsDrawnThisRun

protectedinherited

Definition at line 356 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), and G4VSceneHandler::PostAddSolid().

fViewCount

G4int G4VSceneHandler::fViewCount

protectedinherited

Definition at line 348 of file G4VSceneHandler.hh.

fViewerList

G4ViewerList G4VSceneHandler::fViewerList

protectedinherited

Definition at line 349 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddViewerToList(), G4VSceneHandler::RemoveViewerFromList(), and G4VSceneHandler::SetScene().

instanceActorMap

std::map<std::size_t, vtkSmartPointer<vtkActor> > G4VtkSceneHandler::instanceActorMap

protectedinherited

Definition at line 161 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

instanceColoursMap

std::map<std::size_t, vtkSmartPointer<vtkDoubleArray> > G4VtkSceneHandler::instanceColoursMap

protectedinherited

Definition at line 158 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

instancePolyDataMap

std::map<std::size_t, vtkSmartPointer<vtkPolyData> > G4VtkSceneHandler::instancePolyDataMap

protectedinherited

Definition at line 159 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

instancePositionMap

std::map<std::size_t, vtkSmartPointer<vtkPoints> > G4VtkSceneHandler::instancePositionMap

protectedinherited

Definition at line 156 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

instanceRotationMap

std::map<std::size_t, vtkSmartPointer<vtkDoubleArray> > G4VtkSceneHandler::instanceRotationMap

protectedinherited

Definition at line 157 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

instanceTensorGlyphMap

std::map<std::size_t, vtkSmartPointer<vtkTensorGlyphColor> > G4VtkSceneHandler::instanceTensorGlyphMap

protectedinherited

Definition at line 160 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

polyhedronDataMap

std::map<std::size_t, vtkSmartPointer<vtkPoints> > G4VtkSceneHandler::polyhedronDataMap

protectedinherited

Definition at line 150 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

polyhedronPolyDataCountMap

std::map<std::size_t, std::size_t> G4VtkSceneHandler::polyhedronPolyDataCountMap

protectedinherited

Definition at line 153 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

polyhedronPolyDataMap

std::map<std::size_t, vtkSmartPointer<vtkPolyData> > G4VtkSceneHandler::polyhedronPolyDataMap

protectedinherited

Definition at line 152 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

polyhedronPolyMap

std::map<std::size_t, vtkSmartPointer<vtkCellArray> > G4VtkSceneHandler::polyhedronPolyMap

protectedinherited

Definition at line 151 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitiveTensorGlyph(), and G4VtkSceneHandler::Clear().

polyhedronVisAttributesMap

std::map<std::size_t, const G4VisAttributes*> G4VtkSceneHandler::polyhedronVisAttributesMap

protectedinherited

Definition at line 149 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::Clear().

polylineDataMap

std::map<std::size_t, vtkSmartPointer<vtkPoints> > G4VtkSceneHandler::polylineDataMap

protectedinherited

Definition at line 126 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

polylineLineMap

std::map<std::size_t, vtkSmartPointer<vtkCellArray> > G4VtkSceneHandler::polylineLineMap

protectedinherited

Definition at line 127 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

polylinePolyDataActorMap

std::map<std::size_t, vtkSmartPointer<vtkActor> > G4VtkSceneHandler::polylinePolyDataActorMap

protectedinherited

Definition at line 130 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

polylinePolyDataMap

std::map<std::size_t, vtkSmartPointer<vtkPolyData> > G4VtkSceneHandler::polylinePolyDataMap

protectedinherited

Definition at line 128 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

polylinePolyDataMapperMap

std::map<std::size_t, vtkSmartPointer<vtkPolyDataMapper> > G4VtkSceneHandler::polylinePolyDataMapperMap

protectedinherited

Definition at line 129 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

polylineVisAttributesMap

std::map<std::size_t, const G4VisAttributes*> G4VtkSceneHandler::polylineVisAttributesMap

protectedinherited

Definition at line 125 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

squareDataMap

std::map<std::size_t, vtkSmartPointer<vtkPoints> > G4VtkSceneHandler::squareDataMap

protectedinherited

Definition at line 142 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

squareFilterMap

std::map<std::size_t, vtkSmartPointer<vtkVertexGlyphFilter> > G4VtkSceneHandler::squareFilterMap

protectedinherited

Definition at line 144 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

squarePolyDataActorMap

std::map<std::size_t, vtkSmartPointer<vtkActor> > G4VtkSceneHandler::squarePolyDataActorMap

protectedinherited

Definition at line 146 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

squarePolyDataMap

std::map<std::size_t, vtkSmartPointer<vtkPolyData> > G4VtkSceneHandler::squarePolyDataMap

protectedinherited

Definition at line 143 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

squarePolyDataMapperMap

std::map<std::size_t, vtkSmartPointer<vtkPolyDataMapper> > G4VtkSceneHandler::squarePolyDataMapperMap

protectedinherited

Definition at line 145 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), and G4VtkSceneHandler::Clear().

squareVisAttributesMap

std::map<std::size_t, const G4VisAttributes*> G4VtkSceneHandler::squareVisAttributesMap

protectedinherited

Definition at line 141 of file G4VtkSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::Clear(), and G4VtkSceneHandler::Modified().

---

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

• source/visualization/Vtk/include/G4VtkQtSceneHandler.hh
• source/visualization/Vtk/src/G4VtkQtSceneHandler.cc