#include <G4ViewParameters.hh>

Public Types
enum	CutawayMode { cutawayUnion , cutawayIntersection }

enum	DrawingStyle { wireframe , hlr , hsr , hlhsr , cloud }

enum	RotationStyle { constrainUpDirection , freeRotation }

Public Member Functions
void	AddCutawayPlane (const G4Plane3D &cutawayPlane)

void	AddVisAttributesModifier (const G4ModelingParameters::VisAttributesModifier &)

G4String	CameraAndLightingCommands (const G4Point3D standardTargetPoint) const

void	ChangeCutawayPlane (size_t index, const G4Plane3D &cutawayPlane)

void	ClearCutawayPlanes ()

void	ClearVisAttributesModifiers ()

G4String	DrawingStyleCommands () const

	G4ViewParameters ()

G4Vector3D &	GetActualLightpointDirection ()

const G4Colour &	GetBackgroundColour () const

G4double	GetCameraDistance (G4double radius) const

G4int	GetCBDAlgorithmNumber () const

const std::vector< G4double > &	GetCBDParameters () const

const G4Point3D &	GetCurrentTargetPoint () const

CutawayMode	GetCutawayMode () const

const G4Planes &	GetCutawayPlanes () const

const G4VMarker &	GetDefaultMarker () const

const G4VisAttributes *	GetDefaultTextVisAttributes () const

const G4VisAttributes *	GetDefaultVisAttributes () const

G4double	GetDisplayHeadTimeBlue () const

G4double	GetDisplayHeadTimeGreen () const

G4double	GetDisplayHeadTimeRed () const

G4double	GetDisplayHeadTimeSize () const

G4double	GetDisplayHeadTimeX () const

G4double	GetDisplayHeadTimeY () const

G4double	GetDisplayLightFrontBlue () const

G4double	GetDisplayLightFrontGreen () const

G4double	GetDisplayLightFrontRed () const

G4double	GetDisplayLightFrontT () const

G4double	GetDisplayLightFrontX () const

G4double	GetDisplayLightFrontY () const

G4double	GetDisplayLightFrontZ () const

G4double	GetDolly () const

DrawingStyle	GetDrawingStyle () const

G4double	GetEndTime () const

const G4Point3D &	GetExplodeCentre () const

G4double	GetExplodeFactor () const

G4double	GetFadeFactor () const

G4double	GetFarDistance (G4double cameraDistance, G4double nearDistance, G4double radius) const

G4double	GetFieldHalfAngle () const

G4double	GetFrontHalfHeight (G4double nearDistance, G4double radius) const

G4double	GetGlobalLineWidthScale () const

G4double	GetGlobalMarkerScale () const

const G4Vector3D &	GetLightpointDirection () const

G4bool	GetLightsMoveWithCamera () const

G4double	GetNearDistance (G4double cameraDistance, G4double radius) const

G4int	GetNoOfSides () const

G4int	GetNumberOfCloudPoints () const

RotationStyle	GetRotationStyle () const

const G4Vector3D &	GetScaleFactor () const

const G4Plane3D &	GetSectionPlane () const

const std::vector< G4ModelingParameters::PVNameCopyNo > &	GetSpecialMeshVolumes () const

G4double	GetStartTime () const

const G4Vector3D &	GetUpVector () const

const G4Vector3D &	GetViewpointDirection () const

const std::vector< G4ModelingParameters::VisAttributesModifier > &	GetVisAttributesModifiers () const

G4double	GetVisibleDensity () const

G4int	GetWindowAbsoluteLocationHintX (G4int) const

G4int	GetWindowAbsoluteLocationHintY (G4int) const

G4int	GetWindowLocationHintX () const

G4int	GetWindowLocationHintY () const

unsigned int	GetWindowSizeHintX () const

unsigned int	GetWindowSizeHintY () const

const G4String &	GetXGeometryString () const

G4double	GetZoomFactor () const

void	IncrementDolly (G4double dollyIncrement)

void	IncrementPan (G4double right, G4double up)

void	IncrementPan (G4double right, G4double up, G4double forward)

G4bool	IsAutoRefresh () const

G4bool	IsAuxEdgeVisible () const

G4bool	IsCulling () const

G4bool	IsCullingCovered () const

G4bool	IsCullingInvisible () const

G4bool	IsCutaway () const

G4bool	IsDensityCulling () const

G4bool	IsDisplayHeadTime () const

G4bool	IsDisplayLightFront () const

G4bool	IsExplode () const

G4bool	IsMarkerNotHidden () const

G4bool	IsPicking () const

G4bool	IsSection () const

G4bool	IsSpecialMeshRendering () const

bool	IsWindowLocationHintX () const

bool	IsWindowLocationHintY () const

bool	IsWindowSizeHintX () const

bool	IsWindowSizeHintY () const

void	MultiplyScaleFactor (const G4Vector3D &scaleFactorMultiplier)

void	MultiplyZoomFactor (G4double zoomFactorMultiplier)

G4bool	operator!= (const G4ViewParameters &) const

void	PrintDifferences (const G4ViewParameters &v) const

G4String	SceneModifyingCommands () const

void	SetAutoRefresh (G4bool)

void	SetAuxEdgeVisible (G4bool)

void	SetBackgroundColour (const G4Colour &)

void	SetCBDAlgorithmNumber (G4int)

void	SetCBDParameters (const std::vector< G4double > &)

void	SetCulling (G4bool)

void	SetCullingCovered (G4bool)

void	SetCullingInvisible (G4bool)

void	SetCurrentTargetPoint (const G4Point3D &currentTargetPoint)

void	SetCutawayMode (CutawayMode)

void	SetDefaultColour (const G4Colour &)

void	SetDefaultMarker (const G4VMarker &defaultMarker)

void	SetDefaultTextColour (const G4Colour &)

void	SetDefaultTextVisAttributes (const G4VisAttributes &)

void	SetDefaultVisAttributes (const G4VisAttributes &)

void	SetDensityCulling (G4bool)

void	SetDisplayHeadTime (G4bool)

void	SetDisplayHeadTimeBlue (G4double)

void	SetDisplayHeadTimeGreen (G4double)

void	SetDisplayHeadTimeRed (G4double)

void	SetDisplayHeadTimeSize (G4double)

void	SetDisplayHeadTimeX (G4double)

void	SetDisplayHeadTimeY (G4double)

void	SetDisplayLightFront (G4bool)

void	SetDisplayLightFrontBlue (G4double)

void	SetDisplayLightFrontGreen (G4double)

void	SetDisplayLightFrontRed (G4double)

void	SetDisplayLightFrontT (G4double)

void	SetDisplayLightFrontX (G4double)

void	SetDisplayLightFrontY (G4double)

void	SetDisplayLightFrontZ (G4double)

void	SetDolly (G4double dolly)

void	SetDrawingStyle (G4ViewParameters::DrawingStyle style)

void	SetEndTime (G4double)

void	SetExplodeCentre (const G4Point3D &explodeCentre)

void	SetExplodeFactor (G4double explodeFactor)

void	SetFadeFactor (G4double)

void	SetFieldHalfAngle (G4double fieldHalfAngle)

void	SetGlobalLineWidthScale (G4double globalLineWidthScale)

void	SetGlobalMarkerScale (G4double globalMarkerScale)

void	SetLightpointDirection (const G4Vector3D &lightpointDirection)

void	SetLightsMoveWithCamera (G4bool moves)

void	SetMarkerHidden ()

void	SetMarkerNotHidden ()

G4int	SetNoOfSides (G4int nSides)

G4int	SetNumberOfCloudPoints (G4int)

void	SetOrthogonalProjection ()

void	SetPan (G4double right, G4double up)

void	SetPerspectiveProjection (G4double fieldHalfAngle=30. *CLHEP::deg)

void	SetPicking (G4bool)

void	SetRotationStyle (RotationStyle)

void	SetScaleFactor (const G4Vector3D &scaleFactor)

void	SetSectionPlane (const G4Plane3D &sectionPlane)

void	SetSpecialMeshRendering (G4bool)

void	SetSpecialMeshVolumes (const std::vector< G4ModelingParameters::PVNameCopyNo > &)

void	SetStartTime (G4double)

void	SetUpVector (const G4Vector3D &upVector)

void	SetViewAndLights (const G4Vector3D &viewpointDirection)

void	SetViewpointDirection (const G4Vector3D &viewpointDirection)

void	SetVisibleDensity (G4double visibleDensity)

void	SetWindowLocationHint (G4int xHint, G4int yHint)

void	SetWindowSizeHint (G4int xHint, G4int yHint)

void	SetXGeometryString (const G4String &)

void	SetZoomFactor (G4double zoomFactor)

G4String	TimeWindowCommands () const

G4String	TouchableCommands () const

void	UnsetExplodeFactor ()

void	UnsetSectionPlane ()

	~G4ViewParameters ()

Static Public Member Functions
static G4ViewParameters *	CatmullRomCubicSplineInterpolation (const std::vector< G4ViewParameters > &views, G4int nInterpolationPoints=50)

Private Types
enum	{ fNoValue = 0 , fXValue = 0x0001 , fYValue = 0x0002 , fWidthValue = 0x0004 , fHeightValue = 0x0008 , fAllValues = 0x000F , fXNegative = 0x0010 , fYNegative = 0x0020 }

Private Member Functions
G4int	ParseGeometry (const char string, G4int x, G4int y, unsigned int width, unsigned int *height)

G4int	ReadInteger (char string, char *NextString)

Private Attributes
G4Vector3D	fActualLightpointDirection

G4bool	fAutoRefresh

G4bool	fAuxEdgeVisible

G4Colour	fBackgroundColour

G4int	fCBDAlgorithmNumber

std::vector< G4double >	fCBDParameters

G4bool	fCullCovered

G4bool	fCulling

G4bool	fCullInvisible

G4Point3D	fCurrentTargetPoint

CutawayMode	fCutawayMode

G4Planes	fCutawayPlanes

G4VMarker	fDefaultMarker

G4VisAttributes	fDefaultTextVisAttributes

G4VisAttributes	fDefaultVisAttributes

G4bool	fDensityCulling

G4bool	fDisplayHeadTime

G4double	fDisplayHeadTimeBlue

G4double	fDisplayHeadTimeGreen

G4double	fDisplayHeadTimeRed

G4double	fDisplayHeadTimeSize

G4double	fDisplayHeadTimeX

G4double	fDisplayHeadTimeY

G4bool	fDisplayLightFront

G4double	fDisplayLightFrontBlue

G4double	fDisplayLightFrontGreen

G4double	fDisplayLightFrontRed

G4double	fDisplayLightFrontT

G4double	fDisplayLightFrontX

G4double	fDisplayLightFrontY

G4double	fDisplayLightFrontZ

G4double	fDolly

DrawingStyle	fDrawingStyle

G4double	fEndTime

G4Point3D	fExplodeCentre

G4double	fExplodeFactor

G4double	fFadeFactor

G4double	fFieldHalfAngle

G4int	fGeometryMask

G4double	fGlobalLineWidthScale

G4double	fGlobalMarkerScale

G4bool	fLightsMoveWithCamera

G4bool	fMarkerNotHidden

G4int	fNoOfSides

G4int	fNumberOfCloudPoints

G4bool	fPicking

G4Vector3D	fRelativeLightpointDirection

RotationStyle	fRotationStyle

G4Vector3D	fScaleFactor

G4bool	fSection

G4Plane3D	fSectionPlane

G4bool	fSpecialMeshRendering

std::vector< G4ModelingParameters::PVNameCopyNo >	fSpecialMeshVolumes

G4double	fStartTime

G4Vector3D	fUpVector

G4Vector3D	fViewpointDirection

std::vector< G4ModelingParameters::VisAttributesModifier >	fVisAttributesModifiers

G4double	fVisibleDensity

G4int	fWindowLocationHintX

G4bool	fWindowLocationHintXNegative

G4int	fWindowLocationHintY

G4bool	fWindowLocationHintYNegative

G4int	fWindowSizeHintX

G4int	fWindowSizeHintY

G4String	fXGeometryString

G4double	fZoomFactor

Friends
std::ostream &	operator<< (std::ostream &, const DrawingStyle &)

std::ostream &	operator<< (std::ostream &, const G4ViewParameters &)

Detailed Description

Definition at line 90 of file G4ViewParameters.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
fNoValue
fXValue
fYValue
fWidthValue
fHeightValue
fAllValues
fXNegative
fYNegative

Definition at line 397 of file G4ViewParameters.hh.

       { // Constants for geometry mask in ParseGeometry and related functions.
    fNoValue     = 0,
    fXValue      = 0x0001,
    fYValue      = 0x0002,
    fWidthValue  = 0x0004,
    fHeightValue = 0x0008,
    fAllValues   = 0x000F,
    fXNegative   = 0x0010,
    fYNegative   = 0x0020
  };

◆ CutawayMode

enum G4ViewParameters::CutawayMode

Enumerator
cutawayUnion
cutawayIntersection

Definition at line 102 of file G4ViewParameters.hh.

                   {
    cutawayUnion,       // Union (addition) of result of each cutaway plane.
    cutawayIntersection // Intersection (multiplication) " .
  };

◆ DrawingStyle

enum G4ViewParameters::DrawingStyle

Enumerator
wireframe
hlr
hsr
hlhsr
cloud

