lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2023-12-08 10:43:34 +01:00
parent dd1f179cda
commit 860a2b92bf
3962 changed files with 139318 additions and 164259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/visualization/Vtk/History
+29
View File
@@ -6,6 +6,35 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023--07 Stewart Boogert (visVtk-V11-01-15)
- Fixed missing circles in rendering (introduced in visVTK-V11-01-13)
## 2023-11-03 Ben Morgan (visVTK-V11-01-14)
- Add missing dependencies on internal modules
- Remove files no longer being built
## 2023-10-27 Stewart Boogert (vtkVtk-V11-01-13)
- Fixed gcc shadow warnings
## 2023-09-27 Stewart Boogert (visVtk-V11-01-12)
- Updated VTK viewer
- Added off screen rendering
- Fixed bug which locked UI interaction with VtkNative viewer
- Many 3D output formats working including GLTF, PLY, OBJ, VRML
- Remove cuboid offset present in rectilinear scoring meshes (caused an explosion of draw calls)
- Fixed spherical marker size
- Added a VTK example to highlight capabilities
## 2023-08-18 John Allison (visVtk-V11-01-11)
- G4VtkQt:
- Simplify IsUISessionCompatible.
- Cosmetic improvement to align with Vtk economical coding style.
## 2023-08-14 John Allison (visVtk-V11-01-10)
- G4VtkQt:
- Simplify IsUISessionCompatible.
- Exploit new method, G4UImanager::GetBaseSession (intercoms-V11-01-07).
## 2023-05-23 Gabriele Cosmo (visVtk-V11-01-09)
- Fixed compilation warnings for implicit type conversions on macOS/XCode>=14.1.
source/visualization/Vtk/include/private/G4VtkClipperClosedPipeline.hh → source/visualization/Vtk/include/G4VtkOffscreen.hh
+7 -19
View File
@@ -23,28 +23,16 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
#ifndef G4VTKCLIPPERCLOSEDPIPELINE_HH
#define G4VTKCLIPPERCLOSEDPIPELINE_HH
#pragma once
#include "G4VtkClipClosedSurfacePipeline.hh"
#include "G4VGraphicsSystem.hh"
class vtkAppendPolyData;
class G4VtkClipperClosedPipeline : public G4VtkPipeline
class G4VtkOffscreen : public G4VGraphicsSystem
{
public:
G4VtkClipperClosedPipeline(vtkSmartPointer<vtkPolyDataAlgorithm> filter);
~G4VtkClipperClosedPipeline() override = default;
void Print(){};
void Modified();
void Clear(){};
private:
vtkSmartPointer<vtkPlane> plane;
vtkSmartPointer<vtkClipPolyData> clipper;
vtkSmartPointer<vtkAppendPolyData> appendFilter;
vtkSmartPointer<vtkPolyDataMapper> mapper;
G4VtkOffscreen();
~G4VtkOffscreen() override = default;
G4VSceneHandler* CreateSceneHandler(const G4String& name = "") override;
G4VViewer* CreateViewer(G4VSceneHandler&, const G4String& name = "") override;
};
#endif // G4VTKCLIPPERCLOSEDPIPELINE_HH
source/visualization/Vtk/include/private/G4VVtkPipeline.hh
+2 -2
View File
@@ -49,14 +49,14 @@ inline void hash_combine(std::size_t& seed, const T& v, Rest... rest)
template<>
struct hash<G4String>
{
std::size_t operator()(const G4String& string) const
std::size_t operator()(const G4String& strng) const
{
using std::hash;
using std::size_t;
std::size_t h = 0;
for (char const& c : string) {
for (char const& c : strng) {
std::hash_combine(h, c);
}
source/visualization/Vtk/include/private/G4VtkClipOpenPipeline.hh
+1 -1
View File
@@ -45,7 +45,7 @@ class G4VtkClipOpenPipeline : public G4VVtkPipeline
vtkSmartPointer<vtkPolyDataAlgorithm> filter, G4bool useVcColour = false);
~G4VtkClipOpenPipeline() override = default;
void SetPlane(G4Plane3D& plane);
void SetPlane(const G4Plane3D& plane);
void SetPlane(G4double x, G4double y, G4double z, G4double nx, G4double ny, G4double nz);
void TransformPlane(G4double dx, G4double dy, G4double dz, G4double r00, G4double r01,
G4double r02, G4double r10, G4double r11, G4double r12, G4double r20,
source/visualization/Vtk/include/private/G4VtkInteractorStyle.hh
+20 -7
View File
@@ -29,33 +29,46 @@
#ifndef G4VTKINTERACTORSTYLE_HH
#define G4VTKINTERACTORSTYLE_HH
#include "G4ios.hh"
#include "vtkInteractionStyleModule.h" // For export macro
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkInteractorStyleMultiTouchCamera.h"
#include <vtkObjectFactory.h>
// Define interaction style
class VTKINTERACTIONSTYLE_EXPORT G4VtkInteractorStyle : public vtkInteractorStyleTrackballCamera
class VTKINTERACTIONSTYLE_EXPORT G4VtkInteractorStyle : public vtkInteractorStyleMultiTouchCamera
{
public:
static G4VtkInteractorStyle* New();
vtkTypeMacro(G4VtkInteractorStyle, vtkInteractorStyleTrackballCamera)
vtkTypeMacro(G4VtkInteractorStyle, vtkInteractorStyleMultiTouchCamera)
void OnLeftButtonDown() override
void OnMouseMove() override
{
vtkInteractorStyleMultiTouchCamera::OnMouseMove();
}
void OnLeftButtonDown() override
{
// Forward events
vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
vtkInteractorStyleMultiTouchCamera::OnLeftButtonDown();
}
void OnLeftButtonUp() override
{
// Forward events
vtkInteractorStyleMultiTouchCamera::OnLeftButtonUp();
}
void OnMiddleButtonDown() override
{
// Forward events
vtkInteractorStyleTrackballCamera::OnMiddleButtonDown();
vtkInteractorStyleMultiTouchCamera::OnMiddleButtonDown();
}
void OnRightButtonDown() override
{
// Forward events
vtkInteractorStyleTrackballCamera::OnRightButtonDown();
vtkInteractorStyleMultiTouchCamera::OnRightButtonDown();
}
};
source/visualization/Vtk/include/private/G4VtkMessenger.hh
+3
View File
@@ -54,17 +54,20 @@ class G4VtkMessenger : public G4UImessenger
G4UIcommand* fpCommandExport;
G4UIcommand* fpCommandExportCutter;
G4UIcommand* fpCommandDebugPrint;
G4UIcommand* fpCommandInteractorStart;
G4UIdirectory* fpDirectorySet;
G4UIcommand* fpCommandPolyhedronPipeline;
G4UIcmdWithABool* fpCommandWarnings;
G4UIcmdWithABool* fpCommandHUD;
G4UIcmdWithABool* fpCameraOrientation;
G4UIcommand* fpCommandClipper;
G4UIcommand* fpCommandCutter;
G4UIcommand* fpCommandShadow;
G4UIdirectory* fpDirectoryAdd;
G4UIcommand* fpCommandImageOverlay;
G4UIcommand* fpCommandGeometryOverlay;
};
#endif
source/visualization/Vtk/include/private/G4VtkOffscreenViewer.hh
+39
View File
@@ -0,0 +1,39 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#pragma once
#include "G4VViewer.hh"
#include "G4VtkViewer.hh"
class G4VtkOffscreenViewer : public G4VtkViewer
{
public:
G4VtkOffscreenViewer(G4VSceneHandler&, const G4String& name);
~G4VtkOffscreenViewer() override;
void Initialise() override;
void FinishView() override;
};
source/visualization/Vtk/include/private/G4VtkPolydataInstanceAppendPipeline.hh
+1
View File
@@ -42,6 +42,7 @@ class G4VtkPolydataInstanceAppendPipeline : public G4VtkPolydataInstancePipeline
void Print() override;
using G4VtkPolydataInstancePipeline::addInstance;
void addInstance(G4double dx, G4double dy, G4double dz, G4double r00, G4double r01,
G4double r02, G4double r10, G4double r11, G4double r12, G4double r20,
G4double r21, G4double r22, G4double r, G4double g, G4double b, G4double a,
source/visualization/Vtk/include/private/G4VtkPolydataInstanceBakePipeline.hh
+2
View File
@@ -39,7 +39,9 @@ class G4VtkPolydataInstanceBakePipeline : public G4VtkPolydataInstancePipeline
void Print() override;
using G4VtkPolydataInstancePipeline::SetPolydata;
void SetPolydata(const G4Polyhedron& polyhedron) override;
using G4VtkPolydataInstancePipeline::addInstance;
void addInstance(G4double dx, G4double dy, G4double dz, G4double r00, G4double r01,
G4double r02, G4double r10, G4double r11, G4double r12, G4double r20,
G4double r21, G4double r22, G4double r, G4double g, G4double b, G4double a,
source/visualization/Vtk/include/private/G4VtkPolydataInstanceTensorPipeline.hh
+1
View File
@@ -40,6 +40,7 @@ class G4VtkPolydataInstanceTensorPipeline : public G4VtkPolydataInstancePipeline
void Print() override;
static std::size_t MakeHash(const G4Polyhedron& p, const G4VtkVisContext& vc);
protected:
source/visualization/Vtk/include/private/G4VtkPolydataPipeline.hh
+1
View File
@@ -67,6 +67,7 @@ class G4VtkPolydataPipeline : public G4VVtkPipeline
virtual void SetPolydata(const G4Polyhedron& polyhedron);
virtual void SetPolydata(const G4Polyline& polyline);
virtual void SetPolydata(vtkPolyData *polydata);
virtual void SetPolydataData(const G4Point3D& p);
virtual void SetPolydataData(double x, double y, double z);
source/visualization/Vtk/include/private/G4VtkPolydataPolygonPipeline.hh
-1
View File
@@ -42,7 +42,6 @@ class G4VtkPolydataPolygonPipeline : public G4VtkPolydataPipeline
static std::size_t MakeHash(const G4VisAttributes* va);
protected:
G4VisAttributes* pVisAttributes;
};
#endif // GEANT4_G4POLYDATAPOLYGONPIPELINE_HH
source/visualization/Vtk/include/private/G4VtkPolydataPolyline2DPipeline.hh
+1 -1
View File
@@ -44,6 +44,7 @@ class G4VtkPolydataPolyline2DPipeline : public G4VtkPolydataPipeline
~G4VtkPolydataPolyline2DPipeline() override = default;
void Modified() override;
using G4VtkPolydataPipeline::SetPolydata;
void SetPolydata(const G4Polyline& polyline) override;
vtkSmartPointer<vtkActor2D> GetActor2D() { return actor2D; }
@@ -53,7 +54,6 @@ class G4VtkPolydataPolyline2DPipeline : public G4VtkPolydataPipeline
static std::size_t MakeHash(const G4VisAttributes* va);
protected:
G4VisAttributes* pVisAttributes;
vtkSmartPointer<vtkPolyDataMapper2D> mapper2D;
vtkSmartPointer<vtkActor2D> actor2D;
};
source/visualization/Vtk/include/private/G4VtkPolydataPolylinePipeline.hh
-1
View File
@@ -44,7 +44,6 @@ class G4VtkPolydataPolylinePipeline : public G4VtkPolydataPipeline
static std::size_t MakeHash(const G4VisAttributes* va);
protected:
G4VisAttributes* pVisAttributes;
};
#endif // G4VTKPOLYDATAPOLYLINEPIPELINE_HH
source/visualization/Vtk/include/private/G4VtkPolydataSpherePipeline.hh
-1
View File
@@ -44,7 +44,6 @@ class G4VtkPolydataSpherePipeline : public G4VtkPolydataPipeline
static std::size_t MakeHash(const G4VisAttributes* va);
protected:
G4VisAttributes* pVisAttributes;
};
#endif // G4VTKPOLYDATASPHEREPIPELINE_HH
source/visualization/Vtk/include/private/G4VtkQtSceneHandler.hh
+1
View File
@@ -41,6 +41,7 @@ class G4VtkQtSceneHandler : public G4VtkSceneHandler
////////////////////////////////////////////////////////////////
// Implementation of pure virtual functions...
using G4VtkSceneHandler::AddPrimitive;
void AddPrimitive(const G4Polyline&) override;
void AddPrimitive(const G4Text&) override;
void AddPrimitive(const G4Circle&) override;
source/visualization/Vtk/include/private/G4VtkSceneHandler.hh
+4
View File
@@ -82,6 +82,7 @@ class G4VtkSceneHandler : public G4VSceneHandler
////////////////////////////////////////////////////////////////
// Required implementation of pure virtual functions...
using G4VSceneHandler::AddPrimitive;
void AddPrimitive(const G4Polyline&) override;
void AddPrimitive(const G4Text&) override;
void AddPrimitive(const G4Circle&) override;
@@ -96,7 +97,10 @@ class G4VtkSceneHandler : public G4VSceneHandler
G4VSceneHandler::AddPrimitive(polymarker);
}
using G4VSceneHandler::AddSolid;
void AddSolid(const G4Box& box) override;
using G4VSceneHandler::AddCompound;
void AddCompound(const G4Mesh& mesh) override;
void Modified();
source/visualization/Vtk/include/private/G4VtkUnstructuredGridPipeline.hh
+76 -16
View File
@@ -26,16 +26,27 @@
#ifndef G4VTKUNSTRUCTUREDGRIDPIPELINE_HH
#define G4VTKUNSTRUCTUREDGRIDPIPELINE_HH
#include <map>
#include <vector>
#include "G4VVtkPipeline.hh"
#include "G4PseudoScene.hh"
#include "vtkSmartPointer.h"
#include "vtkPoints.h"
#include "vtkCharArray.h"
#include "vtkDoubleArray.h"
#include "vtkUnstructuredGrid.h"
#include "vtkStaticCleanUnstructuredGrid.h"
#include "vtkLookupTable.h"
#include "vtkDiscretizableColorTransferFunction.h"
class vtkDoubleArray;
class vtkClipDataSet;
class vtkDataSetMapper;
class vtkUnstructuredGridVolumeMapper;
class vtkUnstructuredGridVolumeRayCastMapper;
class vtkUnstructuredGridVolumeZSweepMapper;
class vtkOpenGLProjectedTetrahedraMapper;
class vtkActor;
class G4Mesh;
@@ -47,6 +58,11 @@ class G4VtkUnstructuredGridPipeline : public G4VVtkPipeline
~G4VtkUnstructuredGridPipeline() = default;
void AddFilter(vtkSmartPointer<vtkUnstructuredGridAlgorithm> f) { filters.push_back(f); }
vtkSmartPointer<vtkUnstructuredGridAlgorithm> GetFilter(G4int iFilter) { return filters[iFilter]; }
std::size_t GetNumberOfFilters() { return filters.size(); }
vtkSmartPointer<vtkUnstructuredGridAlgorithm> GetFinalFilter() { return filters[filters.size() - 1]; }
void Modified() {};
void Clear() {};
void Print() {};
@@ -62,11 +78,27 @@ class G4VtkUnstructuredGridPipeline : public G4VVtkPipeline
PseudoSceneVtkBase(G4PhysicalVolumeModel* pvModel, // input
G4int depth,
vtkPoints *points,
vtkDoubleArray *cellValues,
vtkUnstructuredGrid *unstructuredGrid) // input...the following are outputs by reference
: fpPVModel(pvModel), fDepth(depth), fpPoints(points),
fpGrid(unstructuredGrid), fpCellValues(cellValues)
vtkDoubleArray *pointColourValues,
vtkDoubleArray *cellColourValues,
vtkDoubleArray *pointColourIndices,
vtkDoubleArray *cellColourIndices,
vtkDiscretizableColorTransferFunction *colourLUT,
vtkUnstructuredGrid *unstructuredGrid) // input...the following are outputs by reference
: fpPVModel(pvModel), fDepth(depth), fpPoints(points), fpGrid(unstructuredGrid),
fpPointColourValues(pointColourValues), fpCellColourValues(cellColourValues),
fpPointColourIndices(pointColourIndices), fpCellColourIndices(cellColourIndices),
fpColourLUT(colourLUT)
{}
G4int GetNumberOfPoints() {return iPoint;}
G4int GetNumberOfCells() {return iCell;}
G4int GetNumberOfAddedCells() {return iCellAdd;}
void DumpColourMap() {
for(auto i : fpColourMap) {
G4cout << i.first << " " << i.second << G4endl;
}
}
protected:
using G4PseudoScene::AddSolid; // except for...
void AddSolid(const G4VSolid& /*solid*/) override {};
@@ -78,17 +110,31 @@ class G4VtkUnstructuredGridPipeline : public G4VVtkPipeline
G4int fDepth;
vtkSmartPointer<vtkPoints> fpPoints;
vtkSmartPointer<vtkUnstructuredGrid> fpGrid;
vtkSmartPointer<vtkDoubleArray> fpCellValues;
vtkSmartPointer<vtkDoubleArray> fpPointColourValues;
vtkSmartPointer<vtkDoubleArray> fpCellColourValues;
vtkSmartPointer<vtkDoubleArray> fpPointColourIndices;
vtkSmartPointer<vtkDoubleArray> fpCellColourIndices;
std::map<std::size_t,double> fpColourMap;
vtkSmartPointer<vtkDiscretizableColorTransferFunction> fpColourLUT;
std::vector<G4ThreeVector> fpPointVector;
std::map<std::size_t, std::size_t> fpPointMap;
G4int iPoint = 0;
G4int iCell = 0;
G4int iCellAdd = 0;
};
class PseudoSceneForTetCells: public PseudoSceneVtkBase {
public:
PseudoSceneForTetCells(G4PhysicalVolumeModel* pvModel, // input
G4int depth,
vtkPoints *points,
vtkDoubleArray *cellValues,
vtkDoubleArray *pointColourValues,
vtkDoubleArray *cellColourValues,
vtkDoubleArray *pointColourIndices,
vtkDoubleArray *cellColourIndices,
vtkDiscretizableColorTransferFunction *colourLUT,
vtkUnstructuredGrid *unstructuredGrid) // input...the following are outputs by reference
: PseudoSceneVtkBase(pvModel,depth,points,cellValues,unstructuredGrid)
: PseudoSceneVtkBase(pvModel,depth,points,pointColourValues,cellColourValues,
pointColourIndices, cellColourIndices, colourLUT, unstructuredGrid)
{}
private:
using G4PseudoScene::AddSolid; // except for...
@@ -98,11 +144,16 @@ class G4VtkUnstructuredGridPipeline : public G4VVtkPipeline
class PseudoSceneForCubicalCells: public PseudoSceneVtkBase {
public:
PseudoSceneForCubicalCells(G4PhysicalVolumeModel* pvModel, // input
G4int depth,
vtkPoints *points,
vtkDoubleArray *cellValues,
vtkUnstructuredGrid *unstructuredGrid) // input...the following are outputs by reference
: PseudoSceneVtkBase(pvModel,depth,points,cellValues,unstructuredGrid)
G4int depth,
vtkPoints *points,
vtkDoubleArray *pointColourValues,
vtkDoubleArray *cellColourValues,
vtkDoubleArray *pointColourIndices,
vtkDoubleArray *cellColourIndices,
vtkDiscretizableColorTransferFunction *colourLUT,
vtkUnstructuredGrid *unstructuredGrid) // input...the following are outputs by reference
: PseudoSceneVtkBase(pvModel,depth,points,pointColourValues,cellColourValues,
pointColourIndices,cellColourIndices,colourLUT, unstructuredGrid)
{}
private:
using G4PseudoScene::AddSolid; // except for...
@@ -112,12 +163,21 @@ class G4VtkUnstructuredGridPipeline : public G4VVtkPipeline
private:
vtkSmartPointer<vtkPoints> points;
vtkSmartPointer<vtkDoubleArray> pointValues;
vtkSmartPointer<vtkDoubleArray> cellValues;
vtkSmartPointer<vtkDoubleArray> pointColourValues;
vtkSmartPointer<vtkDoubleArray> cellColourValues;
vtkSmartPointer<vtkDoubleArray> pointColourIndices;
vtkSmartPointer<vtkDoubleArray> cellColourIndices;
vtkSmartPointer<vtkDiscretizableColorTransferFunction> colourLUT;
vtkSmartPointer<vtkUnstructuredGrid> unstructuredGrid;
vtkSmartPointer<vtkStaticCleanUnstructuredGrid> cleanUnstructuredGrid;
std::vector<vtkSmartPointer<vtkUnstructuredGridAlgorithm>> filters; // derived types can store filters in this vector
vtkSmartPointer<vtkStaticCleanUnstructuredGrid> clean;
vtkSmartPointer<vtkClipDataSet> clip;
vtkSmartPointer<vtkDataSetMapper> mapper;
vtkSmartPointer<vtkUnstructuredGridVolumeRayCastMapper> volumeMapper;
vtkSmartPointer<vtkActor> actor;
vtkSmartPointer<vtkVolume> volume;
};
#endif // G4VTKUNSTRUCTUREDGRIDPIPELINE_HH
source/visualization/Vtk/include/private/G4VtkUtility.hh
+4
View File
@@ -45,5 +45,9 @@ vtkSmartPointer<vtkMatrix4x4> G4Transform3DToVtkMatrix4x4(const G4Transform3D& g
vtkSmartPointer<vtkPlane> G4Plane3DToVtkPlane(const G4Plane3D& g4plane);
G4Plane3D VtkPlaneToG4Plane3D(vtkPlane* vtkPlane);
void MaxBounds(G4double* maxBound, G4double* boundToCheck);
std::size_t MakeHash(const G4ThreeVector &v);
std::size_t MakeHash(const G4Colour &c);
#endif // G4VTKUTILITY_HH
source/visualization/Vtk/include/private/G4VtkViewer.hh
+29 -9
View File
@@ -82,18 +82,18 @@ class vtkGeant4Callback : public vtkCommand
auto cp = cam->GetPosition();
auto fp = cam->GetFocalPoint();
auto ud = cam->GetViewUp();
auto ps = cam->GetParallelScale();
auto cd = std::sqrt(std::pow(cp[0] - fp[0], 2) + std::pow(cp[1] - fp[1], 2)
+ std::pow(cp[2] - fp[2], 2));
fVP->SetCurrentTargetPoint(G4Point3D(fp[0], fp[1], fp[2]));
fVP->SetViewpointDirection(
(G4Point3D(cp[0], cp[1], cp[2]) - G4Point3D(fp[0], fp[1], fp[2])).unit());
fVP->SetViewpointDirection((G4Point3D(cp[0], cp[1], cp[2]) - G4Point3D(fp[0], fp[1], fp[2])).unit());
fVP->SetUpVector(G4Vector3D(ud[0], ud[1], ud[2]));
if (cam->GetParallelProjection() != 0) {
fVP->SetZoomFactor(parallelScale / cam->GetParallelScale());
fVP->SetZoomFactor(parallelScale / ps);
}
else {
auto cd = std::sqrt(std::pow(cp[0] - fp[0], 2) + std::pow(cp[1] - cp[1], 2)
+ std::pow(cp[2] - cp[2], 2));
fVP->SetZoomFactor(cameraDistance / cd);
}
}
@@ -127,8 +127,12 @@ class vtkInfoCallback : public vtkCommand
double* foc = cam->GetFocalPoint();
double viewAngle = cam->GetViewAngle();
double distance = cam->GetDistance();
double near;
double far;
cam->GetClippingRange(near,far);
double parallelScale = cam->GetParallelScale();
if (pos == nullptr) return;
// Get current time
@@ -145,10 +149,11 @@ class vtkInfoCallback : public vtkCommand
"camera focal point : %.1f %.1f %.1f \n"
"view angle : %.1f\n"
"distance : %.1f\n"
"clip near/far : %.1f %.1f\n"
"parallel scale : %.1f\n"
"number actors : %i\n"
"fps : %.1f",
pos[0], pos[1], pos[2], foc[0], foc[1], foc[2], viewAngle, distance, parallelScale,
pos[0], pos[1], pos[2], foc[0], foc[1], foc[2], viewAngle, distance, near, far, parallelScale,
nActors, fps);
if (this->TextActor != nullptr) {
this->TextActor->SetInput(this->TextBuff);
@@ -219,6 +224,7 @@ class G4VtkViewer : public G4VViewer
void ExportVRMLScene(G4String);
void ExportVTPScene(G4String);
void ExportGLTFScene(G4String);
void ExportJSONRenderWindowScene(G4String);
void ExportVTPCutter(G4String fileName);
void ExportFormatStore(G4String fileName, G4String store);
@@ -251,9 +257,15 @@ class G4VtkViewer : public G4VViewer
const G4double imageBottomLeft[2], const G4double worldBottomLeft[2],
const G4double imageTopRight[2], const G4double worldTopRight[2],
const G4double rot[3], const G4double trans[3]);
void Add3DOverlay(const G4String& fileName, const G4double colour[3], const G4double alpha,
const G4double scale[3], const G4double rotation[3],
const G4double translation[3]);
void AddGeometryOverlay(const G4String& fileName, const G4double colour[3], const G4double alpha,
const G4String& representation,
const G4double scale[3], const G4double rotation[3],
const G4double translation[3]);
void Render() {_renderWindow->Render();}
void StartInteractor() {
G4cout << "StartInteractor" << G4endl;
_renderWindow->GetInteractor()->Start();}
void Print();
@@ -275,6 +287,9 @@ class G4VtkViewer : public G4VViewer
protected:
G4bool firstSetView = true;
G4bool firstFinishView = true;
G4double cameraDistance;
vtkNew<vtkImplicitPlaneRepresentation> cutterPlaneRepresentation;
vtkNew<vtkImplicitPlaneWidget2> cutterPlaneWidget;
@@ -282,6 +297,11 @@ class G4VtkViewer : public G4VViewer
vtkNew<vtkImplicitPlaneWidget2> clipperPlaneWidget;
vtkNew<vtkCameraOrientationWidget> camOrientWidget;
bool bCutter = false;
bool bClipper = false;
bool bHud = false;
bool bOrientation = false;
};
#endif
source/visualization/Vtk/include/private/G4VtkVisContext.hh
+1
View File
@@ -74,6 +74,7 @@ class G4VtkVisContext
green(vc2.green),
blue(vc2.blue),
alpha(vc2.alpha),
fSize(vc2.fSize),
fDrawingStyle(vc2.fDrawingStyle)
{}
};
source/visualization/Vtk/sources.cmake
+6 -2
View File
@@ -3,11 +3,13 @@
geant4_add_module(G4visVtk
PUBLIC_HEADERS
G4Vtk.hh
G4VtkOffscreen.hh
PRIVATE_HEADERS
G4VtkUtility.hh
G4VtkMessenger.hh
G4VtkSceneHandler.hh
G4VtkViewer.hh
G4VtkOffscreenViewer.hh
G4VtkInteractorStyle.hh
G4VtkStore.hh
G4VtkVisContext.hh
@@ -15,7 +17,6 @@ geant4_add_module(G4visVtk
G4VtkCutterPipeline.hh
G4VtkClipClosedSurfacePipeline.hh
G4VtkClipOpenPipeline.hh
#G4VtkClipperClosedPipeline.hh
G4VtkImagePipeline.hh
G4VtkPolydataPipeline.hh
G4VtkPolydataInstancePipeline.hh
@@ -35,16 +36,17 @@ geant4_add_module(G4visVtk
SOURCES
G4Vtk.cc
G4VtkOffscreen.cc
G4VtkUtility.cc
G4VtkMessenger.cc
G4VtkSceneHandler.cc
G4VtkViewer.cc
G4VtkOffscreenViewer.cc
G4VtkInteractorStyle.cc
G4VtkStore.cc
G4VtkCutterPipeline.cc
G4VtkClipClosedSurfacePipeline.cc
G4VtkClipOpenPipeline.cc
#G4VtkClipperClosedPipeline.cc
G4VtkImagePipeline.cc
G4VtkPolydataPipeline.cc
G4VtkPolydataInstancePipeline.cc
@@ -70,9 +72,11 @@ geant4_module_link_libraries(G4visVtk
G4geometrymng
G4globman
G4graphics_reps
G4hepgeometry
G4intercoms
G4materials
G4modeling
G4specsolids
${VTK_LIBRARIES})
# - VTK-Qt if Qt enabled
source/visualization/Vtk/src/G4VtkClipClosedSurfacePipeline.cc
+3 -3
View File
@@ -40,10 +40,10 @@
#include <vtkClipClosedSurface.h>
G4VtkClipClosedSurfacePipeline::G4VtkClipClosedSurfacePipeline(
G4String nameIn, const G4VtkVisContext& vc, vtkSmartPointer<vtkPolyDataAlgorithm> filter,
G4String nameIn, const G4VtkVisContext& vcIn, vtkSmartPointer<vtkPolyDataAlgorithm> filter,
G4bool useVcColour)
: G4VVtkPipeline(nameIn, G4String("G4VtkClipClosedSurfacePipeline"), vc, true,
vc.fViewer->renderer)
: G4VVtkPipeline(nameIn, G4String("G4VtkClipClosedSurfacePipeline"), vcIn, true,
vcIn.fViewer->renderer)
{
// create implicit function for clipping
plane = vtkSmartPointer<vtkPlane>::New();
source/visualization/Vtk/src/G4VtkClipOpenPipeline.cc
+5 -3
View File
@@ -38,10 +38,10 @@
#include "vtkSmartPointer.h"
#include <vtkClipClosedSurface.h>
G4VtkClipOpenPipeline::G4VtkClipOpenPipeline(G4String nameIn, const G4VtkVisContext& vc,
G4VtkClipOpenPipeline::G4VtkClipOpenPipeline(G4String nameIn, const G4VtkVisContext& vcIn,
vtkSmartPointer<vtkPolyDataAlgorithm> filter,
G4bool useVcColour)
: G4VVtkPipeline(nameIn, G4String("G4VtkClipOpenPipeline"), vc, true, vc.fViewer->renderer)
: G4VVtkPipeline(nameIn, G4String("G4VtkClipOpenPipeline"), vcIn, true, vcIn.fViewer->renderer)
{
// create implicit function for clipping
plane = vtkSmartPointer<vtkPlane>::New();
@@ -79,8 +79,10 @@ G4VtkClipOpenPipeline::G4VtkClipOpenPipeline(G4String nameIn, const G4VtkVisCont
// set actor properties from vis context
if (vc.fDrawingStyle == G4ViewParameters::hsr) {
actor->GetProperty()->SetRepresentationToSurface();
}
else if (vc.fDrawingStyle == G4ViewParameters::hlr) {
actor->GetProperty()->SetRepresentationToSurface();
}
else if (vc.fDrawingStyle == G4ViewParameters::wireframe) {
actor->GetProperty()->SetRepresentationToWireframe();
@@ -96,7 +98,7 @@ G4VtkClipOpenPipeline::G4VtkClipOpenPipeline(G4String nameIn, const G4VtkVisCont
vc.fViewer->renderer->AddActor(actor);
}
void G4VtkClipOpenPipeline::SetPlane(G4Plane3D& planeIn)
void G4VtkClipOpenPipeline::SetPlane(const G4Plane3D& planeIn)
{
auto normal = planeIn.normal();
auto point = planeIn.point();
source/visualization/Vtk/src/G4VtkClipperClosedPipeline.cc
-106
View File
@@ -1,106 +0,0 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#include "G4VtkClipperClosedPipeline.hh"
#include "vtkActor.h"
#include "vtkAppendPolyData.h"
#include "vtkClipPolyData.h"
#include "vtkFeatureEdges.h"
#include "vtkPlane.h"
#include "vtkPolyDataAlgorithm.h"
#include "vtkPolyDataMapper.h"
#include "vtkPolyDataNormals.h"
#include "vtkSmartPointer.h"
#include "vtkStripper.h"
#include "vtkTriangleFilter.h"
G4VtkClipperClosedPipeline::G4VtkClipperClosedPipeline(
vtkSmartPointer<vtkPolyDataAlgorithm> filterIn)
{
finalFilter = filterIn;
// create implicit function for clipping
plane = vtkSmartPointer<vtkPlane>::New();
plane->SetOrigin(0, 0, 0);
plane->SetNormal(1, 0, 0);
// clipper
clipper = vtkSmartPointer<vtkClipPolyData>::New();
clipper->SetClipFunction(plane);
clipper->SetInputConnection(finalFilter->GetOutputPort());
// calculate normals with a feature angle of 45 degrees
auto filterNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
filterNormals->SetFeatureAngle(45);
filterNormals->SetInputConnection(clipper->GetOutputPort());
// boundary edges
auto boundaryEdges = vtkSmartPointer<vtkFeatureEdges>::New();
boundaryEdges->SetInputConnection(clipper->GetOutputPort());
boundaryEdges->BoundaryEdgesOn();
boundaryEdges->FeatureEdgesOff();
boundaryEdges->NonManifoldEdgesOff();
boundaryEdges->ManifoldEdgesOff();
// boundary strips
auto boundaryStrips = vtkSmartPointer<vtkStripper>::New();
boundaryStrips->SetInputConnection(boundaryEdges->GetOutputPort());
// boundary polygon
auto boundaryPoly = vtkSmartPointer<vtkPolyData>::New();
boundaryPoly->SetPoints(boundaryStrips->GetOutput()->GetPoints());
boundaryPoly->SetPolys(boundaryStrips->GetOutput()->GetLines());
// boundary triangle filter
auto boundaryTriangle = vtkSmartPointer<vtkTriangleFilter>::New();
boundaryTriangle->AddInputData(boundaryPoly);
// calculate normals with a feature angle of 45 degrees
auto boundaryNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
boundaryNormals->SetFeatureAngle(45);
boundaryNormals->SetInputConnection(boundaryTriangle->GetOutputPort());
// append filter
appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
appendFilter->AddInputConnection(boundaryNormals->GetOutputPort());
appendFilter->AddInputConnection(filterNormals->GetOutputPort());
// mapper
mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(appendFilter->GetOutputPort());
mapper->SetColorModeToDirectScalars();
mapper->ScalarVisibilityOn();
// add to actor
actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
actor->SetVisibility(1);
}
void G4VtkClipperClosedPipeline::Modified()
{
appendFilter->Update();
};
source/visualization/Vtk/src/G4VtkCutterPipeline.cc
+2 -2
View File
@@ -37,10 +37,10 @@
#include "vtkProperty.h"
#include "vtkSmartPointer.h"
G4VtkCutterPipeline::G4VtkCutterPipeline(G4String nameIn, const G4VtkVisContext& vc,
G4VtkCutterPipeline::G4VtkCutterPipeline(G4String nameIn, const G4VtkVisContext& vcIn,
vtkSmartPointer<vtkPolyDataAlgorithm> filter,
G4bool useVcColour)
: G4VVtkPipeline(nameIn, G4String("G4VtkCutterPipeline"), vc, false, vc.fViewer->renderer)
: G4VVtkPipeline(nameIn, G4String("G4VtkCutterPipeline"), vcIn, false, vcIn.fViewer->renderer)
{
// cutter plane
plane = vtkSmartPointer<vtkPlane>::New();
source/visualization/Vtk/src/G4VtkImagePipeline.cc
+7 -1
View File
@@ -39,6 +39,7 @@
#include "vtkImageReader2Factory.h"
#include "vtkMatrix4x4.h"
#include "vtkSmartPointer.h"
#include "vtkImageFlip.h"
G4VtkImagePipeline::G4VtkImagePipeline(const G4String& nameIn, const G4VtkVisContext& vcIn)
: G4VVtkPipeline(nameIn, "G4VtkImagePipeline", vcIn, false, vcIn.fViewer->renderer)
@@ -66,6 +67,7 @@ G4VtkImagePipeline::G4VtkImagePipeline(const G4String& nameIn, const G4VtkVisCon
1.};
transform->DeepCopy(transformArray);
actor->SetUserMatrix(transform);
actor->GetProperty()->SetOpacity(vc.alpha);
vc.fViewer->renderer->AddActor(GetActor());
}
@@ -78,7 +80,11 @@ void G4VtkImagePipeline::SetImage(const G4String& fileName)
imageReader->SetFileName(fileName.c_str());
imageReader->Update();
actor->GetMapper()->SetInputConnection(imageReader->GetOutputPort());
vtkNew<vtkImageFlip> flip;
flip->SetInputConnection(imageReader->GetOutputPort());
flip->SetFilteredAxis(1);
actor->GetMapper()->SetInputConnection(flip->GetOutputPort());
AddFilter(imageReader);
}
source/visualization/Vtk/src/G4VtkMessenger.cc
+108 -2
View File
@@ -85,6 +85,10 @@ G4VtkMessenger::G4VtkMessenger()
fpCommandDebugPrint = new G4UIcommand("/vis/vtk/printDebug", this);
fpCommandDebugPrint->SetGuidance("Debug print of pipelines");
// start interactor in native mode
fpCommandInteractorStart = new G4UIcommand("/vis/vtk/startInteraction", this);
fpCommandInteractorStart->SetGuidance("Start VtkNative window interaction");
/***************************** Set directory *****************************/
fpDirectorySet = new G4UIdirectory("/vis/vtk/set/", true);
fpDirectorySet->SetGuidance("G4VtkViewer set commands");
@@ -98,6 +102,10 @@ G4VtkMessenger::G4VtkMessenger()
fpCommandHUD = new G4UIcmdWithABool("/vis/vtk/set/hud", this);
fpCommandHUD->SetGuidance("Enable or disable HUD for VTK");
// Camera orientation widget
fpCameraOrientation = new G4UIcmdWithABool("/vis/vtk/set/orientation", this);
fpCameraOrientation->SetGuidance("Enable or disable camera orientation widget");
// Clipper command
fpCommandClipper = new G4UIcommand("/vis/vtk/set/clipper", this);
fpCommandClipper->SetGuidance("Enable a cutaway plane (clipper) in VTK");
@@ -121,7 +129,7 @@ G4VtkMessenger::G4VtkMessenger()
// Shadows command
fpCommandShadow = new G4UIcommand("/vis/vtk/set/shadows", this);
fpCommandClipper->SetGuidance("Enable/disable shadows in VTK");
fpCommandShadow->SetGuidance("Enable/disable shadows in VTK");
auto fpCommandShadowParam = new G4UIparameter("enable", 'b', omitable = true);
fpCommandShadowParam->SetDefaultValue(1);
fpCommandShadow->SetParameter(fpCommandShadowParam);
@@ -201,6 +209,66 @@ G4VtkMessenger::G4VtkMessenger()
parameterImageOverlay->SetGuidance("alpha");
parameterImageOverlay->SetDefaultValue(0.5);
fpCommandImageOverlay->SetParameter(parameterImageOverlay);
fpCommandGeometryOverlay = new G4UIcommand("/vis/vtk/add/geometryOverlay", this);
auto parameterGeometryOverlay = new G4UIparameter("filename", 's', omitable = false);
parameterGeometryOverlay->SetGuidance("Geometry file name ");
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("xScale", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("scale in x");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("yScale", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("scale in y");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("zScale", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("scale in z");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("xRotation", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("rotation in x");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("yRotation", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("rotation in y");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("zRotation", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("rotation in z");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("xTranslation", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("translation in x");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("yTranslation", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("translation in y");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("zTranslation", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("translation in z");
parameterGeometryOverlay->SetDefaultValue(0.0);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("alpha", 'd', omitable = true);
parameterGeometryOverlay->SetGuidance("alpha");
parameterGeometryOverlay->SetDefaultValue(0.5);
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
parameterGeometryOverlay = new G4UIparameter("representation", 's', omitable = true);
parameterGeometryOverlay->SetGuidance("representation of mesh");
parameterGeometryOverlay->SetDefaultValue("s");
fpCommandGeometryOverlay->SetParameter(parameterGeometryOverlay);
}
G4VtkMessenger::~G4VtkMessenger()
@@ -214,6 +282,7 @@ G4VtkMessenger::~G4VtkMessenger()
delete fpCommandDebugPrint;
delete fpCommandPolyhedronPipeline;
delete fpCommandImageOverlay;
delete fpCommandGeometryOverlay;
}
G4String G4VtkMessenger::GetCurrentValue(G4UIcommand* /*command*/)
@@ -289,6 +358,15 @@ void G4VtkMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
pVtkViewer->DisableHUD();
}
}
else if (command == fpCameraOrientation) {
G4cout << newValue << G4endl;
if (G4UIcommand::ConvertToBool(newValue)) {
pVtkViewer->EnableCameraOrientationWidget();
}
else {
pVtkViewer->DisableCameraOrientationWidget();
}
}
else if (command == fpCommandDebugPrint) {
pVtkViewer->Print();
}
@@ -312,7 +390,7 @@ void G4VtkMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
G4double worldTopRight[2] = {1, 1};
G4double rotation[3] = {0, 0, 0};
G4double translation[3] = {0, 0, 0};
G4double alpha = 0;
G4double alpha = 0.5;
std::istringstream iss(newValue);
@@ -324,6 +402,31 @@ void G4VtkMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
pVtkViewer->AddImageOverlay(fileName, alpha, imageBottomLeft, worldBottomLeft, imageTopRight,
worldTopRight, rotation, translation);
}
else if (command == fpCommandGeometryOverlay) {
G4String temp;
G4String fileName;
G4double scale[3] = {1, 1, 1};
G4double rotation[3] = {0,0,0};
G4double translation[3] = {0,0,0};
G4double colour[3] = {0.5, 0.5, 0.5};
G4double alpha = 1.0;
G4String representation = "w";
std::istringstream iss(newValue);
iss >> fileName
>> scale[0] >> scale[1] >> scale[2]
>> rotation[0] >> rotation[1] >> rotation[2]
>> translation[0] >> translation[1] >> translation[2]
>> alpha >> representation;
G4cout << fileName << G4endl;
pVtkViewer->AddGeometryOverlay(fileName, colour, alpha, representation,
scale, rotation, translation);
}
else if (command == fpCommandClipper) {
pVtkViewer->EnableClipper(G4Plane3D(), true);
}
@@ -333,4 +436,7 @@ void G4VtkMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
else if (command == fpCommandShadow) {
pVtkViewer->EnableShadows();
}
else if (command == fpCommandInteractorStart) {
pVtkViewer->StartInteractor();
}
}
source/visualization/Vtk/src/G4VtkOffscreen.cc
+63
View File
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//
//
// John Allison 5th April 2001
// A template for a simplest possible graphics driver.
//?? Lines or sections marked like this require specialisation for your driver.
#include "G4VtkOffscreen.hh"
#include "G4VtkMessenger.hh"
#include "G4VtkSceneHandler.hh"
#include "G4VtkOffscreenViewer.hh"
G4VtkOffscreen::G4VtkOffscreen()
: G4VGraphicsSystem("VtkOffscreen", "VTK_OFFSCREEN", "Vtk with offscreen rendering",
G4VGraphicsSystem::noFunctionality)
{
G4VtkMessenger::GetInstance();
}
G4VSceneHandler* G4VtkOffscreen::CreateSceneHandler(const G4String& name)
{
return new G4VtkSceneHandler(*this, name);
}
G4VViewer* G4VtkOffscreen::CreateViewer(G4VSceneHandler& scene, const G4String& name)
{
G4VViewer* pView = new G4VtkOffscreenViewer((G4VtkSceneHandler&)scene, name);
if (pView->GetViewId() < 0) {
G4cerr << "G4Vtk::CreateViewer: ERROR flagged by negative"
" view id in G4VtkViewer creation."
"\n Destroying view and returning null pointer."
<< G4endl;
delete pView;
pView = nullptr;
}
return pView;
}
source/visualization/Vtk/src/G4VtkOffscreenViewer.cc
+63
View File
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#include "G4VtkOffscreenViewer.hh"
#include "G4VtkSceneHandler.hh"
#include "G4VSceneHandler.hh"
#include "vtkWindowToImageFilter.h"
#include "vtkPNGWriter.h"
G4VtkOffscreenViewer::G4VtkOffscreenViewer(G4VSceneHandler& sceneHandler, const G4String& name)
: G4VtkViewer(sceneHandler, name)
{
}
G4VtkOffscreenViewer::~G4VtkOffscreenViewer()
{
}
void G4VtkOffscreenViewer::Initialise()
{
G4VtkViewer::Initialise();
_renderWindow->SetOffScreenRendering(1);
}
void G4VtkOffscreenViewer::FinishView()
{
auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
fVtkSceneHandler.Modified();
_renderWindow->Render();
vtkNew<vtkWindowToImageFilter> windowToImageFilter;
windowToImageFilter->SetInput(_renderWindow);
windowToImageFilter->Update();
vtkNew<vtkPNGWriter> writer;
writer->SetFileName("offscreen.png");
writer->SetInputConnection(windowToImageFilter->GetOutputPort());
writer->Write();
}
source/visualization/Vtk/src/G4VtkPolydataInstanceAppendPipeline.cc
+7 -7
View File
@@ -66,8 +66,8 @@ std::size_t G4VtkPolydataInstanceAppendPipeline::MakeHash(const G4Polyhedron& po
}
G4VtkPolydataInstanceAppendPipeline::G4VtkPolydataInstanceAppendPipeline(G4String nameIn,
const G4VtkVisContext& vc)
: G4VtkPolydataInstancePipeline(nameIn, vc)
const G4VtkVisContext& vcIn)
: G4VtkPolydataInstancePipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataInstanceAppendPipeline"));
@@ -108,11 +108,11 @@ void G4VtkPolydataInstanceAppendPipeline::addInstance(G4double dx, G4double dy,
G4double r10, G4double r11, G4double r12,
G4double r20, G4double r21, G4double r22,
G4double r, G4double g, G4double b,
G4double a, const G4String& name)
G4double a, const G4String& nameIn)
{
// Add to base class
G4VtkPolydataInstancePipeline::addInstance(dx, dy, dz, r00, r01, r02, r10, r11, r12, r20, r21,
r22, r, g, b, a, name);
r22, r, g, b, a, nameIn);
// create transform
auto transform = vtkSmartPointer<vtkGeneralTransform>::New();
@@ -133,14 +133,14 @@ void G4VtkPolydataInstanceAppendPipeline::addInstance(G4double dx, G4double dy,
GetFinalFilter()->AddInputConnection(tf->GetOutputPort());
}
void G4VtkPolydataInstanceAppendPipeline::removeInstance(const G4String& name)
void G4VtkPolydataInstanceAppendPipeline::removeInstance(const G4String& nameIn)
{
// Remove from base class
G4VtkPolydataInstancePipeline::removeInstance(name);
G4VtkPolydataInstancePipeline::removeInstance(nameIn);
// Remove transform filter from append filter
appendFilter->RemoveInputConnection(0, transformFilterMap[name]->GetOutputPort());
// Remove from local filter map
transformFilterMap.erase(name);
transformFilterMap.erase(nameIn);
}
source/visualization/Vtk/src/G4VtkPolydataInstanceBakePipeline.cc
+4 -4
View File
@@ -55,8 +55,8 @@ std::size_t G4VtkPolydataInstanceBakePipeline::MakeHash(const G4Polyhedron& poly
}
G4VtkPolydataInstanceBakePipeline::G4VtkPolydataInstanceBakePipeline(G4String nameIn,
const G4VtkVisContext& vc)
: G4VtkPolydataInstancePipeline(nameIn, vc)
const G4VtkVisContext& vcIn)
: G4VtkPolydataInstancePipeline(nameIn, vcIn)
{
iVert = 0;
iFace = 0;
@@ -86,10 +86,10 @@ void G4VtkPolydataInstanceBakePipeline::addInstance(G4double dx, G4double dy, G4
G4double r10, G4double r11, G4double r12,
G4double r20, G4double r21, G4double r22,
G4double r, G4double g, G4double b, G4double a,
const G4String& name)
const G4String& nameIn)
{
G4VtkPolydataInstancePipeline::addInstance(dx, dy, dz, r00, r01, r02, r10, r11, r12, r20, r21,
r22, r, g, b, a, name);
r22, r, g, b, a, nameIn);
vtkIdType vStart;
vtkIdType vEnd;
source/visualization/Vtk/src/G4VtkPolydataInstancePipeline.cc
+6 -6
View File
@@ -29,8 +29,8 @@
#include "vtkPoints.h"
G4VtkPolydataInstancePipeline::G4VtkPolydataInstancePipeline(G4String nameIn,
const G4VtkVisContext& vc)
: G4VtkPolydataPipeline(nameIn, vc)
const G4VtkVisContext& vcIn)
: G4VtkPolydataPipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataInstancePipeline"));
@@ -49,22 +49,22 @@ G4VtkPolydataInstancePipeline::G4VtkPolydataInstancePipeline(G4String nameIn,
void G4VtkPolydataInstancePipeline::addInstance(G4double dx, G4double dy, G4double dz, G4double r00,
G4double r01, G4double r02, G4double r10,
G4double r11, G4double r12, G4double r20,
G4double r21, G4double r22, const G4String& name)
G4double r21, G4double r22, const G4String& nameIn)
{
// add the instance without colour or alpha
addInstance(dx, dy, dz, r00, r01, r02, r10, r11, r12, r20, r21, r22, 0, 0, 0, 0, name);
addInstance(dx, dy, dz, r00, r01, r02, r10, r11, r12, r20, r21, r22, 0, 0, 0, 0, nameIn);
}
void G4VtkPolydataInstancePipeline::addInstance(G4double dx, G4double dy, G4double dz, G4double r00,
G4double r01, G4double r02, G4double r10,
G4double r11, G4double r12, G4double r20,
G4double r21, G4double r22, G4double r, G4double g,
G4double b, G4double a, const G4String& name)
G4double b, G4double a, const G4String& nameIn)
{
instanceColour->InsertNextTuple4(r, g, b, a);
auto idp = instancePosition->InsertNextPoint(dx, dy, dz);
instanceTransform->InsertNextTuple9(r00, r01, r02, r10, r11, r12, r20, r21, r22);
instanceMap[name] = idp;
instanceMap[nameIn] = idp;
}
void G4VtkPolydataInstancePipeline::removeInstance(const G4String& /*name*/)
source/visualization/Vtk/src/G4VtkPolydataInstanceTensorPipeline.cc
+2 -2
View File
@@ -57,8 +57,8 @@ std::size_t G4VtkPolydataInstanceTensorPipeline::MakeHash(const G4Polyhedron& po
}
G4VtkPolydataInstanceTensorPipeline::G4VtkPolydataInstanceTensorPipeline(G4String nameIn,
const G4VtkVisContext& vc)
: G4VtkPolydataInstancePipeline(nameIn, vc)
const G4VtkVisContext& vcIn)
: G4VtkPolydataInstancePipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataInstanceTensorPipeline"));
source/visualization/Vtk/src/G4VtkPolydataPipeline.cc
+7 -2
View File
@@ -67,8 +67,8 @@ std::size_t G4VtkPolydataPipeline::MakeHash(const G4Polyhedron& polyhedron,
return hash;
}
G4VtkPolydataPipeline::G4VtkPolydataPipeline(G4String nameIn, const G4VtkVisContext& vc)
: G4VVtkPipeline(nameIn, "G4VtkPolydataPipeline", vc, false, vc.fViewer->renderer)
G4VtkPolydataPipeline::G4VtkPolydataPipeline(G4String nameIn, const G4VtkVisContext& vcIn)
: G4VVtkPipeline(nameIn, "G4VtkPolydataPipeline", vcIn, false, vcIn.fViewer->renderer)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataPipeline"));
@@ -178,6 +178,11 @@ void G4VtkPolydataPipeline::SetPolydata(const G4Polyhedron& polyhedron)
} while (notLastFace);
}
void G4VtkPolydataPipeline::SetPolydata(vtkPolyData *polydataIn) {
polydata->DeepCopy(polydataIn);
}
void G4VtkPolydataPipeline::SetPolydata(const G4Polyline& polyline)
{
// Data data
source/visualization/Vtk/src/G4VtkPolydataPolygonPipeline.cc
+2 -2
View File
@@ -41,9 +41,9 @@ std::size_t G4VtkPolydataPolygonPipeline::MakeHash(const G4VisAttributes* pVA)
}
G4VtkPolydataPolygonPipeline::G4VtkPolydataPolygonPipeline(G4String nameIn,
const G4VtkVisContext& vc,
const G4VtkVisContext& vcIn,
const G4VisAttributes* pVisAttributes)
: G4VtkPolydataPipeline(nameIn, vc)
: G4VtkPolydataPipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataSpherePipeline"));
source/visualization/Vtk/src/G4VtkPolydataPolyline2DPipeline.cc
+2 -2
View File
@@ -46,8 +46,8 @@ std::size_t G4VtkPolydataPolyline2DPipeline::MakeHash(const G4VisAttributes* pVA
}
G4VtkPolydataPolyline2DPipeline::G4VtkPolydataPolyline2DPipeline(
G4String nameIn, const G4VtkVisContext& vc, const G4VisAttributes* pVisAttributes)
: G4VtkPolydataPipeline(nameIn, vc)
G4String nameIn, const G4VtkVisContext& vcIn, const G4VisAttributes* pVisAttributes)
: G4VtkPolydataPipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataPolyline2DPipeline"));
source/visualization/Vtk/src/G4VtkPolydataPolylinePipeline.cc
+2 -2
View File
@@ -36,9 +36,9 @@ std::size_t G4VtkPolydataPolylinePipeline::MakeHash(const G4VisAttributes* pVA)
}
G4VtkPolydataPolylinePipeline::G4VtkPolydataPolylinePipeline(G4String nameIn,
const G4VtkVisContext& vc,
const G4VtkVisContext& vcIn,
const G4VisAttributes* pVisAttributes)
: G4VtkPolydataPipeline(nameIn, vc)
: G4VtkPolydataPipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataPolylinePipeline"));
source/visualization/Vtk/src/G4VtkPolydataSpherePipeline.cc
+3 -3
View File
@@ -39,9 +39,9 @@ std::size_t G4VtkPolydataSpherePipeline::MakeHash(const G4VisAttributes* pVA)
return std::hash<G4VisAttributes>{}(*pVA);
}
G4VtkPolydataSpherePipeline::G4VtkPolydataSpherePipeline(G4String nameIn, const G4VtkVisContext& vc,
G4VtkPolydataSpherePipeline::G4VtkPolydataSpherePipeline(G4String nameIn, const G4VtkVisContext& vcIn,
const G4VisAttributes* pVisAttributes)
: G4VtkPolydataPipeline(nameIn, vc)
: G4VtkPolydataPipeline(nameIn, vcIn)
{
// Set pipeline type
SetTypeName(G4String("G4VtkPolydataSpherePipeline"));
@@ -65,7 +65,7 @@ G4VtkPolydataSpherePipeline::G4VtkPolydataSpherePipeline(G4String nameIn, const
GetActor()->SetVisibility(1);
GetActor()->GetProperty()->SetRenderPointsAsSpheres(true);
GetActor()->GetProperty()->SetPointSize(vc.fSize * 5);
GetActor()->GetProperty()->SetPointSize(vc.fSize * 2);
vc.fViewer->renderer->AddActor(GetActor());
}
source/visualization/Vtk/src/G4VtkQt.cc
+4 -16
View File
@@ -56,19 +56,7 @@ G4VViewer* G4VtkQt::CreateViewer(G4VSceneHandler& scene, const G4String& name)
G4bool G4VtkQt::IsUISessionCompatible() const
{
G4UImanager* ui = G4UImanager::GetUIpointer();
G4UIsession* session = ui->GetSession();
// If session is a batch session, it may be:
// a) this is a batch job (the user has not instantiated any UI session);
// b) we are currently processing a UI command, in which case the UI
// manager creates a temporary batch session and to find out if there is
// a genuine UI session that the user has instantiated we must drill
// down through previous sessions to a possible non-batch session.
while (auto batch = dynamic_cast<G4UIbatch*>(session)) {
session = batch->GetPreviousSession();
}
// Qt windows are only appropriate in a Qt session.
return dynamic_cast<G4UIQt*>(session) != nullptr;
}
// Qt windows require a Qt session.
G4UIsession* baseSession = G4UImanager::GetUIpointer()->GetBaseSession();
return dynamic_cast<G4UIQt*>(baseSession) != nullptr;
}
source/visualization/Vtk/src/G4VtkQtViewer.cc
+5 -2
View File
@@ -75,6 +75,7 @@ G4VtkQtViewer::G4VtkQtViewer(G4VSceneHandler& sceneHandler, const G4String& name
new G4AutoLock(mWaitForVisSubThreadQtOpenGLContextMoved, std::defer_lock);
G4Qt::getInstance();
//this->setFormat(QVTKOpenGLNativeWidget::defaultFormat());
}
G4VtkQtViewer::~G4VtkQtViewer()
@@ -89,7 +90,6 @@ void G4VtkQtViewer::Initialise()
// Specific GL render window and interactor for Qt
_renderWindow = vtkGenericOpenGLRenderWindow::New();
renderWindowInteractor = vtkRenderWindowInteractor::New();
_renderWindow->AddRenderer(renderer);
this->setRenderWindow(_renderWindow);
@@ -104,7 +104,8 @@ void G4VtkQtViewer::Initialise()
// Shadows
renderer->SetUseShadows(0);
vtkSmartPointer<G4VtkInteractorStyle> style = vtkSmartPointer<G4VtkInteractorStyle>::New();
vtkSmartPointer<G4VtkInteractorStyle> style =
vtkSmartPointer<G4VtkInteractorStyle>::New();
this->interactor()->SetInteractorStyle(style);
}
@@ -113,6 +114,7 @@ void G4VtkQtViewer::CreateMainWindow(QVTKOpenGLNativeWidget* vtkWidget, const QS
G4UImanager* UI = G4UImanager::GetUIpointer();
fUiQt = static_cast<G4UIQt*>(UI->GetG4UIWindow());
fUiQt->AddTabWidget((QWidget*)vtkWidget, name);
vtkWidget->setAttribute(Qt::WA_AcceptTouchEvents, false);
fGLWidget = vtkWidget;
createSceneTreeWidget();
}
@@ -221,6 +223,7 @@ void G4VtkQtViewer::FinishView()
fVtkSceneHandler.Modified();
_renderWindow->Render();
auto qGLW = dynamic_cast<QVTKOpenGLNativeWidget*>(fGLWidget);
qGLW->interactor()->Initialize();
qGLW->interactor()->Start();
source/visualization/Vtk/src/G4VtkStore.cc
+86 -30
View File
@@ -59,17 +59,18 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wextra-semi"
#include "vtkNew.h"
#include "vtkSmartPointer.h"
#include "vtkBillboardTextActor3D.h"
#include "vtkLine.h"
#include "vtkMatrix3x3.h"
#include "vtkOBJReader.h"
#include "vtkPLYReader.h"
#include "vtkSTLReader.h"
#include "vtkPolyDataReader.h"
#include "vtkProperty.h"
#include "vtkProperty2D.h"
#include "vtkRegularPolygonSource.h"
#include "vtkSTLReader.h"
#include "vtkSmartPointer.h"
#include "vtkTextProperty.h"
#pragma GCC diagnostic pop
@@ -415,9 +416,9 @@ void G4VtkStore::AddPrimitiveSeparate(const G4Polyhedron& polyhedron, const G4Vt
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());
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());
}
@@ -428,26 +429,37 @@ void G4VtkStore::AddPrimitiveTensorGlyph(const G4Polyhedron& polyhedron, const G
return;
}
auto hash = G4VtkPolydataInstanceTensorPipeline::MakeHash(polyhedron, vc);
// 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(polyhedron);
pl->SetPolydata(polyhedronNew);
tensorGlyphPipeMap.insert(std::make_pair(hash, pl));
}
else {
pl = tensorGlyphPipeMap[hash];
}
G4Transform3D fInvObjTrans = vc.fTransform.inverse();
G4Transform3D fInvObjTrans = fTransformNew.inverse();
const G4VisAttributes* pVA =
vc.fViewer->GetApplicableVisAttributes(polyhedron.GetVisAttributes());
G4Color colour = pVA->GetColour();
pl->addInstance(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->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"));
}
@@ -459,25 +471,35 @@ void G4VtkStore::AddPrimitiveAppend(const G4Polyhedron& polyhedron, const G4VtkV
return;
}
auto hash = G4VtkPolydataInstanceAppendPipeline::MakeHash(polyhedron, vc);
// 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(polyhedron);
pl->SetPolydata(polyhedronNew);
appendPipeMap.insert(std::make_pair(hash, pl));
}
else {
pl = appendPipeMap[hash];
}
G4Transform3D fInvObjTrans = vc.fTransform.inverse();
G4Transform3D fInvObjTrans = fTransformNew.inverse();
pl->addInstance(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(), 0, 0,
0, 0, G4String("null"));
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"));
};
void G4VtkStore::AddPrimitiveTransformBake(const G4Polyhedron& polyhedron,
@@ -488,6 +510,16 @@ void G4VtkStore::AddPrimitiveTransformBake(const G4Polyhedron& polyhedron,
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());
@@ -496,7 +528,7 @@ void G4VtkStore::AddPrimitiveTransformBake(const G4Polyhedron& polyhedron,
G4Colour colour = pVA->GetColour();
// Hash the vis (alpha) attributes and polyhedron
std::size_t hash = G4VtkPolydataInstanceBakePipeline::MakeHash(polyhedron, vc);
std::size_t hash = G4VtkPolydataInstanceBakePipeline::MakeHash(polyhedronNew, vc);
std::shared_ptr<G4VtkPolydataInstanceBakePipeline> pl;
if (bakePipeMap.find(hash) == bakePipeMap.end()) {
@@ -508,12 +540,13 @@ void G4VtkStore::AddPrimitiveTransformBake(const G4Polyhedron& polyhedron,
pl = bakePipeMap[hash];
}
G4Transform3D fInvObjTrans = vc.fTransform.inverse();
pl->SetPolydata(polyhedron);
G4Transform3D fInvObjTrans = fTransformNew.inverse();
pl->SetPolydata(polyhedronNew);
pl->addInstance(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->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"));
};
@@ -696,20 +729,43 @@ void G4VtkStore::AddNonG4ObjectImage(const G4String& fileName, const G4VtkVisCon
imagePipeMap.insert(std::make_pair(fileName, pl));
}
void G4VtkStore::AddNonG4ObjectPolydata(const G4String fileName, const G4VtkVisContext& /*vc*/)
void G4VtkStore::AddNonG4ObjectPolydata(const G4String fileName, const G4VtkVisContext& vc)
{
vtkSmartPointer<vtkPolyData> pd;
if (fileName.find("obj") != G4String::npos) {
vtkSmartPointer<vtkOBJReader> objReader;
vtkNew<vtkOBJReader> objReader;
objReader->SetFileName(fileName.c_str());
objReader->Update();
pd = objReader->GetOutput();
}
else if (fileName.find("ply") != G4String::npos) {
vtkSmartPointer<vtkPLYReader> plyReader;
vtkNew<vtkPLYReader> plyReader;
plyReader->SetFileName(fileName.c_str());
plyReader->Update();
pd = plyReader->GetOutput();
}
else if (fileName.find("stl") != G4String::npos) {
vtkSmartPointer<vtkSTLReader> stlReader;
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) {
vtkSmartPointer<vtkPolyDataReader> pldReader;
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);
}
void G4VtkStore::GetBounds(G4double maxBoundIn[6])
source/visualization/Vtk/src/G4VtkText2DPipeline.cc
+2 -2
View File
@@ -50,9 +50,9 @@ std::size_t G4VtkText2DPipeline::MakeHash(const G4Text& text, const G4VtkVisCont
return hash;
}
G4VtkText2DPipeline::G4VtkText2DPipeline(const G4Text& text, const G4VtkVisContext& vc,
G4VtkText2DPipeline::G4VtkText2DPipeline(const G4Text& text, const G4VtkVisContext& vcIn,
const G4VisAttributes* pVA)
: G4VVtkPipeline(text.GetText().c_str(), "G4VtkText2DPipeline", vc, false, vc.fViewer->renderer)
: G4VVtkPipeline(text.GetText().c_str(), "G4VtkText2DPipeline", vcIn, false, vcIn.fViewer->renderer)
{
G4double x = text.GetPosition().x();
G4double y = text.GetPosition().y();
source/visualization/Vtk/src/G4VtkTextPipeline.cc
+2 -2
View File
@@ -52,9 +52,9 @@ std::size_t G4VtkTextPipeline::MakeHash(const G4Text& text, const G4VtkVisContex
return hash;
}
G4VtkTextPipeline::G4VtkTextPipeline(const G4Text& text, const G4VtkVisContext& vc,
G4VtkTextPipeline::G4VtkTextPipeline(const G4Text& text, const G4VtkVisContext& vcIn,
const G4VisAttributes* pVA)
: G4VVtkPipeline(text.GetText().c_str(), "G4VtkTextPipeline", vc, false, vc.fViewer->renderer)
: G4VVtkPipeline(text.GetText().c_str(), "G4VtkTextPipeline", vcIn, false, vcIn.fViewer->renderer)
{
G4double x = text.GetPosition().x();
G4double y = text.GetPosition().y();
source/visualization/Vtk/src/G4VtkUnstructuredGridPipeline.cc
+140 -35
View File
@@ -25,13 +25,25 @@
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkCharArray.h"
#include "vtkUnstructuredGrid.h"
#include "vtkDataSetMapper.h"
#include "vtkUnstructuredGridVolumeMapper.h"
#include "vtkUnstructuredGridVolumeRayCastMapper.h"
#include "vtkUnstructuredGridVolumeZSweepMapper.h"
#include "vtkOpenGLProjectedTetrahedraMapper.h"
#include "vtkActor.h"
#include "vtkColorTransferFunction.h"
#include "vtkPiecewiseFunction.h"
#include "vtkLookupTable.h"
#include "vtkVolumeProperty.h"
#include "vtkVolume.h"
#include "vtkNew.h"
#include "vtkTetra.h"
#include "vtkVoxel.h"
#include "vtkStaticCleanUnstructuredGrid.h"
// #include "vtkCleanUnstructuredGrid.h"
#include "vtkDataSetTriangleFilter.h"
#include "vtkClipDataSet.h"
#include "G4VtkUnstructuredGridPipeline.hh"
#include "G4VtkVisContext.hh"
@@ -48,32 +60,78 @@
#include "G4Tet.hh"
#include "G4Material.hh"
G4VtkUnstructuredGridPipeline::G4VtkUnstructuredGridPipeline(G4String nameIn, const G4VtkVisContext& vc) :
G4VVtkPipeline(nameIn, "G4VtkUnstructuredPipeline", vc, false, vc.fViewer->renderer) {
G4VtkUnstructuredGridPipeline::G4VtkUnstructuredGridPipeline(G4String nameIn, const G4VtkVisContext& vcIn) :
G4VVtkPipeline(nameIn, "G4VtkUnstructuredPipeline", vcIn, false, vcIn.fViewer->renderer) {
points = vtkSmartPointer<vtkPoints>::New();
pointValues = vtkSmartPointer<vtkDoubleArray>::New();
cellValues = vtkSmartPointer<vtkDoubleArray>::New();
cellValues->SetNumberOfComponents(4);
cellValues->SetName("Colors");
pointColourValues = vtkSmartPointer<vtkDoubleArray>::New();
cellColourValues = vtkSmartPointer<vtkDoubleArray>::New();
pointColourValues->SetNumberOfComponents(4);
cellColourValues->SetNumberOfComponents(4);
pointColourIndices = vtkSmartPointer<vtkDoubleArray>::New();
cellColourIndices = vtkSmartPointer<vtkDoubleArray>::New();
pointColourIndices->SetNumberOfComponents(1);
cellColourIndices->SetNumberOfComponents(1);
colourLUT = vtkSmartPointer<vtkDiscretizableColorTransferFunction>::New();
colourLUT->DiscretizeOn();
unstructuredGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
unstructuredGrid->SetPoints(points);
unstructuredGrid->GetCellData()->SetScalars(cellValues);
unstructuredGrid->GetPointData()->SetScalars(pointColourValues);
unstructuredGrid->GetCellData()->SetScalars(cellColourValues);
// clean filter
#if 0
clean = vtkSmartPointer<vtkStaticCleanUnstructuredGrid>::New();
clean->SetInputData(unstructuredGrid);
clean->ToleranceIsAbsoluteOff();
clean->SetTolerance(1e-6);
#endif
// Clip filter
clip = vtkSmartPointer<vtkClipDataSet>::New();
vtkNew<vtkPlane> plane;
clip->SetClipFunction(plane);
clip->SetInputData(unstructuredGrid);
// Triangle filter
auto tri = vtkSmartPointer<vtkDataSetTriangleFilter>::New();
tri->SetInputData(unstructuredGrid);
// create dataset mapper
mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetScalarModeToUseCellData();
mapper->SetColorModeToDirectScalars();
mapper->SetInputData(unstructuredGrid);
//mapper->SetInputConnection(clip->GetOutputPort());
//mapper->SetInputConnection(tri->GetOutputPort());
// create volume mapper
volumeMapper = vtkSmartPointer<vtkUnstructuredGridVolumeRayCastMapper>::New();
volumeMapper->SetScalarModeToUseCellData();
volumeMapper->SetInputConnection(tri->GetOutputPort());
// create volume properties
auto volumeProp = vtkSmartPointer<vtkVolumeProperty>::New();
volumeProp->SetColor(colourLUT);
// create actor
actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
actor->SetVisibility(1);
// create volume
volume = vtkSmartPointer<vtkVolume>::New();
volume->SetMapper(volumeMapper);
//volume->SetProperty(volumeProp);
volume->SetVisibility(1);
// add to renderer
vc.fViewer->renderer->AddActor(actor);
//vc.fViewer->renderer->AddVolume(volume);
}
void G4VtkUnstructuredGridPipeline::PseudoSceneForTetCells::AddSolid(const G4VSolid& solid) {
@@ -85,29 +143,67 @@ void G4VtkUnstructuredGridPipeline::PseudoSceneForTetCells::AddSolid(const G4VSo
const auto& colour = pVisAtts->GetColour();
G4ThreeVector p0, p1, p2, p3;
tet.GetVertices(p0, p1,p2, p3);
tet.GetVertices(p0, p1, p2, p3);
fpPoints->InsertNextPoint(p0.x(),p0.y(),p0.z());
fpPoints->InsertNextPoint(p1.x(),p1.y(),p1.z());
fpPoints->InsertNextPoint(p2.x(),p2.y(),p2.z());
fpPoints->InsertNextPoint(p3.x(),p3.y(),p3.z());
G4int idx[4] = {-1, -1, -1, -1};
vtkNew<vtkTetra> tetra;
tetra->GetPointIds()->SetId(0, 4*iCell);
tetra->GetPointIds()->SetId(1, 4*iCell+1);
tetra->GetPointIds()->SetId(2, 4*iCell+2);
tetra->GetPointIds()->SetId(3, 4*iCell+3);
if (iCell > 0 && iCell < 100000000) {
#if 0
G4ThreeVector pts[4] = {p0, p1, p2, p3};
for (G4int i = 0; i < 4; i++) {
auto h = MakeHash(pts[i]);
if (fpPointMap.find(h) == fpPointMap.end()) {
fpPointMap.insert(std::make_pair(h, iPoint));
fpPoints->InsertNextPoint(pts[i].x(), pts[i].y(), pts[i].z());
fpPointVector.push_back(pts[i]);
idx[i] = iPoint;
iPoint++;
}
else {
idx[i] = fpPointMap[h];
}
}
#endif
fpGrid->InsertNextCell(tetra->GetCellType(), tetra->GetPointIds());
#if 1
fpPoints->InsertNextPoint(p0.x(), p0.y(), p0.z());
fpPoints->InsertNextPoint(p1.x(), p1.y(), p1.z());
fpPoints->InsertNextPoint(p2.x(), p2.y(), p2.z());
fpPoints->InsertNextPoint(p3.x(), p3.y(), p3.z());
iPoint += 4;
double cols[] = {colour.GetRed(),
colour.GetGreen(),
colour.GetBlue(),
colour.GetAlpha()};
fpCellValues->InsertNextTuple(cols);
idx[0] = 4 * iCellAdd;
idx[1] = 4 * iCellAdd + 1;
idx[2] = 4 * iCellAdd + 2;
idx[3] = 4 * iCellAdd + 3;
#endif
vtkNew<vtkTetra> tetra;
tetra->GetPointIds()->SetId(0, idx[0]);
tetra->GetPointIds()->SetId(1, idx[1]);
tetra->GetPointIds()->SetId(2, idx[2]);
tetra->GetPointIds()->SetId(3, idx[3]);
fpGrid->InsertNextCell(tetra->GetCellType(), tetra->GetPointIds());
auto hash = MakeHash(colour);
unsigned short int iColour = 0;
if (fpColourMap.find(hash) == fpColourMap.end()) {
iColour = fpColourMap.size();
fpColourMap.insert(std::make_pair(hash,iColour));
double c[4] = {colour.GetRed(), colour.GetGreen(), colour.GetBlue(), colour.GetAlpha()};
fpColourLUT->SetIndexedColorRGBA(iColour,c);
}
else {
iColour = fpColourMap[hash];
}
fpCellColourValues->InsertNextTuple4(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), colour.GetAlpha());
fpCellColourIndices->InsertNextTuple1(iColour);
iCellAdd++;
}
iCell++;
}
catch (const std::bad_cast&) {
G4ExceptionDescription ed;
@@ -126,13 +222,13 @@ void G4VtkUnstructuredGridPipeline::PseudoSceneForCubicalCells::AddSolid(const G
fpPoints->InsertNextPoint(position.x()-box.GetXHalfLength(),position.y()-box.GetYHalfLength(),position.z()-box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()-box.GetXHalfLength(),position.y()+box.GetYHalfLength(),position.z()-box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()+box.GetXHalfLength(),position.y()+box.GetYHalfLength(),position.z()-box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()+box.GetXHalfLength(),position.y()-box.GetYHalfLength(),position.z()-box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()+box.GetXHalfLength(),position.y()+box.GetYHalfLength(),position.z()-box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()-box.GetXHalfLength(),position.y()-box.GetYHalfLength(),position.z()+box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()-box.GetXHalfLength(),position.y()+box.GetYHalfLength(),position.z()+box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()+box.GetXHalfLength(),position.y()+box.GetYHalfLength(),position.z()+box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()+box.GetXHalfLength(),position.y()-box.GetYHalfLength(),position.z()+box.GetZHalfLength());
fpPoints->InsertNextPoint(position.x()+box.GetXHalfLength(),position.y()+box.GetYHalfLength(),position.z()+box.GetZHalfLength());
vtkNew<vtkVoxel> voxel;
voxel->GetPointIds()->SetId(0, 8*iCell);
@@ -150,7 +246,9 @@ void G4VtkUnstructuredGridPipeline::PseudoSceneForCubicalCells::AddSolid(const G
colour.GetGreen(),
colour.GetBlue(),
colour.GetAlpha()};
fpCellValues->InsertNextTuple(cols);
fpCellColourValues->InsertNextTuple(cols);
//fpCellColourIndices->InsertNextTuple1(iColour);
iCell++;
@@ -181,19 +279,26 @@ void G4VtkUnstructuredGridPipeline::SetUnstructuredGridData(const G4Mesh &mesh)
// Graphics scene
if(mesh.GetMeshType() == G4Mesh::tetrahedron) {
PseudoSceneForTetCells pseudoScene(&tmpPVModel, mesh.GetMeshDepth(), points, cellValues,
unstructuredGrid);
PseudoSceneForTetCells pseudoScene(&tmpPVModel, mesh.GetMeshDepth(), points,
pointColourValues, cellColourValues,
pointColourIndices, cellColourIndices,
colourLUT, unstructuredGrid);
tmpPVModel.DescribeYourselfTo(pseudoScene);
//G4cout << pseudoScene.GetNumberOfPoints() << " " << pseudoScene.GetNumberOfCells() << " " << pseudoScene.GetNumberOfAddedCells() << G4endl;
//pseudoScene.DumpColourMap();
}
else if(mesh.GetMeshType() == G4Mesh::nested3DRectangular) {
PseudoSceneForCubicalCells pseudoScene(&tmpPVModel, mesh.GetMeshDepth(), points, cellValues,
unstructuredGrid);
PseudoSceneForCubicalCells pseudoScene(&tmpPVModel, mesh.GetMeshDepth(), points,
pointColourValues, cellColourValues,
pointColourIndices, cellColourIndices,
colourLUT, unstructuredGrid);
tmpPVModel.DescribeYourselfTo(pseudoScene);
}
else if(mesh.GetMeshType() == G4Mesh::rectangle) {
PseudoSceneForCubicalCells pseudoScene(&tmpPVModel, mesh.GetMeshDepth(), points, cellValues,
unstructuredGrid);
PseudoSceneForCubicalCells pseudoScene(&tmpPVModel, mesh.GetMeshDepth(), points,
pointColourValues, cellColourValues,
pointColourIndices, cellColourIndices,
colourLUT, unstructuredGrid);
tmpPVModel.DescribeYourselfTo(pseudoScene);
}
source/visualization/Vtk/src/G4VtkUtility.cc
+31
View File
@@ -26,9 +26,11 @@
// Created by Stewart Boogert on 05/03/2023.
//
#include "G4VVtkPipeline.hh" // Move basic hashing functionality to G4VtkUtility.(hh/cc
#include "G4VtkUtility.hh"
#include "G4Transform3D.hh"
#include "G4Colour.hh"
#include "vtkMatrix4x4.h"
#include "vtkPlane.h"
@@ -79,3 +81,32 @@ void MaxBounds(G4double* maxBound, G4double* boundToCheck)
if (boundToCheck[4] < maxBound[4]) maxBound[4] = boundToCheck[4];
if (boundToCheck[5] > maxBound[5]) maxBound[5] = boundToCheck[5];
}
std::size_t MakeHash(const G4ThreeVector &v)
{
std::size_t xhash = std::hash<G4double>{}(v.x());
std::size_t yhash = std::hash<G4double>{}(v.y());
std::size_t zhash = std::hash<G4double>{}(v.z());
std::hash_combine(xhash, yhash);
std::hash_combine(yhash, zhash);
return xhash;
}
std::size_t MakeHash(const G4Colour &c)
{
std::size_t rhash = std::hash<G4double>{}(c.GetRed());
std::size_t ghash = std::hash<G4double>{}(c.GetGreen());
std::size_t bhash = std::hash<G4double>{}(c.GetBlue());
std::size_t ahash = std::hash<G4double>{}(c.GetAlpha());
std::hash_combine(rhash, ghash);
std::hash_combine(rhash, bhash);
std::hash_combine(rhash, ahash);
return rhash;
}
source/visualization/Vtk/src/G4VtkViewer.cc
+90 -46
View File
@@ -23,6 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
#include <cmath>
#include "G4VtkViewer.hh"
#include "G4Transform3D.hh"
@@ -46,7 +48,11 @@
#include "vtkLightCollection.h"
#include "vtkOBJExporter.h"
#include "vtkOBJImporter.h"
#include "vtkGLTFExporter.h"
#include "vtkOOGLExporter.h"
#include "vtkJSONRenderWindowExporter.h"
#include "vtkVtkJSSceneGraphSerializer.h"
//#include "vtkBufferedArchiver.h"
#include "vtkPNGWriter.h"
#include "vtkPNMWriter.h"
#include "vtkPOVExporter.h"
@@ -160,36 +166,35 @@ void G4VtkViewer::SetView()
if (radius <= 0.) {
radius = 1.;
}
G4double cameraDistance = fVP.GetCameraDistance(radius);
if (firstSetView) cameraDistance = fVP.GetCameraDistance(radius);
G4Point3D viewpointDirection = fVP.GetViewpointDirection();
G4Point3D targetPoint = fVP.GetCurrentTargetPoint();
G4Point3D cameraPosition = targetPoint + viewpointDirection.unit() * cameraDistance;
renderer->GetActiveCamera()->SetFocalPoint(targetPoint.x(), targetPoint.y(), targetPoint.z());
renderer->GetActiveCamera()->SetPosition(cameraPosition.x(), cameraPosition.y(),
cameraPosition.z());
renderer->GetActiveCamera()->SetParallelScale(cameraDistance);
G4Point3D targetPosition = fVP.GetCurrentTargetPoint();
G4double zoomFactor = fVP.GetZoomFactor();
G4double fieldHalfAngle = fVP.GetFieldHalfAngle();
G4Point3D cameraPosition = targetPosition + viewpointDirection.unit() /zoomFactor * cameraDistance;
vtkCamera* activeCamera = renderer->GetActiveCamera();
activeCamera->SetFocalPoint(targetPosition.x(), targetPosition.y(), targetPosition.z());
activeCamera->SetViewAngle(2*fieldHalfAngle / M_PI * 180);
activeCamera->SetPosition(cameraPosition.x(), cameraPosition.y(), cameraPosition.z());
activeCamera->SetParallelScale(cameraDistance / zoomFactor);
if (fieldHalfAngle == 0) {
activeCamera->SetParallelProjection(1);
}
else {
activeCamera->SetParallelProjection(0);
}
// need to set camera distance and parallel scale on first set view
if (firstSetView) {
geant4Callback->SetVtkInitialValues(cameraDistance, cameraDistance);
activeCamera->SetParallelScale(cameraDistance);
firstSetView = false;
}
// projection type and view angle and zoom factor
G4double fieldHalfAngle = fVP.GetFieldHalfAngle();
G4double zoomFactor = fVP.GetZoomFactor();
vtkCamera* activeCamera = renderer->GetActiveCamera();
if (fieldHalfAngle == 0) {
activeCamera->SetParallelProjection(1);
activeCamera->SetParallelScale(activeCamera->GetParallelScale() / zoomFactor);
}
else {
activeCamera->SetParallelProjection(0);
activeCamera->SetViewAngle(2 * fieldHalfAngle / M_PI * 180);
activeCamera->SetPosition(cameraPosition.x() / zoomFactor, cameraPosition.y() / zoomFactor,
cameraPosition.z() / zoomFactor);
}
// camera up direction
const G4Vector3D upVector = fVP.GetUpVector();
renderer->GetActiveCamera()->SetViewUp(upVector.x(), upVector.y(), upVector.z());
@@ -197,7 +202,7 @@ void G4VtkViewer::SetView()
// Light
const G4Vector3D lightDirection = fVP.GetLightpointDirection();
G4bool lightsMoveWithCamera = fVP.GetLightsMoveWithCamera();
G4Vector3D lightPosition = targetPoint + lightDirection.unit() * cameraDistance;
G4Vector3D lightPosition = targetPosition + lightDirection.unit() * cameraDistance;
vtkLightCollection* currentLights = renderer->GetLights();
if (currentLights->GetNumberOfItems() != 0) {
@@ -323,7 +328,13 @@ void G4VtkViewer::FinishView()
_renderWindow->GetInteractor()->Initialize();
_renderWindow->Render();
_renderWindow->GetInteractor()->Start();
if (firstFinishView) {
firstFinishView = false;
}
else {
_renderWindow->GetInteractor()->Start();
}
}
void G4VtkViewer::ExportScreenShot(G4String path, G4String format)
@@ -349,7 +360,7 @@ void G4VtkViewer::ExportScreenShot(G4String path, G4String format)
imWriter = vtkPostScriptWriter::New();
}
else {
imWriter = vtkPNGWriter::New();
return;
}
_renderWindow->Render();
@@ -374,35 +385,43 @@ void G4VtkViewer::ExportScreenShot(G4String path, G4String format)
void G4VtkViewer::ExportOBJScene(G4String path)
{
vtkSmartPointer<vtkRenderWindow> _rw1 = vtkSmartPointer<vtkRenderWindow>::New();
_rw1->AddRenderer(_renderWindow->GetRenderers()->GetFirstRenderer());
vtkSmartPointer<vtkOBJExporter> exporter = vtkSmartPointer<vtkOBJExporter>::New();
exporter->SetRenderWindow(_rw1);
exporter->SetRenderWindow(_renderWindow);
exporter->SetFilePrefix(path.c_str());
exporter->Write();
}
void G4VtkViewer::ExportVRMLScene(G4String path)
{
vtkSmartPointer<vtkRenderWindow> _rw1 = vtkSmartPointer<vtkRenderWindow>::New();
_rw1->AddRenderer(_renderWindow->GetRenderers()->GetFirstRenderer());
vtkSmartPointer<vtkVRMLExporter> exporter = vtkSmartPointer<vtkVRMLExporter>::New();
exporter->SetRenderWindow(_rw1);
exporter->SetRenderWindow(_renderWindow);
exporter->SetFileName((path + ".vrml").c_str());
exporter->Write();
}
void G4VtkViewer::ExportVTPScene(G4String path)
{
vtkSmartPointer<vtkRenderWindow> _rw1 = vtkSmartPointer<vtkRenderWindow>::New();
_rw1->AddRenderer(_renderWindow->GetRenderers()->GetFirstRenderer());
vtkSmartPointer<vtkSingleVTPExporter> exporter = vtkSmartPointer<vtkSingleVTPExporter>::New();
exporter->SetRenderWindow(_rw1);
exporter->SetRenderWindow(_renderWindow);
exporter->SetFileName((path + ".vtp").c_str());
exporter->Write();
}
void G4VtkViewer::ExportGLTFScene(G4String /*fileName*/) {}
void G4VtkViewer::ExportGLTFScene(G4String fileName) {
vtkSmartPointer<vtkGLTFExporter> exporter = vtkSmartPointer<vtkGLTFExporter>::New();
exporter->SetRenderWindow(_renderWindow);
exporter->SetFileName((fileName+".gltf").c_str());
exporter->InlineDataOn();
exporter->Write();
}
void G4VtkViewer::ExportJSONRenderWindowScene(G4String /*fileName*/) {
vtkSmartPointer<vtkJSONRenderWindowExporter> exporter = vtkSmartPointer<vtkJSONRenderWindowExporter>::New();
vtkSmartPointer<vtkVtkJSSceneGraphSerializer> serializer = vtkSmartPointer<vtkVtkJSSceneGraphSerializer>::New();
exporter->SetRenderWindow(_renderWindow);
exporter->SetSerializer(serializer);
exporter->Write();
}
void G4VtkViewer::ExportVTPCutter(G4String fileName)
{
@@ -505,6 +524,13 @@ void G4VtkViewer::ExportFormatStore(G4String fileName, G4String storeName)
exporter->SetFileName(fileName.c_str());
exporter->Write();
}
else if (fileName.find("gltf") != std::string::npos) {
vtkNew<vtkGLTFExporter> exporter;
exporter->SetRenderWindow(tempRenderWindow);
exporter->SetFileName(fileName.c_str());
exporter->InlineDataOn();
exporter->Write();
}
}
void G4VtkViewer::AddViewHUD()
@@ -537,6 +563,10 @@ void G4VtkViewer::AddClipperPlaneWidget(const G4Plane3D& plane)
clipperPlaneRepresentation->PlaceWidget(bounds);
clipperPlaneRepresentation->SetNormal(vplane->GetNormal());
vtkNew<vtkPropCollection> planeRepActors;
clipperPlaneRepresentation->GetActors(planeRepActors);
planeRepActors->InitTraversal();
SetWidgetInteractor(clipperPlaneWidget);
clipperPlaneWidget->SetRepresentation(clipperPlaneRepresentation);
clipperPlaneWidget->AddObserver(vtkCommand::InteractionEvent, clipperCallback);
@@ -634,6 +664,7 @@ void G4VtkViewer::DisableCutter(G4String /*name*/)
void G4VtkViewer::EnableCutterWidget()
{
G4cout << "enable cutter widget" << G4endl;
cutterPlaneWidget->SetEnabled(1);
}
@@ -646,7 +677,7 @@ void G4VtkViewer::AddCameraOrientationWidget()
{
camOrientWidget->SetParentRenderer(renderer);
// Enable the widget.
camOrientWidget->On();
camOrientWidget->Off();
}
void G4VtkViewer::EnableCameraOrientationWidget()
@@ -666,18 +697,25 @@ void G4VtkViewer::AddImageOverlay(const G4String& fileName, const G4double alpha
const G4double rotation[3], const G4double translation[3])
{
auto xScale = (worldTopRight[0] - worldBottomLeft[0]) / (imageTopRight[0] - imageBottomLeft[0]);
auto yScale = (worldTopRight[1] - worldBottomLeft[1]) / (imageTopRight[1] - imageBottomLeft[1]);
auto yScale = -(worldTopRight[1] - worldBottomLeft[1]) / (imageTopRight[1] - imageBottomLeft[1]);
G4cout << xScale << " " << yScale << G4endl;
auto transformation = G4Transform3D::Identity;
auto scal = G4Scale3D(xScale, yScale, 1);
auto rotx = G4RotateX3D(rotation[0]);
auto roty = G4RotateY3D(rotation[1]);
auto rotz = G4RotateZ3D(rotation[2]);
auto tran = G4Translate3D(translation[0] - xScale * (imageBottomLeft[0] + imageTopRight[0]) / 2.0,
translation[1] - yScale * (imageBottomLeft[1] + imageTopRight[1]) / 2.0,
auto rotx = G4RotateX3D(rotation[0]/180*M_PI);
auto roty = G4RotateY3D(rotation[1]/180*M_PI);
auto rotz = G4RotateZ3D(rotation[2]/180*M_PI);
auto tranImg = G4Translate3D( -std::fabs(imageBottomLeft[0] + imageTopRight[0]) / 2.0,
-std::fabs(imageBottomLeft[1] + imageTopRight[1]) / 2.0,
0);
auto tran = G4Translate3D(translation[0],
translation[1],
translation[2]);
transformation = tran * rotz * roty * rotx * scal * transformation;
G4cout << translation[0] << " " << translation[1] << " " << translation[2] << G4endl;
transformation = tran * rotz * roty * rotx * scal * tranImg * transformation;
G4cout << transformation.dx() << " " << transformation.dy() << " " << transformation.dz() << G4endl;
auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
G4VtkStore& st = fVtkSceneHandler.GetTransientStore();
@@ -686,9 +724,10 @@ void G4VtkViewer::AddImageOverlay(const G4String& fileName, const G4double alpha
st.AddNonG4ObjectImage(fileName, vc);
}
void G4VtkViewer::Add3DOverlay(const G4String& fileName, const G4double colour[3],
const G4double alpha, const G4double scale[3],
const G4double rotation[3], const G4double translation[3])
void G4VtkViewer::AddGeometryOverlay(const G4String& fileName, const G4double colour[3],
const G4double alpha, const G4String& representation,
const G4double scale[3], const G4double rotation[3],
const G4double translation[3])
{
auto transformation = G4Transform3D::Identity;
auto scal = G4Scale3D(scale[0], scale[1], scale[2]);
@@ -702,7 +741,12 @@ void G4VtkViewer::Add3DOverlay(const G4String& fileName, const G4double colour[3
auto& fVtkSceneHandler = dynamic_cast<G4VtkSceneHandler&>(fSceneHandler);
G4VtkStore& st = fVtkSceneHandler.GetTransientStore();
G4VtkVisContext vc = G4VtkVisContext(this, nullptr, false, transformation);
if (representation == "w")
vc.fDrawingStyle = G4ViewParameters::wireframe;
else if (representation == "s")
vc.fDrawingStyle = G4ViewParameters::hlhsr;
vc.alpha = alpha;
vc.red = colour[0];
vc.green = colour[1];