G4VtkStore Class Reference

#include <G4VtkStore.hh>

Public Member Functions
	G4VtkStore (G4String name)
	~G4VtkStore ()
void	Modified ()
void	Clear ()
void	ClearNonG4 ()
void	Print ()
void	AddPrimitive (const G4Polyline &polyline, const G4VtkVisContext &vc)
void	AddPrimitive (const G4Text &text, const G4VtkVisContext &vc)
void	AddPrimitive (const G4Circle &circle, const G4VtkVisContext &vc)
void	AddPrimitive (const G4Square &square, const G4VtkVisContext &vc)
void	AddPrimitiveSeparate (const G4Polyhedron &polyhedron, const G4VtkVisContext &vc)
void	AddPrimitiveTensorGlyph (const G4Polyhedron &polyhedron, const G4VtkVisContext &vc)
void	AddPrimitiveAppend (const G4Polyhedron &polyhedron, const G4VtkVisContext &vc)
void	AddPrimitiveTransformBake (const G4Polyhedron &polyhedron, const G4VtkVisContext &vc)
void	AddCompound (const G4Mesh &mesh, const G4VtkVisContext &vc)
void	UpdatePlanePipelines (G4String name, G4String type, const G4Plane3D)
void	AddClipper (G4String name, const G4Plane3D &plane)
void	UpdateClipper (G4String name, const G4Plane3D &plane)
void	RemoveClipper (G4String name)
void	AddCutter (G4String name, const G4Plane3D &plane)
void	UpdateCutter (G4String name, const G4Plane3D &plane)
void	RemoveCutter (G4String name)
void	AddNonG4ObjectImage (const G4String &fileName, const G4VtkVisContext &vc)
void	AddNonG4ObjectPolydata (const G4String fileName, const G4VtkVisContext &vc)
void	GetBounds (G4double maxBound[6])
void	AddToRenderer (vtkRenderer *renderer)
std::map< std::size_t, std::shared_ptr< G4VtkPolydataPolylinePipeline > > &	GetPolylinePipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataPolyline2DPipeline > > &	GetPolyline2DPipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataSpherePipeline > > &	GetPolydataSpherePipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataPolygonPipeline > > &	GetPolydataPolygonPipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataPipeline > > &	GetSeparatePipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataInstanceTensorPipeline > > &	GetTensorPipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataInstanceAppendPipeline > > &	GetAppendPipeMap ()
std::map< std::size_t, std::shared_ptr< G4VtkPolydataInstanceBakePipeline > > &	GetBakePipeMap ()

Detailed Description

Definition at line 97 of file G4VtkStore.hh.

Constructor & Destructor Documentation

G4VtkStore()

G4VtkStore::G4VtkStore

(

G4String

name

)

Definition at line 83 of file G4VtkStore.cc.

: name(nameIn) {}

~G4VtkStore()

G4VtkStore::~G4VtkStore

(

)

Definition at line 85 of file G4VtkStore.cc.

{
  Clear();
}

Member Function Documentation

AddClipper()

void G4VtkStore::AddClipper	(	G4String	name,
		const G4Plane3D &	plane )

Definition at line 579 of file G4VtkStore.cc.

{
  for (const auto& v : separatePipeMap) {
    auto clip_pl = new G4VtkClipClosedSurfacePipeline(nameIn, v.second->GetVtkVisContext(),
                                                      v.second->GetFinalFilter(), true);
    clip_pl->SetPlane(plane);
    v.second->AddChildPipeline(clip_pl);
  }
 
  for (const auto& v : tensorGlyphPipeMap) {
    auto clip_pl = new G4VtkClipClosedSurfacePipeline(nameIn, v.second->GetVtkVisContext(),
                                                      v.second->GetFinalFilter());
    clip_pl->SetPlane(plane);
    v.second->AddChildPipeline(clip_pl);
  }
 
  for (const auto& v : appendPipeMap) {
    auto clip_pl = new G4VtkClipClosedSurfacePipeline(nameIn, v.second->GetVtkVisContext(),
                                                      v.second->GetFinalFilter(), true);
    clip_pl->SetPlane(plane);
    v.second->AddChildPipeline(clip_pl);
  }
 
  for (const auto& v : bakePipeMap) {
    auto clip_pl = new G4VtkClipClosedSurfacePipeline(nameIn, v.second->GetVtkVisContext(),
                                                      v.second->GetFinalFilter(), true);
    clip_pl->SetPlane(plane);
    v.second->AddChildPipeline(clip_pl);
  }
}