Definition at line 94 of file G4ViewParameters.hh.

                    {
    wireframe,  // Draw edges    - no hidden line removal.
    hlr,        // Draw edges    - hidden lines removed.
    hsr,        // Draw surfaces - hidden surfaces removed.
    hlhsr,      // Draw surfaces and edges - hidden removed.
    cloud       // Draw volume as a cloud of dots.
  };

◆ RotationStyle

enum G4ViewParameters::RotationStyle

Enumerator
constrainUpDirection
freeRotation

Definition at line 107 of file G4ViewParameters.hh.

                     {
    constrainUpDirection,  // Standard, HEP convention.
    freeRotation           // Free, Google-like rotation, using mouse-grab.
  };

Constructor & Destructor Documentation

◆ G4ViewParameters()

G4ViewParameters::G4ViewParameters ( )

Definition at line 43 of file G4ViewParameters.cc.

                                   :
  fDrawingStyle (wireframe),
  fNumberOfCloudPoints(10000),
  fAuxEdgeVisible (false),
  fCulling (true),
  fCullInvisible (true),
  fDensityCulling (false),
  fVisibleDensity (0.01 * g / cm3),
  fCullCovered (false),
  fCBDAlgorithmNumber (0),
  fSection (false),
  fSectionPlane (),
  fCutawayMode (cutawayUnion),
  fCutawayPlanes (),
  fExplodeFactor (1.),
  fNoOfSides (),
  fViewpointDirection (G4Vector3D (0., 0., 1.)),  // On z-axis.
  fUpVector (G4Vector3D (0., 1., 0.)),            // y-axis up.
  fFieldHalfAngle (0.),                           // Orthogonal projection.
  fZoomFactor (1.),
  fScaleFactor (G4Vector3D (1., 1., 1.)),
  fCurrentTargetPoint (),
  fDolly (0.),
  fLightsMoveWithCamera (false),
  fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
  fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
  fDefaultVisAttributes (),
  fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
  fDefaultMarker (),
  fGlobalMarkerScale (1.),
  fGlobalLineWidthScale (1.),
  fMarkerNotHidden (true),
  fWindowSizeHintX (600),
  fWindowSizeHintY (600),
  fWindowLocationHintX(0),
  fWindowLocationHintY(0),
  fWindowLocationHintXNegative(true),
  fWindowLocationHintYNegative(false),
  fGeometryMask(0),
  fAutoRefresh (false),
  fBackgroundColour (G4Colour(0.,0.,0.)),         // Black
  fPicking (false),
  fRotationStyle (constrainUpDirection),
  fStartTime(-G4VisAttributes::fVeryLongTime),
  fEndTime(G4VisAttributes::fVeryLongTime),
  fFadeFactor(0.),
  fDisplayHeadTime(false),
  fDisplayHeadTimeX(-0.9),
  fDisplayHeadTimeY(-0.9),
  fDisplayHeadTimeSize(24.),
  fDisplayHeadTimeRed(0.),
  fDisplayHeadTimeGreen(1.),
  fDisplayHeadTimeBlue(1.),
  fDisplayLightFront(false),
  fDisplayLightFrontX(0.),
  fDisplayLightFrontY(0.),
  fDisplayLightFrontZ(0.),
  fDisplayLightFrontT(0.),
  fDisplayLightFrontRed(0.),
  fDisplayLightFrontGreen(1.),
  fDisplayLightFrontBlue(0.),
  fSpecialMeshRendering(false)
{
  // Pick up default no of sides from G4Polyhedron.
  // Note that this parameter is variously called:
  //   No of sides
  //   NumberOfRotationSteps
  //   Line segments per circle
  // It refers to the approximation of a circle by a polygon of
  // stated number of sides.
  fNoOfSides = G4Polyhedron::GetNumberOfRotationSteps();
  
  fDefaultMarker.SetScreenSize (5.);
  // Markers are 5 pixels "overall" size, i.e., diameter.
}

References fDefaultMarker, fNoOfSides, HepPolyhedron::GetNumberOfRotationSteps(), and G4VMarker::SetScreenSize().

◆ ~G4ViewParameters()

G4ViewParameters::~G4ViewParameters ( )

Definition at line 119 of file G4ViewParameters.cc.

119{}

Member Function Documentation

◆ AddCutawayPlane()

void G4ViewParameters::AddCutawayPlane ( const G4Plane3D & cutawayPlane )

Definition at line 181 of file G4ViewParameters.cc.

                                                                     {
  if (fCutawayPlanes.size () < 3 ) {
    fCutawayPlanes.push_back (cutawayPlane);
  }
  else {
    G4cerr <<
      "ERROR: G4ViewParameters::AddCutawayPlane:"
      "\n  A maximum of 3 cutaway planes supported." << G4endl;
  }
}

References fCutawayPlanes, G4cerr, and G4endl.

Referenced by G4VisCommandViewerAddCutawayPlane::SetNewValue().

◆ AddVisAttributesModifier()

void G4ViewParameters::AddVisAttributesModifier ( const G4ModelingParameters::VisAttributesModifier & vam )

Definition at line 298 of file G4ViewParameters.cc.

                                                       {
  // If target exists with same signifier just change vis attributes.
  G4bool duplicateTarget = false;
  auto i = fVisAttributesModifiers.begin();
  for (; i < fVisAttributesModifiers.end(); ++i) {
    if (vam.GetPVNameCopyNoPath() == (*i).GetPVNameCopyNoPath() &&
        vam.GetVisAttributesSignifier() == (*i).GetVisAttributesSignifier()) {
      duplicateTarget = true;
      break;
    }
  }
  if (duplicateTarget) (*i).SetVisAttributes(vam.GetVisAttributes());
  else fVisAttributesModifiers.push_back(vam);
}

References fVisAttributesModifiers, G4ModelingParameters::VisAttributesModifier::GetPVNameCopyNoPath(), G4ModelingParameters::VisAttributesModifier::GetVisAttributes(), and G4ModelingParameters::VisAttributesModifier::GetVisAttributesSignifier().

Referenced by G4VisCommandsTouchableSet::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4VViewer::TouchableSetColour(), and G4VViewer::TouchableSetVisibility().

◆ CameraAndLightingCommands()

G4String G4ViewParameters::CameraAndLightingCommands ( const G4Point3D standardTargetPoint ) const

Definition at line 314 of file G4ViewParameters.cc.

{
  std::ostringstream oss;
 
  oss << "#\n# Camera and lights commands";
  
  oss << "\n/vis/viewer/set/viewpointVector "
  << fViewpointDirection.x()
  << ' ' << fViewpointDirection.y()
  << ' ' << fViewpointDirection.z();
  
  oss << "\n/vis/viewer/set/upVector "
  << fUpVector.x()
  << ' ' << fUpVector.y()
  << ' ' << fUpVector.z();
  
  oss << "\n/vis/viewer/set/projection ";
    if (fFieldHalfAngle == 0.) {
    oss
    << "orthogonal";
  } else {
    oss
    << "perspective "
    << fFieldHalfAngle/deg
    << " deg";
  }
  
  oss << "\n/vis/viewer/zoomTo "
  << fZoomFactor;
  
  oss << "\n/vis/viewer/scaleTo "
  << fScaleFactor.x()
  << ' ' << fScaleFactor.y()
  << ' ' << fScaleFactor.z();
  
  oss << "\n/vis/viewer/set/targetPoint "
  << G4BestUnit(standardTargetPoint+fCurrentTargetPoint,"Length")
  << "\n# Note that if you have not set a target point, the vis system sets"
  << "\n# a target point based on the scene - plus any panning and dollying -"
  << "\n# so don't be alarmed by strange coordinates here.";
  
  oss << "\n/vis/viewer/dollyTo "
  << G4BestUnit(fDolly,"Length");
  
  oss << "\n/vis/viewer/set/lightsMove ";
  if (fLightsMoveWithCamera) {
    oss << "camera";
  } else {
    oss << "object";
  }
  
  oss << "\n/vis/viewer/set/lightsVector "
  << fRelativeLightpointDirection.x()
  << ' ' << fRelativeLightpointDirection.y()
  << ' ' << fRelativeLightpointDirection.z();
  
  oss << "\n/vis/viewer/set/rotationStyle ";
  if (fRotationStyle == constrainUpDirection) {
    oss << "constrainUpDirection";
  } else {
    oss << "freeRotation";
  }
  
  G4Colour c = fBackgroundColour;
  oss << "\n/vis/viewer/set/background "
  << c.GetRed()
  << ' ' << c.GetGreen()
  << ' ' << c.GetBlue()
  << ' ' << c.GetAlpha();
  
  c = fDefaultVisAttributes.GetColour();
  oss << "\n/vis/viewer/set/defaultColour "
  << c.GetRed()
  << ' ' << c.GetGreen()
  << ' ' << c.GetBlue()
  << ' ' << c.GetAlpha();
  
  c = fDefaultTextVisAttributes.GetColour();
  oss << "\n/vis/viewer/set/defaultTextColour "
  << c.GetRed()
  << ' ' << c.GetGreen()
  << ' ' << c.GetBlue()
  << ' ' << c.GetAlpha();
  
  oss << std::endl;
  
  return oss.str();
}

