G4VtkStore.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// Created by Stewart Boogert on 13/11/2021.
//
 
#ifndef G4VTKSTORE_HH
#define G4VTKSTORE_HH
 
#include "G4Transform3D.hh"
#include "G4ViewParameters.hh"
 
#include <vtkActor.h>
#include <vtkActor2D.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkCleanPolyData.h>
#include <vtkClipClosedSurface.h>
#include <vtkClipPolyData.h>
#include <vtkDataSetMapper.h>
#include <vtkDoubleArray.h>
#include <vtkFeatureEdges.h>
#include <vtkNamedColors.h>
#include <vtkPlane.h>
#include <vtkPlaneCollection.h>
#include <vtkPointData.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkPolyDataNormals.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkStripper.h>
#include <vtkStructuredGrid.h>
#include <vtkTensorGlyphColor.h>
#include <vtkTriangleFilter.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkSmartPointer.h>
 
#include <map>
#include <vector>
 
class G4VViewer;
class G4VtkViewer;
class G4Polyline;
class G4Text;
class G4Circle;
class G4Square;
class G4Polyhedron;
class G4VisAttributes;
class G4VtkVisContext;
class G4Mesh;
 
class G4VtkPolydataPipeline;
class G4VtkPolydataPolylinePipeline;
class G4VtkPolydataPolyline2DPipeline;
class G4VtkPolydataSpherePipeline;
class G4VtkPolydataPolygonPipeline;
class G4VtkPolydataInstanceTensorPipeline;
class G4VtkPolydataInstanceAppendPipeline;
class G4VtkPolydataInstanceBakePipeline;
class G4VtkClipCloseSurfacePipeline;
class G4VtkImagePipeline;
class G4VtkTextPipeline;
class G4VtkText2DPipeline;
class G4VtkUnstructuredGridPipeline;
 
template<typename>
class vtkSmartPointer;
 
class G4VtkTensorGlyphPolydataPipeline;
 
class G4VtkStore
{
  public:
    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()
    {
      return polylinePipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPolyline2DPipeline>>& GetPolyline2DPipeMap()
    {
      return polyline2DPipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataSpherePipeline>>& GetPolydataSpherePipeMap()
    {
      return circlePipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPolygonPipeline>>&
    GetPolydataPolygonPipeMap()
    {
      return squarePipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPipeline>>& GetSeparatePipeMap()
    {
      return separatePipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataInstanceTensorPipeline>>& GetTensorPipeMap()
    {
      return tensorGlyphPipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataInstanceAppendPipeline>>& GetAppendPipeMap()
    {
      return appendPipeMap;
    }
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataInstanceBakePipeline>>& GetBakePipeMap()
    {
      return bakePipeMap;
    }
 
  private:
    G4String name;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPolylinePipeline>> polylinePipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPolyline2DPipeline>> polyline2DPipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataSpherePipeline>> circlePipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPolygonPipeline>> squarePipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkTextPipeline>> textPipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkText2DPipeline>> text2DPipeMap;
 
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPipeline>> separatePipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataInstanceTensorPipeline>> tensorGlyphPipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataInstanceAppendPipeline>> appendPipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataInstanceBakePipeline>> bakePipeMap;
 
    std::map<G4String, std::shared_ptr<G4VtkUnstructuredGridPipeline>> ugridPipeMap;
 
    std::map<G4String, std::shared_ptr<G4VtkImagePipeline>> imagePipeMap;
    std::map<std::size_t, std::shared_ptr<G4VtkPolydataPipeline>> sideloadPipeMap;
};
 
#endif  // G4VTKSTORE_HH