AddCompound()

void G4VtkStore::AddCompound	(	const G4Mesh &	mesh,
		const G4VtkVisContext &	vc )

Definition at line 560 of file G4VtkStore.cc.

                                                                          {
  const auto& container = mesh.GetContainerVolume();
  auto& containerName = const_cast<G4String&>(container->GetName());
 
  auto pl = std::make_shared<G4VtkUnstructuredGridPipeline>(containerName,vc);
  pl->SetUnstructuredGridData(mesh);
  ugridPipeMap.insert(std::make_pair(G4String("test"), pl));
}

Referenced by G4VtkSceneHandler::AddCompound().

AddCutter()

void G4VtkStore::AddCutter	(	G4String	name,
		const G4Plane3D &	plane )

Definition at line 655 of file G4VtkStore.cc.

{
  for (const auto& v : separatePipeMap) {
    auto cut_pl = new G4VtkCutterPipeline(nameIn, v.second->GetVtkVisContext(),
                                          v.second->GetFinalFilter(), true);
    cut_pl->SetPlane(plane);
    v.second->AddChildPipeline(cut_pl);
  }
 
  for (const auto& v : tensorGlyphPipeMap) {
    auto cut_pl =
      new G4VtkCutterPipeline(nameIn, v.second->GetVtkVisContext(), v.second->GetFinalFilter());
    cut_pl->SetPlane(plane);
    v.second->AddChildPipeline(cut_pl);
  }
 
  for (const auto& v : appendPipeMap) {
    auto cut_pl =
      new G4VtkCutterPipeline(nameIn, v.second->GetVtkVisContext(), v.second->GetFinalFilter());
    cut_pl->SetPlane(plane);
    v.second->AddChildPipeline(cut_pl);
  }
 
  for (const auto& v : bakePipeMap) {
    auto cut_pl =
      new G4VtkCutterPipeline(nameIn, v.second->GetVtkVisContext(), v.second->GetFinalFilter());
    cut_pl->SetPlane(plane);
    v.second->AddChildPipeline(cut_pl);
  }
}

AddNonG4ObjectImage()

void G4VtkStore::AddNonG4ObjectImage	(	const G4String &	fileName,
		const G4VtkVisContext &	vc )

Definition at line 731 of file G4VtkStore.cc.

{
  auto pl = std::make_shared<G4VtkImagePipeline>(G4String("name"), vc);
  pl->SetImage(fileName);
  imagePipeMap.insert(std::make_pair(fileName, pl));
}

Referenced by G4VtkViewer::AddImageOverlay().

AddNonG4ObjectPolydata()

void G4VtkStore::AddNonG4ObjectPolydata	(	const G4String	fileName,
		const G4VtkVisContext &	vc )

Definition at line 738 of file G4VtkStore.cc.

{
 
  vtkSmartPointer<vtkPolyData> pd;
 
  if (fileName.find("obj") != G4String::npos) {
    vtkNew<vtkOBJReader> objReader;
    objReader->SetFileName(fileName.c_str());
    objReader->Update();
    pd = objReader->GetOutput();
  }
  else if (fileName.find("ply") != G4String::npos) {
    vtkNew<vtkPLYReader> plyReader;
    plyReader->SetFileName(fileName.c_str());
    plyReader->Update();
    pd = plyReader->GetOutput();
  }
  else if (fileName.find("stl") != G4String::npos) {
    vtkNew<vtkSTLReader> stlReader;
    stlReader->SetFileName(fileName.c_str());
    stlReader->Update();
    pd = stlReader->GetOutput();
  }
  else if (fileName.find("vtp") != G4String::npos && fileName.find("vtu") != G4String::npos) {
    G4cout << "G4VtkStore::AddNonG4ObjectPolydata> vtp/vtu Warning not yet implemented" << G4endl;
  }
 
  auto pl = std::make_shared<G4VtkPolydataPipeline>(G4String("name"), vc);
 
 
  G4Transform3D fInvObjTrans = vc.fTransform.inverse();
  pl->SetPolydata(pd);
  pl->SetActorTransform(vc.fTransform.dx(), vc.fTransform.dy(), vc.fTransform.dz(),
                        fInvObjTrans.xx(), fInvObjTrans.xy(), fInvObjTrans.xz(),
                        fInvObjTrans.yx(), fInvObjTrans.yy(), fInvObjTrans.yz(),
                        fInvObjTrans.zx(), fInvObjTrans.zy(), fInvObjTrans.zz());
  pl->SetActorColour(vc.red, vc.green, vc.blue, vc.alpha);
}

