G4ViewParameters.cc File Reference

#include "G4ViewParameters.hh"
#include "G4VisManager.hh"
#include "G4VPhysicalVolume.hh"
#include "G4UnitsTable.hh"
#include "G4SystemOfUnits.hh"
#include "G4Polyhedron.hh"
#include <sstream>
#include <cmath>

Go to the source code of this file.

Macros
#define	G4warn   G4cout
#define	INTERPOLATE(param)
#define	INTERPOLATELOG(param)
#define	INTERPOLATEUNITVECTOR(vector)
#define	INTERPOLATEVECTOR(vector)
#define	INTERPOLATEPOINT(point)
#define	INTERPOLATECOLOUR(colour)
#define	CONTINUITY(quantity)
#define	INTERPOLATEPLANE(plane)

Functions
std::ostream &	operator<< (std::ostream &os, G4ViewParameters::DrawingStyle style)
std::ostream &	operator<< (std::ostream &os, G4ViewParameters::SMROption option)
std::ostream &	operator<< (std::ostream &os, const G4ViewParameters &v)

Macro Definition Documentation

CONTINUITY

#define CONTINUITY

(

quantity

)

Value:

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; \
}

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

G4warn

#define G4warn   G4cout

Definition at line 43 of file G4ViewParameters.cc.

INTERPOLATE

#define INTERPOLATE

(

param

)

Value:

/* 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;

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

INTERPOLATECOLOUR

#define INTERPOLATECOLOUR

(

colour

)

Value:

INTERPOLATE(colour.GetRed());   red   = real; \
INTERPOLATE(colour.GetGreen()); green = real; \
INTERPOLATE(colour.GetBlue());  blue  = real; \
INTERPOLATE(colour.GetAlpha()); alpha = real;

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

INTERPOLATELOG

#define INTERPOLATELOG

(

param

)

Value:

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);

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

INTERPOLATEPLANE

#define INTERPOLATEPLANE

(

plane

)

Value:

INTERPOLATE(plane.a()); a = real; \
INTERPOLATE(plane.b()); b = real; \
INTERPOLATE(plane.c()); c = real; \
INTERPOLATE(plane.d()); d = real;

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

INTERPOLATEPOINT

#define INTERPOLATEPOINT

(

point

)

Value:

INTERPOLATE(point.x()); x = real; \
INTERPOLATE(point.y()); y = real; \
INTERPOLATE(point.z()); z = real;

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

INTERPOLATEUNITVECTOR

#define INTERPOLATEUNITVECTOR

(

vector

)

Value:

INTERPOLATE(vector.x()); x = real; \
INTERPOLATE(vector.y()); y = real; \
INTERPOLATE(vector.z()); z = real;

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

INTERPOLATEVECTOR

#define INTERPOLATEVECTOR

(

vector

)

Value:

INTERPOLATE(vector.x()); x = real; \
INTERPOLATE(vector.y()); y = real; \
INTERPOLATE(vector.z()); z = real;

Referenced by G4ViewParameters::CatmullRomCubicSplineInterpolation().

Function Documentation

operator<<() [1/3]

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

Definition at line 920 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 (const auto& fCutawayPlane : v.fCutawayPlanes) {
      os << ' ' << fCutawayPlane;
    }
  }
  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:\n    " << 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 << "\nVis attributes modifiers: ";
  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
    v.fVisAttributesModifiers;
  if (vams.empty()) {
    os << "None";
  } else {
    os << vams;
  }
 
  os << "\nTime window parameters:"
  << "\n  Start time:  " << v.fTimeParameters.fStartTime/ns << " ns"
  << "\n  End time:    " << v.fTimeParameters.fEndTime/ns << " ns"
  << "\n  Fade factor: " << v.fTimeParameters.fFadeFactor;
  if (!v.fTimeParameters.fDisplayHeadTime) {
    os << "\n  Head time display not requested.";
  } else {
    os
    << "\n  Head time position: "
    << v.fTimeParameters.fDisplayHeadTimeX << ' ' << v.fTimeParameters.fDisplayHeadTimeY
    << "\n  Head time size:     " << v.fTimeParameters.fDisplayHeadTimeSize
    << "\n  Head time colour:   " << v.fTimeParameters.fDisplayHeadTimeRed
    << ' ' << v.fTimeParameters.fDisplayHeadTimeGreen << ' ' << v.fTimeParameters.fDisplayHeadTimeBlue;
  }
  if (!v.fTimeParameters.fDisplayLightFront) {
    os << "\n  Light front display not requested.";
  } else {
    os
    << "\n  Light front position: "
    << v.fTimeParameters.fDisplayLightFrontX/mm << ' ' << v.fTimeParameters.fDisplayLightFrontY/mm
    << ' ' << v.fTimeParameters.fDisplayLightFrontZ/mm << " mm"
    << "\n  Light front time:     " << v.fTimeParameters.fDisplayLightFrontT/ns << " ns"
    << "\n  Light front colour:   " << v.fTimeParameters.fDisplayLightFrontRed
    << ' ' << v.fTimeParameters.fDisplayLightFrontGreen << ' ' << v.fTimeParameters.fDisplayLightFrontBlue;
  }
 
  os << "\nSpecial Mesh Rendering";
  if (v.fSpecialMeshRendering) {
    os << " requested with option \"" << v.fSpecialMeshRenderingOption;
    os << "\" for ";
    if (v.fSpecialMeshVolumes.empty()) {
      os << "any mesh";
    } else {
      os << "selected meshes";
      for (const auto& vol: v.fSpecialMeshVolumes) {
    os << "\n    " << vol.GetName() << ':' << vol.GetCopyNo();
      }
    }
  } else os << ": off";
 
  os << "\nTransparency by depth: " << v.fTransparencyByDepth
  << ", option: " << v.fTransparencyByDepthOption;
 
  os << "\nZoom to cursor requested: ";
  if (v.fZoomToCursor) os << "true";
  else os << "false";
 
  os << "\nSmooth dots requested: ";
  if (v.fDotsSmooth) os << "true";
  else os << "false";
 
  os << "\nDots size: " << v.fDotsSize;
 
  return os;
}

operator<<() [2/3]

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

Definition at line 887 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<<() [3/3]

std::ostream & operator<<	(	std::ostream &	os,
		G4ViewParameters::SMROption	option )

Definition at line 906 of file G4ViewParameters.cc.

{
  switch (option) {
    case G4ViewParameters::meshAsDefault:
      os << "default"; break;
    case G4ViewParameters::meshAsDots:
      os << "dots"; break;
    case G4ViewParameters::meshAsSurfaces:
      os << "surfaces"; break;
  }
  return os;
}