References constrainUpDirection, deg, fBackgroundColour, fCurrentTargetPoint, fDefaultTextVisAttributes, fDefaultVisAttributes, fDolly, fFieldHalfAngle, fLightsMoveWithCamera, fRelativeLightpointDirection, fRotationStyle, fScaleFactor, fUpVector, fViewpointDirection, fZoomFactor, G4BestUnit, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4Colour::GetGreen(), G4Colour::GetRed(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by anonymous_namespace{G4VisCommandsViewer.cc}::WriteCommands().

◆ CatmullRomCubicSplineInterpolation()

G4ViewParameters * G4ViewParameters::CatmullRomCubicSplineInterpolation	(	const std::vector< G4ViewParameters > &	views,
		G4int	nInterpolationPoints = `50`
	)

static

Definition at line 1419 of file G4ViewParameters.cc.

{
  // Returns a null pointer when no more to be done.  For example:
  // do {
  //   G4ViewParameters* vp =
  //   G4ViewParameters::CatmullRomCubicSplineInterpolation(viewVector,nInterpolationPoints);
  //   if (!vp) break;
  //     ...
  // } while (true);
 
  // See https://en.wikipedia.org/wiki/Cubic_Hermite_spline
 
  // Assumes equal intervals
 
  if (views.size() < 2) {
    G4Exception
    ("G4ViewParameters::CatmullRomCubicSplineInterpolation",
     "visman0301", JustWarning,
     "There must be at least two views.");
    return 0;
  }
 
  if (nInterpolationPoints < 1) {
    G4Exception
    ("G4ViewParameters::CatmullRomCubicSplineInterpolation",
     "visman0302", JustWarning,
     "Number of interpolation points cannot be zero or negative.");
    return 0;
  }
 
  const size_t nIntervals = views.size() - 1;
  const G4double dt = 1./nInterpolationPoints;
 
  static G4ViewParameters holdingValues;
  static G4double t = 0.;  // 0. <= t <= 1.
  static G4int iInterpolationPoint = 0;
  static size_t iInterval = 0;
 
//  G4cout << "Interval " << iInterval << ", t = " << t << G4endl;
 
  // Hermite polynomials.
  const G4double h00 = 2.*t*t*t - 3.*t*t +1;
  const G4double h10 = t*t*t -2.*t*t + t;
  const G4double h01 = -2.*t*t*t + 3.*t*t;
  const G4double h11 = t*t*t - t*t;
 
  // Aliases (to simplify code)
  const size_t& n = nIntervals;
  size_t& i = iInterval;
  const std::vector<G4ViewParameters>& v = views;
 
  // The Catmull-Rom cubic spline prescription is as follows:
  // Slope at first way point is v[1] - v[0].
  // Slope at last way point is v[n] - v[n-1].
  // Otherwise slope at way point i is 0.5*(v[i+1] - v[i-1]).
  // Result = h00*v[i] + h10*m[i] + h01*v[i+1] + h11*m[i+1],
  // where m[i] amd m[i+1] are the slopes at the start and end
  // of the interval for the particular value.
  // If (n == 1), linear interpolation results.
  // If (n == 2), quadratic interpolation results.
 
  // Working variables
  G4double mi, mi1, real, x, y, z;
  
  // First, a crude interpolation of all parameters.  Then, below, a
  // smooth interpolation of those for which it makes sense.
  holdingValues = t < 0.5? v[i]: v[i+1];
 
  // Catmull-Rom cubic spline interpolation
#define INTERPOLATE(param) \
/* This works out the interpolated param in i'th interval */ \
/* Assumes n >= 1 */ \
if (i == 0) { \
/* First interval */ \
mi = v[1].param - v[0].param; \
/* If there is only one interval, make start and end slopes equal */ \
/* (This results in a linear interpolation) */ \
if (n == 1) mi1 = mi; \
/* else the end slope of the interval takes account of the next waypoint along */ \
else mi1 = 0.5 * (v[2].param - v[0].param); \
} else if (i >= n - 1) { \
/* Similarly for last interval */ \
mi1 = v[i+1].param - v[i].param; \
/* If there is only one interval, make start and end slopes equal */ \
if (n == 1) mi = mi1; \
/* else the start slope of the interval takes account of the previous waypoint */ \
else mi = 0.5 * (v[i+1].param - v[i-1].param); \
} else { \
/* Full Catmull-Rom slopes use previous AND next waypoints */ \
mi  = 0.5 * (v[i+1].param - v[i-1].param); \
mi1 = 0.5 * (v[i+2].param - v[i  ].param); \
} \
real = h00 * v[i].param + h10 * mi + h01 * v[i+1].param + h11 * mi1;
 
#define INTERPOLATELOG(param) \
if (i == 0) { \
mi = std::log(v[1].param) - std::log(v[0].param); \
if (n == 1) mi1 = mi; \
else mi1 = 0.5 * (std::log(v[2].param) - std::log(v[0].param)); \
} else if (i >= n - 1) { \
mi1 = std::log(v[i+1].param) - std::log(v[i].param); \
if (n == 1) mi = mi1; \
else mi = 0.5 * (std::log(v[i+1].param) - std::log(v[i-1].param)); \
} else { \
mi  = 0.5 * (std::log(v[i+1].param) - std::log(v[i-1].param)); \
mi1 = 0.5 * (std::log(v[i+2].param) - std::log(v[i  ].param)); \
} \
real = std::exp(h00 * std::log(v[i].param) + h10 * mi + h01 * std::log(v[i+1].param) + h11 * mi1);
 
  // Real parameters
  INTERPOLATE(fVisibleDensity);
  if (real < 0.) real = 0.;
  holdingValues.fVisibleDensity = real;
  INTERPOLATELOG(fExplodeFactor);
  holdingValues.fExplodeFactor = real;
  INTERPOLATE(fFieldHalfAngle);
  if (real < 0.) real = 0.;
  holdingValues.fFieldHalfAngle = real;
  INTERPOLATELOG(fZoomFactor);
  holdingValues.fZoomFactor = real;
  INTERPOLATE(fDolly);
  holdingValues.fDolly = real;
  INTERPOLATE(fGlobalMarkerScale);
  if (real < 0.) real = 0.;
  holdingValues.fGlobalMarkerScale = real;
  INTERPOLATE(fGlobalLineWidthScale);
  if (real < 0.) real = 0.;
  holdingValues.fGlobalLineWidthScale = real;
 
  // Unit vectors
#define INTERPOLATEUNITVECTOR(vector) \
INTERPOLATE(vector.x()); x = real; \
INTERPOLATE(vector.y()); y = real; \
INTERPOLATE(vector.z()); z = real;
  INTERPOLATEUNITVECTOR(fViewpointDirection);
  holdingValues.fViewpointDirection          = G4Vector3D(x,y,z).unit();
  INTERPOLATEUNITVECTOR(fUpVector);
  holdingValues.fUpVector                    = G4Vector3D(x,y,z).unit();
  INTERPOLATEUNITVECTOR(fRelativeLightpointDirection);
  holdingValues.fRelativeLightpointDirection = G4Vector3D(x,y,z).unit();
  INTERPOLATEUNITVECTOR(fActualLightpointDirection);
  holdingValues.fActualLightpointDirection   = G4Vector3D(x,y,z).unit();
 
  // Un-normalised vectors
#define INTERPOLATEVECTOR(vector) \
INTERPOLATE(vector.x()); x = real; \
INTERPOLATE(vector.y()); y = real; \
INTERPOLATE(vector.z()); z = real;
  INTERPOLATEVECTOR(fScaleFactor);
  holdingValues.fScaleFactor = G4Vector3D(x,y,z);
 
  // Points
#define INTERPOLATEPOINT(point) \
INTERPOLATE(point.x()); x = real; \
INTERPOLATE(point.y()); y = real; \
INTERPOLATE(point.z()); z = real;
  INTERPOLATEPOINT(fExplodeCentre);
  holdingValues.fExplodeCentre      = G4Point3D(x,y,z);
  INTERPOLATEPOINT(fCurrentTargetPoint);
  holdingValues.fCurrentTargetPoint = G4Point3D(x,y,z);
 
  // Colour
  G4double red, green, blue, alpha;
#define INTERPOLATECOLOUR(colour) \
INTERPOLATE(colour.GetRed());   red   = real; \
INTERPOLATE(colour.GetGreen()); green = real; \
INTERPOLATE(colour.GetBlue());  blue  = real; \
INTERPOLATE(colour.GetAlpha()); alpha = real;
  INTERPOLATECOLOUR(fBackgroundColour);
  // Components are clamped to 0. <= component <= 1.
  holdingValues.fBackgroundColour = G4Colour(red,green,blue,alpha);
 
  // For some parameters we need to check some continuity
  G4bool continuous;
#define CONTINUITY(quantity) \
  continuous = false; \
  /* This follows the logic of the INTERPOLATE macro above; see comments therein */ \
  if (i == 0) { \
    if (v[1].quantity == v[0].quantity) { \
       if (n == 1) continuous = true; \
       else if (v[2].quantity == v[0].quantity) \
       continuous = true; \
    } \
  } else if (i >= n - 1) { \
    if (v[i+1].quantity == v[i].quantity) { \
      if (n == 1) continuous = true; \
      else if (v[i+1].quantity == v[i-1].quantity) \
      continuous = true; \
    } \
  } else { \
    if (v[i-1].quantity == v[i].quantity && \
        v[i+1].quantity == v[i].quantity && \
        v[i+2].quantity == v[i].quantity) \
    continuous = true; \
  }
 
  G4double a, b, c, d;
#define INTERPOLATEPLANE(plane) \
INTERPOLATE(plane.a()); a = real; \
INTERPOLATE(plane.b()); b = real; \
INTERPOLATE(plane.c()); c = real; \
INTERPOLATE(plane.d()); d = real;
 
  // Section plane
  CONTINUITY(fSection);
  if (continuous) {
    INTERPOLATEPLANE(fSectionPlane);
    holdingValues.fSectionPlane = G4Plane3D(a,b,c,d);
  }
 
  // Cutaway planes
  if (v[i].fCutawayPlanes.size()) {
    CONTINUITY(fCutawayPlanes.size());
    if (continuous) {
      for (size_t j = 0; j < v[i].fCutawayPlanes.size(); ++j) {
        INTERPOLATEPLANE(fCutawayPlanes[j]);
        holdingValues.fCutawayPlanes[j] = G4Plane3D(a,b,c,d);
      }
    }
  }
 
  // Vis attributes modifiers
  // Really, we are only interested in colour - other attributes can follow
  // the "crude" interpolation that is guaranteed above.
  static G4VisAttributes workingVA;
  if  (v[i].fVisAttributesModifiers.size()) {
    CONTINUITY(fVisAttributesModifiers.size());
    if (continuous) {
      for (size_t j = 0; j < v[i].fVisAttributesModifiers.size(); ++j) {
        CONTINUITY(fVisAttributesModifiers[j].GetPVNameCopyNoPath());
        if (continuous) {
          CONTINUITY(fVisAttributesModifiers[j].GetVisAttributesSignifier());
          if (continuous) {
            if (v[i].fVisAttributesModifiers[j].GetVisAttributesSignifier() ==
                G4ModelingParameters::VASColour) {
              INTERPOLATECOLOUR(fVisAttributesModifiers[j].GetVisAttributes().GetColour());
              workingVA = v[i].fVisAttributesModifiers[j].GetVisAttributes();
              workingVA.SetColour(G4Colour(red,green,blue,alpha));
              holdingValues.fVisAttributesModifiers[j].SetVisAttributes(workingVA);
            }
          }
        }
      }
    }
  }
 
  // Time window parameters (for showing particles in flight)
  // Only two parameters are interpolated. The others are usually chosen
  // once and for all by the user for a given series of views - or at least,
  // if not, they will be interpolated by the default "crude" method above.
  INTERPOLATE(fStartTime)
  holdingValues.fStartTime = real;
  INTERPOLATE(fEndTime)
  holdingValues.fEndTime = real;
 
  // Increment counters
  iInterpolationPoint++;
  t += dt;
  if (iInterpolationPoint > nInterpolationPoints) {
    iInterpolationPoint = 1;  // Ready for next interval.
    t = dt;
    iInterval++;
  }
  if (iInterval >= nIntervals) {
    iInterpolationPoint = 0;  // Ready for a complete restart.
    t = 0.;
    iInterval = 0;
    return 0;
  }
 
  return &holdingValues;
}

References alpha, CONTINUITY, fActualLightpointDirection, fBackgroundColour, fCurrentTargetPoint, fCutawayPlanes, fDolly, fEndTime, fExplodeCentre, fExplodeFactor, fFieldHalfAngle, fGlobalLineWidthScale, fGlobalMarkerScale, fRelativeLightpointDirection, fScaleFactor, fSection, fSectionPlane, fStartTime, fUpVector, fViewpointDirection, fVisAttributesModifiers, fVisibleDensity, fZoomFactor, G4Exception(), INTERPOLATE, INTERPOLATECOLOUR, INTERPOLATELOG, INTERPOLATEPLANE, INTERPOLATEPOINT, INTERPOLATEUNITVECTOR, INTERPOLATEVECTOR, JustWarning, anonymous_namespace{G4QuasiElRatios.cc}::mi, CLHEP::detail::n, G4VisAttributes::SetColour(), HepGeom::BasicVector3D< T >::unit(), and G4ModelingParameters::VASColour.

Referenced by G4VVisCommand::InterpolateViews().

◆ ChangeCutawayPlane()

void G4ViewParameters::ChangeCutawayPlane	(	size_t	index,
		const G4Plane3D &	cutawayPlane
	)

Definition at line 192 of file G4ViewParameters.cc.

                                              {
  if (index >= fCutawayPlanes.size()) {
    G4cerr <<
      "ERROR: G4ViewParameters::ChangeCutawayPlane:"
      "\n  Plane " << index << " does not exist." << G4endl;
  } else {
    fCutawayPlanes[index] = cutawayPlane;
  }
}

References fCutawayPlanes, G4cerr, and G4endl.

Referenced by G4VisCommandViewerChangeCutawayPlane::SetNewValue().

◆ ClearCutawayPlanes()

void G4ViewParameters::ClearCutawayPlanes ( )

Referenced by G4VisCommandViewerClearCutawayPlanes::SetNewValue().

◆ ClearVisAttributesModifiers()

void G4ViewParameters::ClearVisAttributesModifiers ( )

Referenced by G4VisCommandViewerClearVisAttributesModifiers::SetNewValue().

◆ DrawingStyleCommands()

G4String G4ViewParameters::DrawingStyleCommands ( ) const

Definition at line 404 of file G4ViewParameters.cc.

{
  std::ostringstream oss;
  
  oss << "#\n# Drawing style commands";
  
  oss << "\n/vis/viewer/set/style ";
  switch (fDrawingStyle) {
    case wireframe:
    case hlr:
      oss << "wireframe";
      break;
    case hsr:
    case hlhsr:
      oss << "surface";
      break;
    case cloud:
      oss << "cloud";
      break;
  }
 
  oss << "\n/vis/viewer/set/hiddenEdge ";
  if (fDrawingStyle == hlr || fDrawingStyle == hlhsr) {
    oss << "true";
  } else {
    oss << "false";
  }
  
  oss << "\n/vis/viewer/set/auxiliaryEdge ";
  if (fAuxEdgeVisible) {
    oss << "true";
  } else {
    oss << "false";
  }
  
  oss << "\n/vis/viewer/set/hiddenMarker ";
  if (fMarkerNotHidden) {
    oss << "false";
  } else {
    oss << "true";
  }
  
  oss << "\n/vis/viewer/set/globalLineWidthScale "
  << fGlobalLineWidthScale;
  
  oss << "\n/vis/viewer/set/globalMarkerScale "
  << fGlobalMarkerScale;
 
  oss << "\n/vis/viewer/set/numberOfCloudPoints "
  << fNumberOfCloudPoints;
 
  oss << "\n/vis/viewer/set/specialMeshRendering ";
  if (fSpecialMeshRendering) {
    oss << "true";
  } else {
    oss << "false";
  }
 
  oss << "\n/vis/viewer/set/specialMeshVolumes";
  for (const auto& volume : fSpecialMeshVolumes) {
    oss << ' ' << volume.GetName() << ' ' << volume.GetCopyNo();
  }
 
  oss << std::endl;
  
  return oss.str();
}

References cloud, fAuxEdgeVisible, fDrawingStyle, fGlobalLineWidthScale, fGlobalMarkerScale, fMarkerNotHidden, fNumberOfCloudPoints, fSpecialMeshRendering, fSpecialMeshVolumes, hlhsr, hlr, hsr, and wireframe.

Referenced by anonymous_namespace{G4VisCommandsViewer.cc}::WriteCommands().

◆ GetActualLightpointDirection()

G4Vector3D & G4ViewParameters::GetActualLightpointDirection ( )

Definition at line 128 of file G4ViewParameters.cc.

                                                            {
  SetViewAndLights (fViewpointDirection);
  return fActualLightpointDirection;
}

References fActualLightpointDirection, fViewpointDirection, and SetViewAndLights().

Referenced by G4VisCommandsViewerSet::SetNewValue(), G4OpenGLViewer::SetView(), G4RayTracerViewer::SetView(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView().

◆ GetBackgroundColour()

const G4Colour & G4ViewParameters::GetBackgroundColour ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VVisCommand::CopyMostViewParameters(), G4OpenGLStoredViewer::DrawDisplayLists(), G4VtkViewer::DrawViewHUD(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Export(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLViewer::SetView(), G4OpenInventorQtViewer::SetView(), G4OpenInventorWinViewer::SetView(), G4OpenInventorXtExtendedViewer::SetView(), G4OpenInventorXtViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4VtkViewer::ShowView(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetCameraDistance()

G4double G4ViewParameters::GetCameraDistance ( G4double radius ) const

Definition at line 141 of file G4ViewParameters.cc.

                                                                   {
  G4double cameraDistance;
  if (fFieldHalfAngle == 0.) {
    cameraDistance = radius;
  }
  else {
    cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
  }
  return cameraDistance;
}

References fDolly, and fFieldHalfAngle.

Referenced by G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), and G4VtkViewer::SetView().

◆ GetCBDAlgorithmNumber()

G4int G4ViewParameters::GetCBDAlgorithmNumber ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisCommandViewerColourByDensity::SetNewValue().

◆ GetCBDParameters()

const std::vector< G4double > & G4ViewParameters::GetCBDParameters ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisCommandViewerColourByDensity::SetNewValue().

◆ GetCurrentTargetPoint()

const G4Point3D & G4ViewParameters::GetCurrentTargetPoint ( ) const

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLXmViewer::left_right_pan_callback(), G4DAWNFILEViewer::SendViewParameters(), G4VRML2FileViewer::SendViewParameters(), G4VisCommandViewerPan::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4OpenGLXmViewer::up_down_pan_callback(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetCutawayMode()

CutawayMode G4ViewParameters::GetCutawayMode ( ) const

Referenced by G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLImmediateViewer::ProcessView(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLViewer::SetView(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetCutawayPlanes()

const G4Planes & G4ViewParameters::GetCutawayPlanes ( ) const

Referenced by G4OpenInventorViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLImmediateViewer::ProcessView(), G4VisCommandViewerAddCutawayPlane::SetNewValue(), G4VisCommandViewerChangeCutawayPlane::SetNewValue(), and G4OpenGLViewer::SetView().

◆ GetDefaultMarker()

const G4VMarker & G4ViewParameters::GetDefaultMarker ( ) const

◆ GetDefaultTextVisAttributes()

const G4VisAttributes * G4ViewParameters::GetDefaultTextVisAttributes ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::GetTextColour(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetDefaultVisAttributes()

const G4VisAttributes * G4ViewParameters::GetDefaultVisAttributes ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::GetColour(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetDisplayHeadTimeBlue()

G4double G4ViewParameters::GetDisplayHeadTimeBlue ( ) const

◆ GetDisplayHeadTimeGreen()

G4double G4ViewParameters::GetDisplayHeadTimeGreen ( ) const

◆ GetDisplayHeadTimeRed()

G4double G4ViewParameters::GetDisplayHeadTimeRed ( ) const

◆ GetDisplayHeadTimeSize()

G4double G4ViewParameters::GetDisplayHeadTimeSize ( ) const

◆ GetDisplayHeadTimeX()

G4double G4ViewParameters::GetDisplayHeadTimeX ( ) const

◆ GetDisplayHeadTimeY()

G4double G4ViewParameters::GetDisplayHeadTimeY ( ) const

◆ GetDisplayLightFrontBlue()

G4double G4ViewParameters::GetDisplayLightFrontBlue ( ) const

◆ GetDisplayLightFrontGreen()

G4double G4ViewParameters::GetDisplayLightFrontGreen ( ) const

◆ GetDisplayLightFrontRed()

G4double G4ViewParameters::GetDisplayLightFrontRed ( ) const

◆ GetDisplayLightFrontT()

G4double G4ViewParameters::GetDisplayLightFrontT ( ) const

◆ GetDisplayLightFrontX()

G4double G4ViewParameters::GetDisplayLightFrontX ( ) const

◆ GetDisplayLightFrontY()

G4double G4ViewParameters::GetDisplayLightFrontY ( ) const

◆ GetDisplayLightFrontZ()

G4double G4ViewParameters::GetDisplayLightFrontZ ( ) const

◆ GetDolly()

G4double G4ViewParameters::GetDolly ( ) const

Referenced by G4OpenGLXmViewer::actions_callback(), G4VVisCommand::CopyCameraParameters(), G4OpenGLXmViewer::ResetView(), G4DAWNFILEViewer::SendViewParameters(), G4OpenGLXmViewerMessenger::SetNewValue(), G4VisCommandViewerDolly::SetNewValue(), G4OpenGLWin32Viewer::SetZoom(), G4OpenGLXmViewer::UpdateControlPanel(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate(), and G4Qt3DViewer::wheelEvent().

◆ GetDrawingStyle()

DrawingStyle G4ViewParameters::GetDrawingStyle ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLXmViewer::CreateMainWindow(), G4VSceneHandler::CreateModelingParameters(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4VSceneHandler::GetDrawingStyle(), G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI(), G4VisCommandDrawLogicalVolume::SetNewValue(), G4VisCommandViewerDefaultHiddenEdge::SetNewValue(), G4VisCommandViewerDefaultStyle::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenInventorViewer::SetReducedWireFrame(), G4OpenInventorViewer::SetSolid(), G4OpenInventorViewer::SetWireFrame(), G4OpenGLQtViewer::updateToolbarAndMouseContextMenu(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetEndTime()

G4double G4ViewParameters::GetEndTime ( ) const

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ GetExplodeCentre()

const G4Point3D & G4ViewParameters::GetExplodeCentre ( ) const

Referenced by G4VSceneHandler::CreateModelingParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ GetExplodeFactor()

G4double G4ViewParameters::GetExplodeFactor ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetFadeFactor()

G4double G4ViewParameters::GetFadeFactor ( ) const

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ GetFarDistance()

G4double G4ViewParameters::GetFarDistance	(	G4double	cameraDistance,
		G4double	nearDistance,
		G4double	radius
	)		const

Definition at line 160 of file G4ViewParameters.cc.

                                              {
  G4double farDistance = cameraDistance + radius;
  if (farDistance < nearDistance) farDistance = nearDistance;
  return farDistance;
}

Referenced by G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::SetView(), G4Qt3DViewer::SetView(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView().

◆ GetFieldHalfAngle()

G4double G4ViewParameters::GetFieldHalfAngle ( ) const

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLStoredViewer::DrawDisplayLists(), G4RayTracerViewer::DrawView(), G4OpenGLXmViewer::misc_callback(), G4DAWNFILEViewer::SendViewParameters(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4OpenGLWin32Viewer::SetZoom(), G4OpenGLQtViewer::updateToolbarAndMouseContextMenu(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate(), and G4Qt3DViewer::wheelEvent().

◆ GetFrontHalfHeight()

G4double G4ViewParameters::GetFrontHalfHeight	(	G4double	nearDistance,
		G4double	radius
	)		const

Definition at line 168 of file G4ViewParameters.cc.

                                                  {
  G4double frontHalfHeight;
  if (fFieldHalfAngle == 0.) {
    frontHalfHeight = radius / fZoomFactor;
  }
  else {
    frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
  }
  return frontHalfHeight;
}

References fFieldHalfAngle, and fZoomFactor.

Referenced by G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView().

◆ GetGlobalLineWidthScale()

G4double G4ViewParameters::GetGlobalLineWidthScale ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetGlobalMarkerScale()

G4double G4ViewParameters::GetGlobalMarkerScale ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetLightpointDirection()

const G4Vector3D & G4ViewParameters::GetLightpointDirection ( ) const

Referenced by G4VVisCommand::CopyCameraParameters(), G4VisCommandsViewerSet::SetNewValue(), G4VtkViewer::SetView(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetLightsMoveWithCamera()

G4bool G4ViewParameters::GetLightsMoveWithCamera ( ) const

Referenced by G4OpenGLXmViewer::actions_callback(), G4VVisCommand::CopyCameraParameters(), G4OpenGLViewer::rotateSceneThetaPhi(), G4VisCommandsViewerSet::SetNewValue(), G4VtkViewer::SetView(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetNearDistance()

G4double G4ViewParameters::GetNearDistance	(	G4double	cameraDistance,
		G4double	radius
	)		const

Definition at line 152 of file G4ViewParameters.cc.

                                               {
  const G4double small = 1.e-6 * radius;
  G4double nearDistance = cameraDistance - radius;
  if (nearDistance < small) nearDistance = small;
  return nearDistance;
}

Referenced by G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView().

◆ GetNoOfSides()

G4int G4ViewParameters::GetNoOfSides ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::GetNoOfSides(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetNumberOfCloudPoints()

G4int G4ViewParameters::GetNumberOfCloudPoints ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::GetNumberOfCloudPoints(), and G4VSceneHandler::RequestPrimitives().

◆ GetRotationStyle()

RotationStyle G4ViewParameters::GetRotationStyle ( ) const

Referenced by G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4OpenGLViewer::rotateScene(), G4OpenGLViewer::rotateSceneToggle(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetRotation(), G4VtkViewer::SetView(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetScaleFactor()

const G4Vector3D & G4ViewParameters::GetScaleFactor ( ) const

Referenced by G4OpenInventorSceneHandler::AddTransform(), G4OpenInventorViewer::CompareForKernelVisit(), G4VVisCommand::CopyCameraParameters(), G4VisCommandViewerScale::SetNewValue(), and G4OpenGLViewer::SetView().

◆ GetSectionPlane()

const G4Plane3D & G4ViewParameters::GetSectionPlane ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4VSceneHandler::CreateSectionSolid(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetSpecialMeshVolumes()

const std::vector< G4ModelingParameters::PVNameCopyNo > & G4ViewParameters::GetSpecialMeshVolumes ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ GetStartTime()

G4double G4ViewParameters::GetStartTime ( ) const

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ GetUpVector()

const G4Vector3D & G4ViewParameters::GetUpVector ( ) const

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4VVisCommand::CopyCameraParameters(), G4OpenGLXmViewer::left_right_pan_callback(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetRotation(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4OpenGLXmViewer::up_down_pan_callback(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), and G4OpenGLXmViewer::wobble_timer_callback().

◆ GetViewpointDirection()

const G4Vector3D & G4ViewParameters::GetViewpointDirection ( ) const

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLXmViewer::left_right_pan_callback(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4DAWNFILEViewer::SendViewParameters(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetRotation(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4OpenGLXmViewer::up_down_pan_callback(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), and G4OpenGLXmViewer::wobble_callback().

◆ GetVisAttributesModifiers()

const std::vector< G4ModelingParameters::VisAttributesModifier > & G4ViewParameters::GetVisAttributesModifiers ( ) const

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), and G4VSceneHandler::CreateModelingParameters().

◆ GetVisibleDensity()

G4double G4ViewParameters::GetVisibleDensity ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ GetWindowAbsoluteLocationHintX()

G4int G4ViewParameters::GetWindowAbsoluteLocationHintX ( G4int sizeX ) const

Definition at line 1275 of file G4ViewParameters.cc.

                                                                          {
  if ( fWindowLocationHintXNegative ) {
    return  sizeX  + fWindowLocationHintX - fWindowSizeHintX;
  }
  return fWindowLocationHintX;
}

References fWindowLocationHintX, fWindowLocationHintXNegative, and fWindowSizeHintX.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise().

◆ GetWindowAbsoluteLocationHintY()

G4int G4ViewParameters::GetWindowAbsoluteLocationHintY ( G4int sizeY ) const

Definition at line 1282 of file G4ViewParameters.cc.

                                                                          {
  if (  fWindowLocationHintYNegative ) {
    return  sizeY  + fWindowLocationHintY - fWindowSizeHintY;
  }
  return fWindowLocationHintY;
}

References fWindowLocationHintY, fWindowLocationHintYNegative, and fWindowSizeHintY.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise().

◆ GetWindowLocationHintX()

G4int G4ViewParameters::GetWindowLocationHintX ( ) const

Referenced by G4VtkViewer::Initialise().

◆ GetWindowLocationHintY()

G4int G4ViewParameters::GetWindowLocationHintY ( ) const

Referenced by G4VtkViewer::Initialise().

◆ GetWindowSizeHintX()

unsigned int G4ViewParameters::GetWindowSizeHintX ( ) const

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLXmViewer::GetXmConnection(), G4OpenInventorQtViewer::Initialise(), G4OpenInventorWinViewer::Initialise(), G4OpenInventorXtExtendedViewer::Initialise(), G4OpenInventorXtViewer::Initialise(), G4RayTracerViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VtkViewer::Initialise(), and G4OpenGLViewer::InitializeGLView().

◆ GetWindowSizeHintY()

unsigned int G4ViewParameters::GetWindowSizeHintY ( ) const

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLXmViewer::GetXmConnection(), G4OpenInventorQtViewer::Initialise(), G4OpenInventorWinViewer::Initialise(), G4RayTracerViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VtkViewer::Initialise(), and G4OpenGLViewer::InitializeGLView().

◆ GetXGeometryString()

const G4String & G4ViewParameters::GetXGeometryString ( ) const

Referenced by G4RTXScanner::GetXWindow(), G4OpenInventorXtExtendedViewer::Initialise(), G4OpenInventorXtViewer::Initialise(), and G4VisCommandViewerClone::SetNewValue().

◆ GetZoomFactor()

G4double G4ViewParameters::GetZoomFactor ( ) const

Referenced by G4OpenGLXmViewer::actions_callback(), G4VVisCommand::CopyCameraParameters(), G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4wheelEvent(), G4OpenGLXmViewer::ResetView(), G4DAWNFILEViewer::SendViewParameters(), G4OpenGLXmViewerMessenger::SetNewValue(), G4VisCommandViewerZoom::SetNewValue(), G4VtkViewer::SetView(), G4OpenGLXmViewer::update_panels_callback(), and G4OpenGLXmViewer::UpdateControlPanel().

◆ IncrementDolly()

void G4ViewParameters::IncrementDolly ( G4double dollyIncrement )

Referenced by G4VisCommandViewerDolly::SetNewValue().

◆ IncrementPan() [1/2]

void G4ViewParameters::IncrementPan	(	G4double	right,
		G4double	up
	)

Definition at line 288 of file G4ViewParameters.cc.

                                                                {
  IncrementPan (right,up, 0);
}

References IncrementPan().

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), IncrementPan(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4OpenGLQtViewer::moveScene(), G4VisCommandViewerPan::SetNewValue(), and G4OpenGLWin32Viewer::SetShift().

◆ IncrementPan() [2/2]

void G4ViewParameters::IncrementPan	(	G4double	right,
		G4double	up,
		G4double	forward
	)

Definition at line 292 of file G4ViewParameters.cc.

                                                                                   {
  G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
  G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
  fCurrentTargetPoint += right * unitRight + up * unitUp + distance * fViewpointDirection;
}

References HepGeom::BasicVector3D< T >::cross(), fCurrentTargetPoint, fUpVector, and fViewpointDirection.

◆ IsAutoRefresh()

G4bool G4ViewParameters::IsAutoRefresh ( ) const

Referenced by G4OpenGLQtViewer::changeDepthInSceneTree(), G4VVisCommand::CopyMostViewParameters(), G4VisManager::EndOfRun(), G4VVisCommand::RefreshIfRequired(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandDrawView::SetNewValue(), G4VisCommandDrawLogicalVolume::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ IsAuxEdgeVisible()

G4bool G4ViewParameters::IsAuxEdgeVisible ( ) const

Referenced by G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4VSceneHandler::GetAuxEdgeVisible(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ IsCulling()

G4bool G4ViewParameters::IsCulling ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VisManager::CreateViewer(), G4VisCommandGeometrySetDaughtersInvisible::SetNewValue(), G4VisCommandGeometrySetVisibility::SetNewValue(), and G4VisCommandGeometrySetVisibility::SetNewValueOnLV().

◆ IsCullingCovered()

G4bool G4ViewParameters::IsCullingCovered ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisManager::CreateViewer().

◆ IsCullingInvisible()

G4bool G4ViewParameters::IsCullingInvisible ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VisManager::CreateViewer(), G4VisCommandGeometrySetVisibility::SetNewValue(), and G4VisCommandGeometrySetVisibility::SetNewValueOnLV().

◆ IsCutaway()

G4bool G4ViewParameters::IsCutaway ( ) const

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4OpenGLStoredQtViewer::ComputeView(), G4VSceneHandler::CreateModelingParameters(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), operator!=(), PrintDifferences(), G4OpenGLImmediateViewer::ProcessView(), and G4OpenGLViewer::SetView().

◆ IsDensityCulling()

G4bool G4ViewParameters::IsDensityCulling ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ IsDisplayHeadTime()

G4bool G4ViewParameters::IsDisplayHeadTime ( ) const

◆ IsDisplayLightFront()

G4bool G4ViewParameters::IsDisplayLightFront ( ) const

◆ IsExplode()

G4bool G4ViewParameters::IsExplode ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), operator!=(), and PrintDifferences().

◆ IsMarkerNotHidden()

G4bool G4ViewParameters::IsMarkerNotHidden ( ) const

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLStoredViewer::DrawDisplayLists(), G4VisCommandDrawLogicalVolume::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ IsPicking()

G4bool G4ViewParameters::IsPicking ( ) const

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLQtViewer::G4MouseReleaseEvent(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLXViewer::ShowView(), G4OpenGLQtViewer::togglePicking(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ IsSection()

G4bool G4ViewParameters::IsSection ( ) const

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::CreateSectionSolid(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ IsSpecialMeshRendering()

G4bool G4ViewParameters::IsSpecialMeshRendering ( ) const

Referenced by G4OpenGLStoredQtViewer::CompareForKernelVisit(), G4OpenGLStoredViewer::CompareForKernelVisit(), G4OpenInventorViewer::CompareForKernelVisit(), G4Qt3DViewer::CompareForKernelVisit(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ IsWindowLocationHintX()

bool G4ViewParameters::IsWindowLocationHintX ( ) const

Referenced by G4OpenGLXmViewer::CreateMainWindow(), and G4OpenGLXViewer::CreateMainWindow().

◆ IsWindowLocationHintY()

bool G4ViewParameters::IsWindowLocationHintY ( ) const

Referenced by G4OpenGLXmViewer::CreateMainWindow(), and G4OpenGLXViewer::CreateMainWindow().

◆ IsWindowSizeHintX()

bool G4ViewParameters::IsWindowSizeHintX ( ) const

Referenced by G4OpenGLXmViewer::CreateMainWindow(), and G4OpenGLXViewer::CreateMainWindow().

◆ IsWindowSizeHintY()

bool G4ViewParameters::IsWindowSizeHintY ( ) const

◆ MultiplyScaleFactor()

void G4ViewParameters::MultiplyScaleFactor ( const G4Vector3D & scaleFactorMultiplier )

Definition at line 121 of file G4ViewParameters.cc.

                                          {
  fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
  fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
  fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
}

References fScaleFactor, HepGeom::BasicVector3D< T >::setX(), HepGeom::BasicVector3D< T >::setY(), HepGeom::BasicVector3D< T >::setZ(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4VisCommandViewerScale::SetNewValue().

◆ MultiplyZoomFactor()

void G4ViewParameters::MultiplyZoomFactor ( G4double zoomFactorMultiplier )

Referenced by G4VisCommandViewerZoom::SetNewValue(), G4OpenGLWin32Viewer::SetZoom(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate(), and G4Qt3DViewer::wheelEvent().

◆ operator!=()

G4bool G4ViewParameters::operator!= ( const G4ViewParameters & v ) const

Definition at line 1082 of file G4ViewParameters.cc.

                                                                     {
 
  // Put performance-sensitive parameters first.
  if (
      // This first to optimise spin, etc.
      (fViewpointDirection   != v.fViewpointDirection)   ||
 
      // No particular order from here on.
      (fDrawingStyle         != v.fDrawingStyle)         ||
      (fNumberOfCloudPoints  != v.fNumberOfCloudPoints)  ||
      (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
      (fCulling              != v.fCulling)              ||
      (fCullInvisible        != v.fCullInvisible)        ||
      (fDensityCulling       != v.fDensityCulling)       ||
      (fCullCovered          != v.fCullCovered)          ||
      (fCBDAlgorithmNumber   != v.fCBDAlgorithmNumber)   ||
      (fSection              != v.fSection)              ||
      (IsCutaway()           != v.IsCutaway())           ||
      (IsExplode()           != v.IsExplode())           ||
      (fNoOfSides            != v.fNoOfSides)            ||
      (fUpVector             != v.fUpVector)             ||
      (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
      (fZoomFactor           != v.fZoomFactor)           ||
      (fScaleFactor          != v.fScaleFactor)          ||
      (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
      (fDolly                != v.fDolly)                ||
      (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
      (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
      (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
      (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
      (fDefaultMarker        != v.fDefaultMarker)        ||
      (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
      (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
      (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
      (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
      (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
      (fXGeometryString      != v.fXGeometryString)      ||
      (fGeometryMask         != v.fGeometryMask)         ||
      (fAutoRefresh          != v.fAutoRefresh)          ||
      (fBackgroundColour     != v.fBackgroundColour)     ||
      (fPicking              != v.fPicking)              ||
      (fRotationStyle        != v.fRotationStyle)        ||
      (fSpecialMeshRendering != v.fSpecialMeshRendering)
      )
    return true;
 
  if (fDensityCulling &&
      (fVisibleDensity != v.fVisibleDensity)) return true;
 
  if (fCBDAlgorithmNumber > 0) {
    if (fCBDParameters.size() != v.fCBDParameters.size()) return true;
    else if (fCBDParameters != v.fCBDParameters) return true;
  }
 
  if (fSection &&
      (!(fSectionPlane == v.fSectionPlane))) return true;
 
  if (IsCutaway()) {
    if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
      return true;
    else {
      for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
    if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
      }
    }
  }
 
  if (IsExplode() &&
      ((fExplodeFactor != v.fExplodeFactor) ||
       (fExplodeCentre != v.fExplodeCentre))) return true;
 
  if (fVisAttributesModifiers != v.fVisAttributesModifiers) return true;
 
  if (fStartTime  != v.fStartTime ||
      fEndTime    != v.fEndTime   ||
      fFadeFactor != v.fFadeFactor) return true;
 
  if (fDisplayHeadTime != v.fDisplayHeadTime) return true;
  if (fDisplayHeadTime) {
    if (fDisplayHeadTimeX     != v.fDisplayHeadTimeX     ||
        fDisplayHeadTimeY     != v.fDisplayHeadTimeY     ||
        fDisplayHeadTimeSize  != v.fDisplayHeadTimeSize  ||
        fDisplayHeadTimeRed   != v.fDisplayHeadTimeRed   ||
        fDisplayHeadTimeGreen != v.fDisplayHeadTimeGreen ||
        fDisplayHeadTimeBlue  != v.fDisplayHeadTimeBlue) {
      return true;
    }
  }
 
  if (fDisplayLightFront != v.fDisplayLightFront) return true;
  if (fDisplayLightFront) {
    if (fDisplayLightFrontX     != v.fDisplayLightFrontX     ||
        fDisplayLightFrontY     != v.fDisplayLightFrontY     ||
        fDisplayLightFrontZ     != v.fDisplayLightFrontZ     ||
        fDisplayLightFrontT     != v.fDisplayLightFrontT     ||
        fDisplayLightFrontRed   != v.fDisplayLightFrontRed   ||
        fDisplayLightFrontGreen != v.fDisplayLightFrontGreen ||
        fDisplayLightFrontBlue  != v.fDisplayLightFrontBlue) {
      return true;
    }
  }
 
  if (fSpecialMeshRendering) {
    if (fSpecialMeshVolumes != v.fSpecialMeshVolumes)
      return true;;
  }
 
  return false;
}

◆ ParseGeometry()

int G4ViewParameters::ParseGeometry	(	const char *	string,
		G4int *	x,
		G4int *	y,
		unsigned int *	width,
		unsigned int *	height
	)

private

Definition at line 1303 of file G4ViewParameters.cc.

{
 
  G4int mask = fNoValue;
  char *strind;
  unsigned int tempWidth  = 0;
  unsigned int tempHeight = 0;
  G4int tempX = 0;
  G4int tempY = 0;
  char *nextCharacter;
  if ( (string == NULL) || (*string == '\0')) {
    return(mask);
  }
  if (*string == '=')
    string++;  /* ignore possible '=' at beg of geometry spec */
  strind = (char *)string;
  if (*strind != '+' && *strind != '-' && *strind != 'x') {
    tempWidth = ReadInteger(strind, &nextCharacter);
    if (strind == nextCharacter)
      return (0);
    strind = nextCharacter;
    mask |= fWidthValue;
  }
  if (*strind == 'x' || *strind == 'X') {
    strind++;
    tempHeight = ReadInteger(strind, &nextCharacter);
    if (strind == nextCharacter)
      return (0);
    strind = nextCharacter;
    mask |= fHeightValue;
  }
 
  if ((*strind == '+') || (*strind == '-')) {
    if (*strind == '-') {
      strind++;
      tempX = -ReadInteger(strind, &nextCharacter);
      if (strind == nextCharacter)
        return (0);
      strind = nextCharacter;
      mask |= fXNegative;
 
    }
    else
      { strind++;
        tempX = ReadInteger(strind, &nextCharacter);
        if (strind == nextCharacter)
          return(0);
        strind = nextCharacter;
      }
    mask |= fXValue;
    if ((*strind == '+') || (*strind == '-')) {
      if (*strind == '-') {
        strind++;
        tempY = -ReadInteger(strind, &nextCharacter);
        if (strind == nextCharacter)
          return(0);
        strind = nextCharacter;
        mask |= fYNegative;
      }
      else
        {
          strind++;
          tempY = ReadInteger(strind, &nextCharacter);
          if (strind == nextCharacter)
            return(0);
          strind = nextCharacter;
        }
      mask |= fYValue;
    }
  }
  /* If strind isn't at the end of the string the it's an invalid
     geometry specification. */
  if (*strind != '\0') return (0);
  if (mask & fXValue)
    *x = tempX;
  if (mask & fYValue)
    *y = tempY;
  if (mask & fWidthValue)
    *width = tempWidth;
  if (mask & fHeightValue)
    *height = tempHeight;
  return (mask);
}

References fHeightValue, fNoValue, fWidthValue, fXNegative, fXValue, fYNegative, fYValue, and ReadInteger().

Referenced by SetXGeometryString().

◆ PrintDifferences()

void G4ViewParameters::PrintDifferences ( const G4ViewParameters & v ) const

Definition at line 753 of file G4ViewParameters.cc.

                                                                        {
 
  // Put performance-sensitive parameters first.
  if (
      // This first to optimise spin, etc.
      (fViewpointDirection   != v.fViewpointDirection)   ||
 
      // No particular order from here on.
      (fDrawingStyle         != v.fDrawingStyle)         ||
      (fNumberOfCloudPoints  != v.fNumberOfCloudPoints)  ||
      (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
      (fCulling              != v.fCulling)              ||
      (fCullInvisible        != v.fCullInvisible)        ||
      (fDensityCulling       != v.fDensityCulling)       ||
      (fVisibleDensity       != v.fVisibleDensity)       ||
      (fCullCovered          != v.fCullCovered)          ||
      (fCBDAlgorithmNumber   != v.fCBDAlgorithmNumber)   ||
      (fSection              != v.fSection)              ||
      (fNoOfSides            != v.fNoOfSides)            ||
      (fUpVector             != v.fUpVector)             ||
      (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
      (fZoomFactor           != v.fZoomFactor)           ||
      (fScaleFactor          != v.fScaleFactor)          ||
      (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
      (fDolly                != v.fDolly)                ||
      (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
      (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
      (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
      (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
      (fDefaultMarker        != v.fDefaultMarker)        ||
      (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
      (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
      (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
      (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
      (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
      (fXGeometryString      != v.fXGeometryString)      ||
      (fGeometryMask         != v.fGeometryMask)         ||
      (fAutoRefresh          != v.fAutoRefresh)          ||
      (fBackgroundColour     != v.fBackgroundColour)     || 
      (fPicking              != v.fPicking)              ||
      (fRotationStyle        != v.fRotationStyle)
      )
    G4cout << "Difference in 1st batch." << G4endl;
 
  if (fCBDAlgorithmNumber > 0) {
    if (fCBDParameters.size() != v.fCBDParameters.size()) {
      G4cout << "Difference in number of colour by density parameters." << G4endl;
    } else if (fCBDParameters != v.fCBDParameters) {
      G4cout << "Difference in values of colour by density parameters." << G4endl;
    }
  }
 
  if (fSection) {
    if (!(fSectionPlane == v.fSectionPlane))
      G4cout << "Difference in section planes batch." << G4endl;
  }
 
  if (IsCutaway()) {
    if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
      G4cout << "Difference in no of cutaway planes." << G4endl;
    }
    else {
      for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
    if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
      G4cout << "Difference in cutaway plane no. " << i << G4endl;
      }
    }
  }
 
  if (IsExplode()) {
    if (fExplodeFactor != v.fExplodeFactor)
      G4cout << "Difference in explode factor." << G4endl;
    if (fExplodeCentre != v.fExplodeCentre)
      G4cout << "Difference in explode centre." << G4endl;
  }
 
  if (fVisAttributesModifiers != v.fVisAttributesModifiers) {
    G4cout << "Difference in vis attributes modifiers." << G4endl;
  }
 
  if (fStartTime != v.fStartTime ||
      fEndTime   != v.fEndTime)  {
    G4cout << "Difference in time window." << G4endl;
  }
 
  if (fFadeFactor != v.fFadeFactor) {
    G4cout << "Difference in time window fade factor." << G4endl;
  }
 
  if (fDisplayHeadTime != v.fDisplayHeadTime) {
    G4cout << "Difference in display head time flag." << G4endl;
  } else {
    if (fDisplayHeadTimeX     != v.fDisplayHeadTimeX     ||
        fDisplayHeadTimeY     != v.fDisplayHeadTimeY     ||
        fDisplayHeadTimeSize  != v.fDisplayHeadTimeSize  ||
        fDisplayHeadTimeRed   != v.fDisplayHeadTimeRed   ||
        fDisplayHeadTimeGreen != v.fDisplayHeadTimeGreen ||
        fDisplayHeadTimeBlue  != v.fDisplayHeadTimeBlue) {
      G4cout << "Difference in display head time parameters." << G4endl;
    }
  }
 
  if (fDisplayLightFront != v.fDisplayLightFront) {
    G4cout << "Difference in display light front flag." << G4endl;
  } else {
    if (fDisplayLightFrontX     != v.fDisplayLightFrontX     ||
        fDisplayLightFrontY     != v.fDisplayLightFrontY     ||
        fDisplayLightFrontZ     != v.fDisplayLightFrontZ     ||
        fDisplayLightFrontT     != v.fDisplayLightFrontT     ||
        fDisplayLightFrontRed   != v.fDisplayLightFrontRed   ||
        fDisplayLightFrontGreen != v.fDisplayLightFrontGreen ||
        fDisplayLightFrontBlue  != v.fDisplayLightFrontBlue) {
      G4cout << "Difference in display light front parameters." << G4endl;
    }
  }
}

◆ ReadInteger()

G4int G4ViewParameters::ReadInteger	(	char *	string,
		char **	NextString
	)

private

Definition at line 1396 of file G4ViewParameters.cc.

{
    G4int Result = 0;
    G4int Sign = 1;
 
    if (*string == '+')
    string++;
    else if (*string == '-')
    {
    string++;
    Sign = -1;
    }
    for (; (*string >= '0') && (*string <= '9'); string++)
    {
    Result = (Result * 10) + (*string - '0');
    }
    *NextString = string;
    if (Sign >= 0)
    return (Result);
    else
    return (-Result);
}

Referenced by ParseGeometry().

◆ SceneModifyingCommands()

G4String G4ViewParameters::SceneModifyingCommands ( ) const

Definition at line 472 of file G4ViewParameters.cc.

{
  std::ostringstream oss;
  
  oss << "#\n# Scene-modifying commands";
  
  oss << "\n/vis/viewer/set/culling global ";
  if (fCulling) {
    oss << "true";
  } else {
    oss << "false";
  }
 
  oss << "\n/vis/viewer/set/culling invisible ";
  if (fCullInvisible) {
    oss << "true";
  } else {
    oss << "false";
  }
  
  oss << "\n/vis/viewer/set/culling density ";
  if (fDensityCulling) {
    oss << "true " << fVisibleDensity/(g/cm3) << " g/cm3";
  } else {
    oss << "false";
  }
  
  oss << "\n/vis/viewer/set/culling coveredDaughters ";
  if (fCullCovered) {
    oss << "true";
  } else {
    oss << "false";
  }
 
  oss << "\n/vis/viewer/colourByDensity "
  << fCBDAlgorithmNumber << " g/cm3";
  for (auto p: fCBDParameters) {
    oss << ' ' << p/(g/cm3);
  }
 
  oss << "\n/vis/viewer/set/sectionPlane ";
  if (fSection) {
    oss << "on "
    << G4BestUnit(fSectionPlane.point(),"Length")
    << fSectionPlane.normal().x()
    << ' ' << fSectionPlane.normal().y()
    << ' ' << fSectionPlane.normal().z();
  } else {
    oss << "off";
  }
  
  oss << "\n/vis/viewer/set/cutawayMode ";
  if (fCutawayMode == cutawayUnion) {
    oss << "union";
  } else {
    oss << "intersection";
  }
  
  oss << "\n/vis/viewer/clearCutawayPlanes";
  if (fCutawayPlanes.size()) {
    for (size_t i = 0; i < fCutawayPlanes.size(); i++) {
      oss << "\n/vis/viewer/addCutawayPlane "
      << G4BestUnit(fCutawayPlanes[i].point(),"Length")
      << fCutawayPlanes[i].normal().x()
      << ' ' << fCutawayPlanes[i].normal().y()
      << ' ' << fCutawayPlanes[i].normal().z();
    }
  } else {
    oss << "\n# No cutaway planes defined.";
  }
  
  oss << "\n/vis/viewer/set/explodeFactor "
  << fExplodeFactor
  << ' ' << G4BestUnit(fExplodeCentre,"Length");
  
  oss << "\n/vis/viewer/set/lineSegmentsPerCircle "
  << fNoOfSides;
  
  oss << std::endl;
  
  return oss.str();
}

References cm3, cutawayUnion, fCBDAlgorithmNumber, fCBDParameters, fCullCovered, fCulling, fCullInvisible, fCutawayMode, fCutawayPlanes, fDensityCulling, fExplodeCentre, fExplodeFactor, fNoOfSides, fSection, fSectionPlane, fVisibleDensity, g, G4BestUnit, HepGeom::Plane3D< T >::normal(), and HepGeom::Plane3D< T >::point().

Referenced by anonymous_namespace{G4VisCommandsViewer.cc}::WriteCommands().

◆ SetAutoRefresh()

void G4ViewParameters::SetAutoRefresh ( G4bool )

Referenced by G4OpenGLQtViewer::changeDepthInSceneTree(), G4VVisCommand::CopyMostViewParameters(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenInventorViewer::G4OpenInventorViewer(), G4VtkViewer::G4VtkViewer(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VisCommandDrawView::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetAuxEdgeVisible()

void G4ViewParameters::SetAuxEdgeVisible ( G4bool )

Referenced by G4OpenGLXmViewer::aux_edge_callback(), G4VisCommandsViewerSet::SetNewValue(), G4OpenInventorViewer::SetReducedWireFrame(), and G4OpenGLQtViewer::toggleAux().

◆ SetBackgroundColour()

void G4ViewParameters::SetBackgroundColour ( const G4Colour & )

Referenced by G4OpenGLQtViewer::actionChangeBackgroundColor(), G4VVisCommand::CopyMostViewParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetCBDAlgorithmNumber()

void G4ViewParameters::SetCBDAlgorithmNumber ( G4int )

Referenced by G4VisCommandViewerColourByDensity::SetNewValue().

◆ SetCBDParameters()

void G4ViewParameters::SetCBDParameters ( const std::vector< G4double > & )

Referenced by G4VisCommandViewerColourByDensity::SetNewValue().

◆ SetCulling()

void G4ViewParameters::SetCulling ( G4bool )

Referenced by G4ASCIITreeViewer::G4ASCIITreeViewer(), G4HepRepFileViewer::G4HepRepFileViewer(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetCullingCovered()

void G4ViewParameters::SetCullingCovered ( G4bool )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetCullingInvisible()

void G4ViewParameters::SetCullingInvisible ( G4bool )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetCurrentTargetPoint()

void G4ViewParameters::SetCurrentTargetPoint ( const G4Point3D & currentTargetPoint )

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenInventorViewer::GroupCameraSensorCB(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLXmViewer::reset_callback(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLXmViewer::up_down_pan_callback().

◆ SetCutawayMode()

void G4ViewParameters::SetCutawayMode ( CutawayMode )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDefaultColour()

void G4ViewParameters::SetDefaultColour ( const G4Colour & )

Referenced by G4OpenGLQtViewer::actionChangeDefaultColor().

◆ SetDefaultMarker()

void G4ViewParameters::SetDefaultMarker ( const G4VMarker & defaultMarker )

◆ SetDefaultTextColour()

void G4ViewParameters::SetDefaultTextColour ( const G4Colour & )

Referenced by G4OpenGLQtViewer::actionChangeTextColor().

◆ SetDefaultTextVisAttributes()

void G4ViewParameters::SetDefaultTextVisAttributes ( const G4VisAttributes & )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDefaultVisAttributes()

void G4ViewParameters::SetDefaultVisAttributes ( const G4VisAttributes & )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDensityCulling()

void G4ViewParameters::SetDensityCulling ( G4bool )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTime()

void G4ViewParameters::SetDisplayHeadTime ( G4bool )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTimeBlue()

void G4ViewParameters::SetDisplayHeadTimeBlue ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTimeGreen()

void G4ViewParameters::SetDisplayHeadTimeGreen ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTimeRed()

void G4ViewParameters::SetDisplayHeadTimeRed ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTimeSize()

void G4ViewParameters::SetDisplayHeadTimeSize ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTimeX()

void G4ViewParameters::SetDisplayHeadTimeX ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayHeadTimeY()

void G4ViewParameters::SetDisplayHeadTimeY ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFront()

void G4ViewParameters::SetDisplayLightFront ( G4bool )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontBlue()

void G4ViewParameters::SetDisplayLightFrontBlue ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontGreen()

void G4ViewParameters::SetDisplayLightFrontGreen ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontRed()

void G4ViewParameters::SetDisplayLightFrontRed ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontT()

void G4ViewParameters::SetDisplayLightFrontT ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontX()

void G4ViewParameters::SetDisplayLightFrontX ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontY()

void G4ViewParameters::SetDisplayLightFrontY ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDisplayLightFrontZ()

void G4ViewParameters::SetDisplayLightFrontZ ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetDolly()

void G4ViewParameters::SetDolly ( G4double dolly )

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenGLXmViewer::dolly_callback(), G4OpenGLXmViewer::reset_callback(), G4OpenGLXmViewerMessenger::SetNewValue(), G4VisCommandViewerDolly::SetNewValue(), G4OpenGLWin32Viewer::SetZoom(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate(), and G4Qt3DViewer::wheelEvent().

◆ SetDrawingStyle()

void G4ViewParameters::SetDrawingStyle ( G4ViewParameters::DrawingStyle style )

Referenced by G4OpenGLXmViewer::drawing_style_callback(), G4VisCommandViewerDefaultHiddenEdge::SetNewValue(), G4VisCommandViewerDefaultStyle::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenInventorViewer::SetReducedWireFrame(), G4OpenInventorViewer::SetSolid(), G4OpenInventorViewer::SetWireFrame(), and G4OpenGLQtViewer::toggleSurfaceAction().

◆ SetEndTime()

void G4ViewParameters::SetEndTime ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetExplodeCentre()

void G4ViewParameters::SetExplodeCentre ( const G4Point3D & explodeCentre )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetExplodeFactor()

void G4ViewParameters::SetExplodeFactor ( G4double explodeFactor )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetFadeFactor()

void G4ViewParameters::SetFadeFactor ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetFieldHalfAngle()

void G4ViewParameters::SetFieldHalfAngle ( G4double fieldHalfAngle )

Referenced by G4VVisCommand::CopyCameraParameters(), G4RayTracerViewer::DrawView(), G4OpenGLXmViewer::projection_callback(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetGlobalLineWidthScale()

void G4ViewParameters::SetGlobalLineWidthScale ( G4double globalLineWidthScale )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetGlobalMarkerScale()

void G4ViewParameters::SetGlobalMarkerScale ( G4double globalMarkerScale )

Referenced by G4VisCommandsViewerSet::SetNewValue(), and G4ToolsSGQtViewer::SetView().

◆ SetLightpointDirection()

void G4ViewParameters::SetLightpointDirection ( const G4Vector3D & lightpointDirection )

Definition at line 276 of file G4ViewParameters.cc.

                                        {
  fRelativeLightpointDirection = lightpointDirection;
  SetViewAndLights (fViewpointDirection);
}

References fRelativeLightpointDirection, fViewpointDirection, and SetViewAndLights().

Referenced by G4VVisCommand::CopyCameraParameters(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetLightsMoveWithCamera()

void G4ViewParameters::SetLightsMoveWithCamera ( G4bool moves )

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenGLXmViewer::set_rot_subject_callback(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetMarkerHidden()

void G4ViewParameters::SetMarkerHidden ( )

Referenced by G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::toggleHiddenMarkers().

◆ SetMarkerNotHidden()

void G4ViewParameters::SetMarkerNotHidden ( )

Referenced by G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLQtViewer::toggleHiddenMarkers().

◆ SetNoOfSides()

G4int G4ViewParameters::SetNoOfSides ( G4int nSides )

Definition at line 220 of file G4ViewParameters.cc.

                                                  {
  const G4int nSidesMin = fDefaultVisAttributes.GetMinLineSegmentsPerCircle();
  if (nSides < nSidesMin) {
    nSides = nSidesMin;
    G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
    "\nnumber of sides per circle < " << nSidesMin
    << "; forced to " << nSides << G4endl;
  }
  fNoOfSides = nSides;
  return fNoOfSides;
}

References fDefaultVisAttributes, fNoOfSides, G4cout, G4endl, and G4VisAttributes::GetMinLineSegmentsPerCircle().

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetNumberOfCloudPoints()

G4int G4ViewParameters::SetNumberOfCloudPoints ( G4int nPoints )

Definition at line 232 of file G4ViewParameters.cc.

                                                            {
  const G4int nPointsMin = 100;
  if (nPoints < nPointsMin) {
    nPoints = nPointsMin;
    G4cout << "G4ViewParameters::SetNumberOfCloudPoints:"
    "\nnumber of points per cloud set to minimum " << nPoints
    << G4endl;
  }
  fNumberOfCloudPoints = nPoints;
  return fNumberOfCloudPoints;
}

References fNumberOfCloudPoints, G4cout, and G4endl.

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetOrthogonalProjection()

void G4ViewParameters::SetOrthogonalProjection ( )

Referenced by G4OpenGLQtViewer::toggleProjection().

◆ SetPan()

void G4ViewParameters::SetPan	(	G4double	right,
		G4double	up
	)

Definition at line 282 of file G4ViewParameters.cc.

                                                          {
  G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
  G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
  fCurrentTargetPoint  = right * unitRight + up * unitUp;
}

References HepGeom::BasicVector3D< T >::cross(), fCurrentTargetPoint, fUpVector, and fViewpointDirection.

Referenced by G4VisCommandViewerPan::SetNewValue().

◆ SetPerspectiveProjection()

void G4ViewParameters::SetPerspectiveProjection ( G4double fieldHalfAngle = 30. *CLHEP::deg )

Referenced by G4OpenGLQtViewer::toggleProjection().

◆ SetPicking()

void G4ViewParameters::SetPicking ( G4bool )

Referenced by G4OpenInventorViewer::G4OpenInventorViewer(), and G4VisCommandsViewerSet::SetNewValue().

◆ SetRotationStyle()

void G4ViewParameters::SetRotationStyle ( RotationStyle )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetScaleFactor()

void G4ViewParameters::SetScaleFactor ( const G4Vector3D & scaleFactor )

Referenced by G4VVisCommand::CopyCameraParameters(), and G4VisCommandViewerScale::SetNewValue().

◆ SetSectionPlane()

void G4ViewParameters::SetSectionPlane ( const G4Plane3D & sectionPlane )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetSpecialMeshRendering()

void G4ViewParameters::SetSpecialMeshRendering ( G4bool )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetSpecialMeshVolumes()

void G4ViewParameters::SetSpecialMeshVolumes ( const std::vector< G4ModelingParameters::PVNameCopyNo > & )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetStartTime()

void G4ViewParameters::SetStartTime ( G4double )

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetUpVector()

void G4ViewParameters::SetUpVector ( const G4Vector3D & upVector )

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenInventorViewer::GroupCameraSensorCB(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLWin32Viewer::SetRotation().

◆ SetViewAndLights()

void G4ViewParameters::SetViewAndLights ( const G4Vector3D & viewpointDirection )

Definition at line 244 of file G4ViewParameters.cc.

                                       {
 
  fViewpointDirection = viewpointDirection;
 
  // If the requested viewpoint direction is parallel to the up
  // vector, the orientation of the view is undefined...
  if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
    static G4bool firstTime = true;
    if (firstTime) {
      firstTime = false;
      G4cout <<
      "WARNING: Viewpoint direction is very close to the up vector direction."
      "\n  Change the up vector or \"/vis/viewer/set/rotationStyle freeRotation\"."
      << G4endl;
    }
  }
 
  // Move the lights too if requested...
  if (fLightsMoveWithCamera) {
    G4Vector3D zprime = fViewpointDirection.unit ();
    G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
    G4Vector3D yprime = zprime.cross (xprime);
    fActualLightpointDirection =
      fRelativeLightpointDirection.x () * xprime +
      fRelativeLightpointDirection.y () * yprime +
      fRelativeLightpointDirection.x () * zprime;     
  } else {
    fActualLightpointDirection = fRelativeLightpointDirection;
  }
}

References HepGeom::BasicVector3D< T >::cross(), fActualLightpointDirection, fLightsMoveWithCamera, fRelativeLightpointDirection, fUpVector, fViewpointDirection, G4cout, G4endl, HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), and HepGeom::BasicVector3D< T >::y().

Referenced by GetActualLightpointDirection(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), SetLightpointDirection(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLXmViewer::wobble_timer_callback().

◆ SetViewpointDirection()

void G4ViewParameters::SetViewpointDirection ( const G4Vector3D & viewpointDirection )

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenInventorViewer::GroupCameraSensorCB(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4Qt3DViewer::mouseMoveEvent(), G4VisCommandsViewerSet::SetNewValue(), and G4OpenGLWin32Viewer::SetRotation().

◆ SetVisibleDensity()

void G4ViewParameters::SetVisibleDensity ( G4double visibleDensity )

Definition at line 203 of file G4ViewParameters.cc.

                                                                 {
  const G4double reasonableMaximum = 10.0 * g / cm3;
  if (visibleDensity < 0) {
    G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
      "density - ignored." << G4endl;
  }
  else {
    if (visibleDensity > reasonableMaximum) {
      G4cout << "G4ViewParameters::SetVisibleDensity: density > "
         << G4BestUnit (reasonableMaximum, "Volumic Mass")
         << " - did you mean this?"
         << G4endl;
    }
    fVisibleDensity = visibleDensity;
  }
}

References cm3, fVisibleDensity, g, G4BestUnit, G4cout, and G4endl.

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ SetWindowLocationHint()

void G4ViewParameters::SetWindowLocationHint	(	G4int	xHint,
		G4int	yHint
	)

◆ SetWindowSizeHint()

void G4ViewParameters::SetWindowSizeHint	(	G4int	xHint,
		G4int	yHint
	)

◆ SetXGeometryString()

void G4ViewParameters::SetXGeometryString ( const G4String & geomStringArg )

Definition at line 1192 of file G4ViewParameters.cc.

{
  G4int x = 0, y = 0;
  unsigned int w = 0, h = 0;
  G4String geomString = geomStringArg;
  // Parse windowSizeHintString for backwards compatibility...
  const G4String delimiters("xX+-");
  G4String::size_type i = geomString.find_first_of(delimiters);
  if (i == G4String::npos) {  // Does not contain "xX+-".  Assume single number
    std::istringstream iss(geomString);
    G4int size;
    iss >> size;
    if (!iss) {
      size = 600;
      G4cout << "Unrecognised windowSizeHint string: \""
         << geomString
         << "\".  Asuuming " << size << G4endl;
    }
    std::ostringstream oss;
    oss << size << 'x' << size;
    geomString = oss.str();
  }
 
  fGeometryMask = ParseGeometry( geomString, &x, &y, &w, &h );
 
  // Handle special case :
  if ((fGeometryMask & fYValue) == 0)
    {  // Using default
      y =  fWindowLocationHintY;
    }
  if ((fGeometryMask & fXValue) == 0)
    {  // Using default
      x =  fWindowLocationHintX;
    }
 
  // Check errors
  // if there is no Width and Height
  if ( ((fGeometryMask & fHeightValue) == 0 ) &&
       ((fGeometryMask & fWidthValue)  == 0 )) {
    h = fWindowSizeHintY;
    w = fWindowSizeHintX;
  } else  if ((fGeometryMask & fHeightValue) == 0 ) {
 
    // if there is only Width. Special case to be backward compatible
    // We set Width and Height the same to obtain a square windows.
    
    G4cout << "Unrecognised geometry string \""
           << geomString
           << "\".  No Height found. Using Width value instead"
           << G4endl;
    h = w;
  }
  if ( ((fGeometryMask & fXValue) == 0 ) ||
       ((fGeometryMask & fYValue)  == 0 )) {
    //Using defaults
    x = fWindowLocationHintX;
    y = fWindowLocationHintY;
  }
  // Set the string
  fXGeometryString = geomString;
  
  // Set values
  fWindowSizeHintX = w;
  fWindowSizeHintY = h;
  fWindowLocationHintX = x;
  fWindowLocationHintY = y;
 
  if ( ((fGeometryMask & fXValue)) &&
       ((fGeometryMask & fYValue))) {
 
    if ( (fGeometryMask & fXNegative) ) {
      fWindowLocationHintXNegative = true;
    } else {
      fWindowLocationHintXNegative = false;
    }
    if ( (fGeometryMask & fYNegative) ) {
    fWindowLocationHintYNegative = true;
    } else {
      fWindowLocationHintYNegative = false;
    }
  }
}

References fGeometryMask, fHeightValue, fWidthValue, fWindowLocationHintX, fWindowLocationHintXNegative, fWindowLocationHintY, fWindowLocationHintYNegative, fWindowSizeHintX, fWindowSizeHintY, fXGeometryString, fXNegative, fXValue, fYNegative, fYValue, G4cout, G4endl, and ParseGeometry().

Referenced by G4VisManager::CreateViewer().

◆ SetZoomFactor()

void G4ViewParameters::SetZoomFactor ( G4double zoomFactor )

Referenced by G4VVisCommand::CopyCameraParameters(), G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4wheelEvent(), G4OpenGLXmViewer::reset_callback(), G4OpenGLXmViewerMessenger::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerZoom::SetNewValue(), and G4OpenGLXmViewer::zoom_callback().

◆ TimeWindowCommands()

G4String G4ViewParameters::TimeWindowCommands ( ) const

Definition at line 698 of file G4ViewParameters.cc.

{
  std::ostringstream oss;
 
  oss <<  "#\n# Time window commands";
 
  oss
  << "\n/vis/viewer/set/timeWindow/startTime "
  << fStartTime/ns << " ns ";
 
  oss
  << "\n/vis/viewer/set/timeWindow/endTime "
  << fEndTime/ns << " ns ";
 
  oss << "\n/vis/viewer/set/timeWindow/fadeFactor "
  << fFadeFactor;
 
  oss
  << "\n/vis/viewer/set/timeWindow/displayHeadTime ";
  if (!fDisplayHeadTime) {
    oss << "false";
  } else {
    oss
    << "true"
    << ' ' << fDisplayHeadTimeX
    << ' ' << fDisplayHeadTimeY
    << ' ' << fDisplayHeadTimeSize
    << ' ' << fDisplayHeadTimeRed
    << ' ' << fDisplayHeadTimeGreen
    << ' ' << fDisplayHeadTimeBlue;
  }
 
  oss
  << "\n/vis/viewer/set/timeWindow/displayLightFront ";
  if (!fDisplayLightFront) {
    oss << "false";
  } else {
    oss
    << "true"
    << ' ' << fDisplayLightFrontX/mm
    << ' ' << fDisplayLightFrontY/mm
    << ' ' << fDisplayLightFrontZ/mm
    << " mm"
    << ' ' << fDisplayLightFrontT/ns
    << " ns"
    << ' ' << fDisplayLightFrontRed
    << ' ' << fDisplayLightFrontGreen
    << ' ' << fDisplayLightFrontBlue;
  }
 
  oss << std::endl;
 
  return oss.str();
}

References fDisplayHeadTime, fDisplayHeadTimeBlue, fDisplayHeadTimeGreen, fDisplayHeadTimeRed, fDisplayHeadTimeSize, fDisplayHeadTimeX, fDisplayHeadTimeY, fDisplayLightFront, fDisplayLightFrontBlue, fDisplayLightFrontGreen, fDisplayLightFrontRed, fDisplayLightFrontT, fDisplayLightFrontX, fDisplayLightFrontY, fDisplayLightFrontZ, fEndTime, fFadeFactor, fStartTime, mm, and ns.

Referenced by anonymous_namespace{G4VisCommandsViewer.cc}::WriteCommands().

◆ TouchableCommands()

G4String G4ViewParameters::TouchableCommands ( ) const

Definition at line 555 of file G4ViewParameters.cc.

{
  std::ostringstream oss;
  
  oss << "#\n# Touchable commands";
 
  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
    fVisAttributesModifiers;
 
  if (vams.empty()) {
    oss
    << "\n# None"
    << "\n/vis/viewer/clearVisAttributesModifiers";
    oss << std::endl;
    return oss.str();
  }
 
  oss
  << "\n/vis/viewer/clearVisAttributesModifiers";
 
  G4ModelingParameters::PVNameCopyNoPath lastPath;
  std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
    iModifier;
  for (iModifier = vams.begin();
       iModifier != vams.end();
       ++iModifier) {
    const G4ModelingParameters::PVNameCopyNoPath& vamPath =
      iModifier->GetPVNameCopyNoPath();
    if (vamPath != lastPath) {
      lastPath = vamPath;
      oss << "\n/vis/set/touchable";
      G4ModelingParameters::PVNameCopyNoPathConstIterator iVAM;
      for (iVAM = vamPath.begin();
           iVAM != vamPath.end();
           ++iVAM) {
        oss << ' ' << iVAM->GetName() << ' ' << iVAM->GetCopyNo();
      }
    }
    const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
    const G4Colour& c = vamVisAtts.GetColour();
    switch (iModifier->GetVisAttributesSignifier()) {
      case G4ModelingParameters::VASVisibility:
        oss << "\n/vis/touchable/set/visibility ";
        if (vamVisAtts.IsVisible()) {
          oss << "true";
        } else {
          oss << "false";
        }
        break;
      case G4ModelingParameters::VASDaughtersInvisible:
        oss << "\n/vis/touchable/set/daughtersInvisible ";
        if (vamVisAtts.IsDaughtersInvisible()) {
          oss << "true";
        } else {
          oss << "false";
        }
        break;
      case G4ModelingParameters::VASColour:
        oss << "\n/vis/touchable/set/colour "
        << c.GetRed()
        << ' ' << c.GetGreen()
        << ' ' << c.GetBlue()
        << ' ' << c.GetAlpha();
        break;
      case G4ModelingParameters::VASLineStyle:
        oss << "\n/vis/touchable/set/lineStyle ";
        switch (vamVisAtts.GetLineStyle()) {
          case G4VisAttributes::unbroken:
            oss << "unbroken";
            break;
          case G4VisAttributes::dashed:
            oss << "dashed";
            break;
          case G4VisAttributes::dotted:
          oss << "dotted";
        }
        break;
      case G4ModelingParameters::VASLineWidth:
        oss << "\n/vis/touchable/set/lineWidth "
        << vamVisAtts.GetLineWidth();
        break;
      case G4ModelingParameters::VASForceWireframe:
        if (vamVisAtts.IsForceDrawingStyle()) {
          if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
            oss << "\n/vis/touchable/set/forceWireframe ";
            if (vamVisAtts.IsForceDrawingStyle()) {
              oss << "true";
            } else {
              oss << "false";
            }
          }
        }
        break;
      case G4ModelingParameters::VASForceSolid:
        if (vamVisAtts.IsForceDrawingStyle()) {
          if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
            oss << "\n/vis/touchable/set/forceSolid ";
            if (vamVisAtts.IsForceDrawingStyle()) {
              oss << "true";
            } else {
              oss << "false";
            }
          }
        }
        break;
      case G4ModelingParameters::VASForceCloud:
        if (vamVisAtts.IsForceDrawingStyle()) {
          if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::cloud) {
            oss << "\n/vis/touchable/set/forceCloud ";
            if (vamVisAtts.IsForceDrawingStyle()) {
              oss << "true";
            } else {
              oss << "false";
            }
          }
        }
        break;
      case G4ModelingParameters::VASForceAuxEdgeVisible:
        if (vamVisAtts.IsForceAuxEdgeVisible()) {
          oss << "\n/vis/touchable/set/forceAuxEdgeVisible ";
          if (vamVisAtts.IsForcedAuxEdgeVisible()) {
            oss << "true";
          } else {
            oss << "false";
          }
        }
        break;
      case G4ModelingParameters::VASForceLineSegmentsPerCircle:
        oss << "\n/vis/touchable/set/lineSegmentsPerCircle "
        << vamVisAtts.GetForcedLineSegmentsPerCircle();
        break;
      case G4ModelingParameters::VASForceNumberOfCloudPoints:
        oss << "\n/vis/touchable/set/numberOfCloudPoints "
        << vamVisAtts.GetForcedNumberOfCloudPoints();
        break;
    }
  }
  
  oss << std::endl;
  
  return oss.str();
}

Referenced by anonymous_namespace{G4VisCommandsViewer.cc}::WriteCommands().

◆ UnsetExplodeFactor()

void G4ViewParameters::UnsetExplodeFactor ( )

◆ UnsetSectionPlane()

void G4ViewParameters::UnsetSectionPlane ( )

Referenced by G4VisCommandsViewerSet::SetNewValue().

Friends And Related Function Documentation

◆ operator<< [1/2]

std::ostream & operator<<	(	std::ostream &	os,
		const DrawingStyle &	style
	)

friend

Definition at line 870 of file G4ViewParameters.cc.

{
  switch (style) {
  case G4ViewParameters::wireframe:
    os << "wireframe"; break;
  case G4ViewParameters::hlr:
    os << "hlr - hidden lines removed"; break;
  case G4ViewParameters::hsr:
    os << "hsr - hidden surfaces removed"; break;
  case G4ViewParameters::hlhsr:
    os << "hlhsr - hidden line, hidden surface removed"; break;
  case G4ViewParameters::cloud:
    os << "cloud - draw volume as a cloud of dots"; break;
  default: os << "unrecognised"; break;
  }
  return os;
}

◆ operator<< [2/2]

std::ostream & operator<<	(	std::ostream &	os,
		const G4ViewParameters &	v
	)

friend

Definition at line 889 of file G4ViewParameters.cc.

                                                                    {
  os << "View parameters and options:";
 
  os << "\n  Drawing style: " << v.fDrawingStyle;
 
  os << "\n  Number of cloud points: " << v.fNumberOfCloudPoints;
 
  os << "\n  Auxiliary edges: ";
  if (!v.fAuxEdgeVisible) os << "in";
  os << "visible";
 
  os << "\n  Culling: ";
  if (v.fCulling) os << "on";
  else            os << "off";
 
  os << "\n  Culling invisible objects: ";
  if (v.fCullInvisible) os << "on";
  else                  os << "off";
 
  os << "\n  Density culling: ";
  if (v.fDensityCulling) {
    os << "on - invisible if density less than "
       << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
  }
  else os << "off";
 
  os << "\n  Culling daughters covered by opaque mothers: ";
  if (v.fCullCovered) os << "on";
  else                os << "off";
 
  os << "\n  Colour by density: ";
  if (v.fCBDAlgorithmNumber <= 0) {
    os << "inactive";
  } else {
    os << "Algorithm " << v.fCBDAlgorithmNumber << ", Parameters:";
    for (auto p: v.fCBDParameters) {
      os << ' ' << G4BestUnit(p,"Volumic Mass");
    }
  }
 
  os << "\n  Section flag: ";
  if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
  else            os << "false";
 
  if (v.IsCutaway()) {
    os << "\n  Cutaway planes: ";
    for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
      os << ' ' << v.fCutawayPlanes[i];
    }
  }
  else {
    os << "\n  No cutaway planes";
  }
 
  os << "\n  Explode factor: " << v.fExplodeFactor
     << " about centre: " << v.fExplodeCentre;
 
  os << "\n  No. of sides used in circle polygon approximation: "
     << v.fNoOfSides;
 
  os << "\n  Viewpoint direction:  " << v.fViewpointDirection;
 
  os << "\n  Up vector:            " << v.fUpVector;
 
  os << "\n  Field half angle:     " << v.fFieldHalfAngle;
 
  os << "\n  Zoom factor:          " << v.fZoomFactor;
 
  os << "\n  Scale factor:         " << v.fScaleFactor;
 
  os << "\n  Current target point: " << v.fCurrentTargetPoint;
 
  os << "\n  Dolly distance:       " << v.fDolly;
 
  os << "\n  Light ";
  if (v.fLightsMoveWithCamera) os << "moves";
  else                         os << "does not move";
  os << " with camera";
 
  os << "\n  Relative lightpoint direction: "
     << v.fRelativeLightpointDirection;
 
  os << "\n  Actual lightpoint direction: "
     << v.fActualLightpointDirection;
 
  os << "\n  Derived parameters for standard view of object of unit radius:";
  G4ViewParameters tempVP = v;
  tempVP.fDolly = 0.;
  tempVP.fZoomFactor = 1.;
  const G4double radius = 1.;
  const G4double cameraDistance = tempVP.GetCameraDistance (radius);
  const G4double nearDistance =
    tempVP.GetNearDistance (cameraDistance, radius);
  const G4double farDistance =
    tempVP.GetFarDistance  (cameraDistance, nearDistance, radius);
  const G4double right  = tempVP.GetFrontHalfHeight (nearDistance, radius);
  os << "\n    Camera distance:   " << cameraDistance;
  os << "\n    Near distance:     " << nearDistance;
  os << "\n    Far distance:      " << farDistance;
  os << "\n    Front half height: " << right;
 
  os << "\n  Default VisAttributes:\n  " << v.fDefaultVisAttributes;
 
  os << "\n  Default TextVisAttributes:\n  " << v.fDefaultTextVisAttributes;
 
  os << "\n  Default marker: " << v.fDefaultMarker;
 
  os << "\n  Global marker scale: " << v.fGlobalMarkerScale;
 
  os << "\n  Global lineWidth scale: " << v.fGlobalLineWidthScale;
 
  os << "\n  Marker ";
  if (v.fMarkerNotHidden) os << "not ";
  os << "hidden by surfaces.";
 
  os << "\n  Window size hint: "
     << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
 
  os << "\n  X geometry string: " << v.fXGeometryString;
  os << "\n  X geometry mask: "
     << std::showbase << std::hex << v.fGeometryMask
     << std::noshowbase << std::dec;
 
  os << "\n  Auto refresh: ";
  if (v.fAutoRefresh) os << "true";
  else os << "false";
 
  os << "\n  Background colour: " << v.fBackgroundColour;
 
  os << "\n  Picking requested: ";
  if (v.fPicking) os << "true";
  else os << "false";
 
  os << "\n  Rotation style: ";
  switch (v.fRotationStyle) {
  case G4ViewParameters::constrainUpDirection:
    os << "constrainUpDirection (conventional HEP view)"; break;
  case G4ViewParameters::freeRotation:
    os << "freeRotation (Google-like rotation, using mouse-grab)"; break;
  default: os << "unrecognised"; break;
  }
 
  os << "\n  Vis attributes modifiers: ";
  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
    v.fVisAttributesModifiers;
  if (vams.empty()) {
    os << "None";
  } else {
    os << vams;
  }
 
  os << "\n  Time window parameters:"
  << "\n  Start time:  " << v.fStartTime/ns << " ns"
  << "\n  End time:    " << v.fEndTime/ns << " ns"
  << "\n  Fade factor: " << v.fFadeFactor;
  if (!v.fDisplayHeadTime) {
    os << "\n  Head time display not requested.";
  } else {
    os
    << "\n  Head time position: "
    << v.fDisplayHeadTimeX << ' ' << v.fDisplayHeadTimeY
    << "\n  Head time size:     " << v.fDisplayHeadTimeSize
    << "\n  Head time colour:   " << v.fDisplayHeadTimeRed
    << ' ' << v.fDisplayHeadTimeGreen << ' ' << v.fDisplayHeadTimeBlue;
  }
  if (!v.fDisplayLightFront) {
    os << "\n  Light front display not requested.";
  } else {
    os
    << "\n  Light front position: "
    << v.fDisplayLightFrontX/mm << ' ' << v.fDisplayLightFrontY/mm
    << ' ' << v.fDisplayLightFrontZ/mm << " mm"
    << "\n  Light front time:     " << v.fDisplayLightFrontT/ns << " ns"
    << "\n  Light front colour:   " << v.fDisplayLightFrontRed
    << ' ' << v.fDisplayLightFrontGreen << ' ' << v.fDisplayLightFrontBlue;
  }
 
  os << "\n  Special Mesh Rendering: ";
  if (v.fSpecialMeshRendering) {
    os << "on: ";
    if (v.fSpecialMeshVolumes.empty()) {
      os << "all meshes";
    } else {
      os << "selected meshes";
      for (const auto& vol: v.fSpecialMeshVolumes) {
    os << "\n    " << vol.GetName() << ':' << vol.GetCopyNo();
      }
    }
  } else os << "off";
 
  return os;
}