Referenced by G4VtkViewer::AddGeometryOverlay().

AddPrimitive() [1/4]

void G4VtkStore::AddPrimitive	(	const G4Circle &	circle,
		const G4VtkVisContext &	vc )

Definition at line 331 of file G4VtkStore.cc.

{
  G4VSceneHandler::MarkerSizeType sizeType;
 
  if (vc.fProcessing2D) {
    sizeType = G4VSceneHandler::MarkerSizeType::screen;
  }
  else {
    sizeType = G4VSceneHandler::MarkerSizeType::world;
  }
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA = vc.fViewer->GetApplicableVisAttributes(circle.GetVisAttributes());
 
  if (sizeType == G4VSceneHandler::MarkerSizeType::world) {
    std::size_t hash = G4VtkPolydataSpherePipeline::MakeHash(pVA);
    std::shared_ptr<G4VtkPolydataSpherePipeline> pl;
 
    if (circlePipeMap.find(hash) == circlePipeMap.end()) {
      // Create new pipeline
      pl = std::make_shared<G4VtkPolydataSpherePipeline>(G4String("name"), vc, pVA);
 
      // add to map
      circlePipeMap.insert(std::make_pair(hash, pl));
    }
    else {
      pl = circlePipeMap[hash];
    }
 
    // Data data point
    const CLHEP::HepRotation rot = vc.fTransform.getRotation();
    G4Point3D posPrime = rot * circle.GetPosition();
    pl->SetPolydataData(vc.fTransform.dx() + posPrime.x(), vc.fTransform.dy() + posPrime.y(),
                        vc.fTransform.dz() + posPrime.z());
  }
}

AddPrimitive() [2/4]

void G4VtkStore::AddPrimitive	(	const G4Polyline &	polyline,
		const G4VtkVisContext &	vc )

Definition at line 254 of file G4VtkStore.cc.

{
  G4VSceneHandler::MarkerSizeType sizeType;
  if (vc.fProcessing2D) {
    sizeType = G4VSceneHandler::MarkerSizeType::screen;
  }
  else {
    sizeType = G4VSceneHandler::MarkerSizeType::world;
  }
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA = vc.fViewer->GetApplicableVisAttributes(polyline.GetVisAttributes());
 
  if (sizeType == G4VSceneHandler::MarkerSizeType::world) {
    std::size_t hash = G4VtkPolydataPolylinePipeline::MakeHash(pVA);
    std::shared_ptr<G4VtkPolydataPolylinePipeline> pl;
 
    if (polylinePipeMap.find(hash) == polylinePipeMap.end()) {
      // Create new pipeline
      pl = std::make_shared<G4VtkPolydataPolylinePipeline>(G4String("name"), vc, pVA);
 
      // Add to map
      polylinePipeMap.insert(std::make_pair(hash, pl));
    }
    else {
      pl = polylinePipeMap[hash];
    }
    pl->SetPolydata(polyline);
  }
 
  else if (sizeType == G4VSceneHandler::MarkerSizeType::screen) {
    std::size_t hash = G4VtkPolydataPolyline2DPipeline::MakeHash(pVA);
    std::shared_ptr<G4VtkPolydataPolyline2DPipeline> pl;
 
    if (polyline2DPipeMap.find(hash) == polyline2DPipeMap.end()) {
      // Create new pipeline
      pl = std::make_shared<G4VtkPolydataPolyline2DPipeline>(G4String("name"), vc, pVA);
 
      // Add to map
      polyline2DPipeMap.insert(std::make_pair(hash, pl));
    }
    else {
      pl = polyline2DPipeMap[hash];
    }
    pl->SetPolydata(polyline);
  }
}

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

AddPrimitive() [3/4]

void G4VtkStore::AddPrimitive	(	const G4Square &	square,
		const G4VtkVisContext &	vc )

Definition at line 368 of file G4VtkStore.cc.

{
  G4VSceneHandler::MarkerSizeType sizeType;
 
  if (vc.fProcessing2D) {
    sizeType = G4VSceneHandler::MarkerSizeType::screen;
  }
  else {
    sizeType = G4VSceneHandler::MarkerSizeType::world;
  }
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA = vc.fViewer->GetApplicableVisAttributes(square.GetVisAttributes());
 
  if (sizeType == G4VSceneHandler::MarkerSizeType::world) {
    std::size_t hash = std::hash<G4VisAttributes>{}(*pVA);
 
    std::shared_ptr<G4VtkPolydataPolygonPipeline> pl;
    if (squarePipeMap.find(hash) == squarePipeMap.end()) {
      // Create new pipeline
      pl = std::make_shared<G4VtkPolydataPolygonPipeline>(G4String("name"), vc, pVA);
 
      // add to map
      squarePipeMap.insert(std::make_pair(hash, pl));
    }
    else {
      pl = squarePipeMap[hash];
    }
 
    // Data data point
    const CLHEP::HepRotation rot = vc.fTransform.getRotation();
    G4Point3D posPrime = rot * square.GetPosition();
    pl->SetPolydataData(vc.fTransform.dx() + posPrime.x(), vc.fTransform.dy() + posPrime.y(),
                        vc.fTransform.dz() + posPrime.z());
  }
}

AddPrimitive() [4/4]

void G4VtkStore::AddPrimitive	(	const G4Text &	text,
		const G4VtkVisContext &	vc )

Definition at line 302 of file G4VtkStore.cc.

{
  G4VSceneHandler::MarkerSizeType sizeType;
  if (vc.fProcessing2D) {
    sizeType = G4VSceneHandler::MarkerSizeType::screen;
  }
  else {
    sizeType = G4VSceneHandler::MarkerSizeType::world;
  }
 
  auto pVA = vc.fViewer->GetApplicableVisAttributes(text.GetVisAttributes());
 
  switch (sizeType) {
    default:
    case (G4VSceneHandler::MarkerSizeType::screen): {
      std::size_t hash = G4VtkTextPipeline::MakeHash(text, vc, pVA);
      auto pl = std::make_shared<G4VtkText2DPipeline>(text, vc, pVA);
      text2DPipeMap.insert(std::make_pair(hash, pl));
      break;
    }
    case G4VSceneHandler::MarkerSizeType::world: {
      std::size_t hash = G4VtkTextPipeline::MakeHash(text, vc, pVA);
      auto pl = std::make_shared<G4VtkTextPipeline>(text, vc, pVA);
      textPipeMap.insert(std::make_pair(hash, pl));
      break;
    }
  }
}

AddPrimitiveAppend()

void G4VtkStore::AddPrimitiveAppend	(	const G4Polyhedron &	polyhedron,
		const G4VtkVisContext &	vc )

Definition at line 473 of file G4VtkStore.cc.

{
  // Empty polyhedron
  if (polyhedron.GetNoFacets() == 0) {
    return;
  }
 
  // Possible the polyhedron already has a transform baked in (definitely the case
  // for scoring meshes. Remove them here
  auto centre = polyhedron.vertexUnweightedMean();
  auto transform = G4Translate3D(-centre.x(), -centre.y(), -centre.z());
 
  auto polyhedronNew = G4Polyhedron(polyhedron);
  auto fTransformNew = G4Transform3D(vc.fTransform*transform.inverse());
 
  polyhedronNew.Transform(transform);
 
  auto hash = G4VtkPolydataInstanceAppendPipeline::MakeHash(polyhedronNew, vc);
  std::shared_ptr<G4VtkPolydataInstanceAppendPipeline> pl;
 
  if (appendPipeMap.find(hash) == appendPipeMap.end()) {
    pl = std::make_shared<G4VtkPolydataInstanceAppendPipeline>(G4String("name"), vc);
    pl->SetPolydata(polyhedronNew);
    appendPipeMap.insert(std::make_pair(hash, pl));
  }
  else {
    pl = appendPipeMap[hash];
  }
 
  G4Transform3D fInvObjTrans = fTransformNew.inverse();
 
  pl->addInstance(fTransformNew.dx(), fTransformNew.dy(), fTransformNew.dz(),
                  fInvObjTrans.xx(), fInvObjTrans.xy(), fInvObjTrans.xz(),
                  fInvObjTrans.yx(), fInvObjTrans.yy(), fInvObjTrans.yz(),
                  fInvObjTrans.zx(), fInvObjTrans.zy(), fInvObjTrans.zz(),
                  0, 0, 0, 0, G4String("null"));
};

Referenced by G4VtkSceneHandler::AddPrimitive().

AddPrimitiveSeparate()

void G4VtkStore::AddPrimitiveSeparate	(	const G4Polyhedron &	polyhedron,
		const G4VtkVisContext &	vc )

Definition at line 405 of file G4VtkStore.cc.

{
  // Return if empty polyhedron
  if (polyhedron.GetNoFacets() == 0) {
    return;
  }
 
  auto hash = G4VtkPolydataPipeline::MakeHash(polyhedron, vc);
 
  auto pl = std::make_shared<G4VtkPolydataPipeline>(G4String("name"), vc);
  pl->SetPolydata(polyhedron);
 
  separatePipeMap.insert(std::make_pair(hash, pl));
 
  const G4VisAttributes* pVA =
    vc.fViewer->GetApplicableVisAttributes(polyhedron.GetVisAttributes());
  G4Color colour = pVA->GetColour();
  G4Transform3D fInvObjTrans = vc.fTransform.inverse();
 
  pl->SetActorTransform(vc.fTransform.dx(), vc.fTransform.dy(), vc.fTransform.dz(),
                        fInvObjTrans.xx(), fInvObjTrans.xy(), fInvObjTrans.xz(),
                        fInvObjTrans.yx(), fInvObjTrans.yy(), fInvObjTrans.yz(),
                        fInvObjTrans.zx(), fInvObjTrans.zy(), fInvObjTrans.zz());
  pl->SetActorColour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), colour.GetAlpha());
}

Referenced by G4VtkSceneHandler::AddPrimitive().

AddPrimitiveTensorGlyph()

void G4VtkStore::AddPrimitiveTensorGlyph	(	const G4Polyhedron &	polyhedron,
		const G4VtkVisContext &	vc )

Definition at line 431 of file G4VtkStore.cc.

{
  // Return if empty polyhedron
  if (polyhedron.GetNoFacets() == 0) {
    return;
  }
 
  // Possible the polyhedron already has a transform baked in (definitely the case
  // for scoring meshes. Remove them here
  auto centre = polyhedron.vertexUnweightedMean();
  auto transform = G4Translate3D(-centre.x(), -centre.y(), -centre.z());
 
  auto polyhedronNew = G4Polyhedron(polyhedron);
  auto fTransformNew = G4Transform3D(vc.fTransform*transform.inverse());
 
  polyhedronNew.Transform(transform);
 
  auto hash = G4VtkPolydataInstanceTensorPipeline::MakeHash(polyhedronNew, vc);
  std::shared_ptr<G4VtkPolydataInstanceTensorPipeline> pl;
 
  if (tensorGlyphPipeMap.find(hash) == tensorGlyphPipeMap.end()) {
    pl = std::make_shared<G4VtkPolydataInstanceTensorPipeline>(G4String("name"), vc);
    pl->SetPolydata(polyhedronNew);
    tensorGlyphPipeMap.insert(std::make_pair(hash, pl));
  }
  else {
    pl = tensorGlyphPipeMap[hash];
  }
 
  G4Transform3D fInvObjTrans = fTransformNew.inverse();
  const G4VisAttributes* pVA =
    vc.fViewer->GetApplicableVisAttributes(polyhedron.GetVisAttributes());
  G4Color colour = pVA->GetColour();
 
  pl->addInstance(fTransformNew.dx(), fTransformNew.dy(), fTransformNew.dz(),
                  fInvObjTrans.xx(), fInvObjTrans.xy(), fInvObjTrans.xz(),
                  fInvObjTrans.yx(), fInvObjTrans.yy(), fInvObjTrans.yz(),
                  fInvObjTrans.zx(), fInvObjTrans.zy(), fInvObjTrans.zz(),
                  colour.GetRed(), colour.GetGreen(), colour.GetBlue(), colour.GetAlpha(),
                  G4String("null"));
}

Referenced by G4VtkSceneHandler::AddPrimitive().

AddPrimitiveTransformBake()

void G4VtkStore::AddPrimitiveTransformBake	(	const G4Polyhedron &	polyhedron,
		const G4VtkVisContext &	vc )

Definition at line 511 of file G4VtkStore.cc.

{
  // Empty polyhedron
  if (polyhedron.GetNoFacets() == 0) {
    return;
  }
 
  // Possible the polyhedron already has a transform baked in (definitely the case
  // for scoring meshes. Remove them here
  auto centre = polyhedron.vertexUnweightedMean();
  auto transform = G4Translate3D(-centre.x(), -centre.y(), -centre.z());
 
  auto polyhedronNew = G4Polyhedron(polyhedron);
  auto fTransformNew = G4Transform3D(vc.fTransform*transform.inverse());
 
  polyhedronNew.Transform(transform);
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA =
    vc.fViewer->GetApplicableVisAttributes(polyhedron.GetVisAttributes());
 
  // Polyhedron colour
  G4Colour colour = pVA->GetColour();
 
  // Hash the vis (alpha) attributes and polyhedron
  std::size_t hash = G4VtkPolydataInstanceBakePipeline::MakeHash(polyhedronNew, vc);
 
  std::shared_ptr<G4VtkPolydataInstanceBakePipeline> pl;
  if (bakePipeMap.find(hash) == bakePipeMap.end()) {
    pl = std::make_shared<G4VtkPolydataInstanceBakePipeline>(G4String("none"), vc);
 
    bakePipeMap.insert(std::make_pair(hash, pl));
  }
  else {
    pl = bakePipeMap[hash];
  }
 
  G4Transform3D fInvObjTrans = fTransformNew.inverse();
  pl->SetPolydata(polyhedronNew);
 
  pl->addInstance(fTransformNew.dx(), fTransformNew.dy(), fTransformNew.dz(),
                  fInvObjTrans.xx(), fInvObjTrans.xy(), fInvObjTrans.xz(),
                  fInvObjTrans.yx(), fInvObjTrans.yy(), fInvObjTrans.yz(),
                  fInvObjTrans.zx(), fInvObjTrans.zy(), fInvObjTrans.zz(),
                  colour.GetRed(), colour.GetGreen(), colour.GetBlue(), colour.GetAlpha(),
                  G4String("null"));
};

Referenced by G4VtkSceneHandler::AddPrimitive().

AddToRenderer()

void G4VtkStore::AddToRenderer

(

vtkRenderer *

renderer

)

Definition at line 809 of file G4VtkStore.cc.

{
  for (const auto& it : polylinePipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : polyline2DPipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : circlePipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : squarePipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : textPipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : text2DPipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : separatePipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : tensorGlyphPipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : appendPipeMap)
    renderer->AddActor(it.second->GetActor());
  for (const auto& it : bakePipeMap)
    renderer->AddActor(it.second->GetActor());
}

Referenced by G4VtkViewer::ExportFormatStore().

Clear()

void G4VtkStore::Clear

(

)

Definition at line 127 of file G4VtkStore.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkStore::Clear() " << name << G4endl;
#endif
 
  for (const auto& v : polylinePipeMap) {
    v.second->Clear();
  }
  polylinePipeMap.clear();
 
  for (const auto& v : polyline2DPipeMap) {
    v.second->Clear();
  }
  polyline2DPipeMap.clear();
 
  for (const auto& v : circlePipeMap) {
    v.second->Clear();
  }
  circlePipeMap.clear();
 
  for (const auto& v : squarePipeMap) {
    v.second->Clear();
  }
  squarePipeMap.clear();
 
  for (const auto& v : textPipeMap) {
    v.second->Clear();
  }
  textPipeMap.clear();
 
  for (const auto& v : text2DPipeMap) {
    v.second->Clear();
  }
  text2DPipeMap.clear();
 
  for (const auto& v : separatePipeMap) {
    v.second->Clear();
  }
  separatePipeMap.clear();
 
  for (const auto& v : tensorGlyphPipeMap) {
    v.second->Clear();
  }
  tensorGlyphPipeMap.clear();
 
  for (const auto& v : appendPipeMap) {
    v.second->Clear();
  }
  appendPipeMap.clear();
 
  for (const auto& v : bakePipeMap) {
    v.second->Clear();
  }
  bakePipeMap.clear();
}

Referenced by G4VtkSceneHandler::ClearStore(), G4VtkSceneHandler::ClearTransientStore(), G4VtkViewer::ClearView(), and ~G4VtkStore().

ClearNonG4()

void G4VtkStore::ClearNonG4

(

)

Definition at line 184 of file G4VtkStore.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkStore::Clear() " << name << G4endl;
#endif
 
  for (const auto& v : imagePipeMap) {
    v.second->Clear();
  }
  imagePipeMap.clear();
 
  for (const auto& v : sideloadPipeMap) {
    v.second->Clear();
  }
  sideloadPipeMap.clear();
}

Referenced by G4VtkMessenger::SetNewValue().

GetAppendPipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataInstanceAppendPipeline > > & G4VtkStore::GetAppendPipeMap ( )

inline

Definition at line 160 of file G4VtkStore.hh.

    {
      return appendPipeMap;
    }

GetBakePipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataInstanceBakePipeline > > & G4VtkStore::GetBakePipeMap ( )

inline

Definition at line 164 of file G4VtkStore.hh.

    {
      return bakePipeMap;
    }

GetBounds()

void G4VtkStore::GetBounds

(

G4double

maxBound[6]

)

Definition at line 777 of file G4VtkStore.cc.

{
  G4double maxBound[6] = {1e99, -1e99, 1e99, -1e99, 1e99, -1e99};
 
  for (const auto& v : separatePipeMap) {
    auto b = v.second->GetBounds();
    MaxBounds(maxBound, b);
  }
 
  for (const auto& v : tensorGlyphPipeMap) {
    auto b = v.second->GetBounds();
    MaxBounds(maxBound, b);
  }
 
  for (const auto& v : appendPipeMap) {
    auto b = v.second->GetBounds();
    MaxBounds(maxBound, b);
  }
 
  for (const auto& v : bakePipeMap) {
    auto b = v.second->GetBounds();
    MaxBounds(maxBound, b);
  }
 
  maxBoundIn[0] = maxBound[0];
  maxBoundIn[1] = maxBound[1];
  maxBoundIn[2] = maxBound[2];
  maxBoundIn[3] = maxBound[3];
  maxBoundIn[4] = maxBound[4];
  maxBoundIn[5] = maxBound[5];
}

Referenced by G4VtkViewer::AddClipperPlaneWidget(), and G4VtkViewer::AddCutterPlaneWidget().

GetPolydataPolygonPipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataPolygonPipeline > > & G4VtkStore::GetPolydataPolygonPipeMap ( )

inline

Definition at line 148 of file G4VtkStore.hh.

    {
      return squarePipeMap;
    }

GetPolydataSpherePipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataSpherePipeline > > & G4VtkStore::GetPolydataSpherePipeMap ( )

inline

Definition at line 143 of file G4VtkStore.hh.

    {
      return circlePipeMap;
    }

GetPolyline2DPipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataPolyline2DPipeline > > & G4VtkStore::GetPolyline2DPipeMap ( )

inline

Definition at line 139 of file G4VtkStore.hh.

    {
      return polyline2DPipeMap;
    }

GetPolylinePipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataPolylinePipeline > > & G4VtkStore::GetPolylinePipeMap ( )

inline

Definition at line 135 of file G4VtkStore.hh.

    {
      return polylinePipeMap;
    }

GetSeparatePipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataPipeline > > & G4VtkStore::GetSeparatePipeMap ( )

inline

Definition at line 152 of file G4VtkStore.hh.

    {
      return separatePipeMap;
    }

Referenced by G4VtkViewer::ExportVTPCutter().

GetTensorPipeMap()

std::map< std::size_t, std::shared_ptr< G4VtkPolydataInstanceTensorPipeline > > & G4VtkStore::GetTensorPipeMap ( )

inline

Definition at line 156 of file G4VtkStore.hh.

    {
      return tensorGlyphPipeMap;
    }

Modified()

void G4VtkStore::Modified

(

)

Definition at line 90 of file G4VtkStore.cc.

{
#ifdef G4VTKDEBUG
  G4cout << "G4VtkStore::Modified() " << name << G4endl;
#endif
 
  for (const auto& it : polylinePipeMap)
    it.second->Modified();
 
  for (const auto& it : polyline2DPipeMap)
    it.second->Modified();
 
  for (const auto& it : circlePipeMap)
    it.second->Modified();
 
  for (const auto& it : squarePipeMap)
    it.second->Modified();
 
  for (const auto& it : textPipeMap)
    it.second->Modified();
 
  for (const auto& it : text2DPipeMap)
    it.second->Modified();
 
  for (const auto& it : separatePipeMap)
    it.second->Modified();
 
  for (const auto& it : tensorGlyphPipeMap)
    it.second->Modified();
 
  for (const auto& it : appendPipeMap)
    it.second->Modified();
 
  for (const auto& it : bakePipeMap)
    it.second->Modified();
}

Referenced by G4VtkSceneHandler::Modified().

Print()

void G4VtkStore::Print

(

)

Definition at line 201 of file G4VtkStore.cc.

{
  G4cout << "G4VtkStore::Print() " << name << std::endl;
  G4cout << "G4VtkStore::Print() polylinePipeMap size        > " << polylinePipeMap.size()
         << G4endl;
  G4cout << "G4VtkStore::Print() polyline2DPipeMap size      > " << polyline2DPipeMap.size()
         << G4endl;
  G4cout << "G4VtkStore::Print() circlePipeMap size          > " << circlePipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() squarePipeMap size          > " << squarePipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() textPipeMap size            > " << textPipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() text2DPipeMap size          > " << text2DPipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() separatePipeMap size        > " << separatePipeMap.size()
         << G4endl;
  G4cout << "G4VtkStore::Print() tensorGlyphPipeMap size     > " << tensorGlyphPipeMap.size()
         << G4endl;
  G4cout << "G4VtkStore::Print() transformAppendPipeMap size > " << appendPipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() bakePipeMap size            > " << bakePipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() ugridPipeMap size           > " << ugridPipeMap.size() << G4endl;
  G4cout << "G4VtkStore::Print() imagePipeMap size           > " << imagePipeMap.size() << G4endl;
 
  for (const auto& it : polylinePipeMap)
    it.second->Print();
 
  for (const auto& it : polyline2DPipeMap)
    it.second->Print();
 
  for (const auto& it : circlePipeMap)
    it.second->Print();
 
  for (const auto& it : squarePipeMap)
    it.second->Print();
 
  for (const auto& it : separatePipeMap)
    it.second->Print();
 
  for (const auto& it : tensorGlyphPipeMap)
    it.second->Print();
 
  for (const auto& it : appendPipeMap)
    it.second->Print();
 
  for (const auto& it : bakePipeMap)
    it.second->Print();
 
  for (const auto& it : ugridPipeMap) {
    G4cout << it.first << G4endl;
    it.second->Print();
  }
 
  for (const auto& it : imagePipeMap)
    it.second->Print();
}

Referenced by G4VtkViewer::Print().

RemoveClipper()

void G4VtkStore::RemoveClipper

(

G4String

name

)

Definition at line 653 of file G4VtkStore.cc.

{}

Referenced by G4VtkViewer::DisableClipper().

RemoveCutter()

void G4VtkStore::RemoveCutter

(

G4String

name

)

Definition at line 729 of file G4VtkStore.cc.

{}

Referenced by G4VtkViewer::DisableCutter().

UpdateClipper()

void G4VtkStore::UpdateClipper	(	G4String	name,
		const G4Plane3D &	plane )

Definition at line 610 of file G4VtkStore.cc.

{
  for (const auto& v : separatePipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkClipClosedSurfacePipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
 
  for (const auto& v : tensorGlyphPipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkClipClosedSurfacePipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
 
  for (const auto& v : appendPipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkClipClosedSurfacePipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
 
  for (const auto& v : bakePipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkClipClosedSurfacePipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
}

Referenced by UpdatePlanePipelines().

UpdateCutter()

void G4VtkStore::UpdateCutter	(	G4String	name,
		const G4Plane3D &	plane )

Definition at line 686 of file G4VtkStore.cc.

{
  for (const auto& v : separatePipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkCutterPipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
 
  for (const auto& v : tensorGlyphPipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkCutterPipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
 
  for (const auto& v : appendPipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkCutterPipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
 
  for (const auto& v : bakePipeMap) {
    auto children = v.second->GetChildPipelines();
    for (auto c : children) {
      if (c->GetName() == nameIn) {
        auto cc = dynamic_cast<G4VtkCutterPipeline*>(c);
        cc->SetPlane(plane);
      }
    }
  }
}

Referenced by UpdatePlanePipelines().

UpdatePlanePipelines()

void G4VtkStore::UpdatePlanePipelines	(	G4String	name,
		G4String	type,
		const G4Plane3D	plane )

Definition at line 569 of file G4VtkStore.cc.

{
  if (type == "clipper") {
    UpdateClipper(nameIn, plane);
  }
  else if (type == "cutter") {
    UpdateCutter(nameIn, plane);
  }
}

Referenced by vtkIPWCallback::Execute().

---

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

• G4VtkStore.hh
• G4VtkStore.cc