G4ViewParameters Class Reference

#include <G4ViewParameters.hh>


Public Types

 wireframe
 hlr
 hsr
 hlhsr
 polyhedron
 nurbs
 cutawayUnion
 cutawayIntersection
 constrainUpDirection
 freeRotation
enum  DrawingStyle { wireframe, hlr, hsr, hlhsr }
enum  RepStyle { polyhedron, nurbs }
enum  CutawayMode { cutawayUnion, cutawayIntersection }
enum  RotationStyle { constrainUpDirection, freeRotation }

Public Member Functions

 G4ViewParameters ()
 ~G4ViewParameters ()
G4bool operator!= (const G4ViewParameters &) const
DrawingStyle GetDrawingStyle () const
G4bool IsAuxEdgeVisible () const
RepStyle GetRepStyle () const
G4bool IsCulling () const
G4bool IsCullingInvisible () const
G4bool IsDensityCulling () const
G4double GetVisibleDensity () const
G4bool IsCullingCovered () const
G4bool IsSection () const
const G4Plane3D & GetSectionPlane () const
G4bool IsCutaway () const
CutawayMode GetCutawayMode () const
const G4Planes & GetCutawayPlanes () const
G4bool IsExplode () const
G4double GetExplodeFactor () const
const G4Point3D & GetExplodeCentre () const
G4int GetNoOfSides () const
const G4Vector3D & GetViewpointDirection () const
const G4Vector3D & GetUpVector () const
G4double GetFieldHalfAngle () const
G4double GetZoomFactor () const
const G4Vector3D & GetScaleFactor () const
const G4Point3D & GetCurrentTargetPoint () const
G4double GetDolly () const
G4bool GetLightsMoveWithCamera () const
const G4Vector3D & GetLightpointDirection () const
G4Vector3D & GetActualLightpointDirection ()
const G4VisAttributes * GetDefaultVisAttributes () const
const G4VisAttributes * GetDefaultTextVisAttributes () const
const G4VMarker & GetDefaultMarker () const
G4double GetGlobalMarkerScale () const
G4double GetGlobalLineWidthScale () const
G4bool IsMarkerNotHidden () const
unsigned int GetWindowSizeHintX () const
unsigned int GetWindowSizeHintY () const
G4int GetWindowAbsoluteLocationHintX (G4int) const
G4int GetWindowAbsoluteLocationHintY (G4int) const
G4int GetWindowLocationHintX () const
G4int GetWindowLocationHintY () const
const G4String & GetXGeometryString () const
bool IsWindowSizeHintX () const
bool IsWindowSizeHintY () const
bool IsWindowLocationHintX () const
bool IsWindowLocationHintY () const
G4bool IsAutoRefresh () const
const G4Colour & GetBackgroundColour () const
G4bool IsPicking () const
RotationStyle GetRotationStyle () const
const std::vector< G4ModelingParameters::VisAttributesModifier > & GetVisAttributesModifiers () const
G4double GetCameraDistance (G4double radius) const
G4double GetNearDistance (G4double cameraDistance, G4double radius) const
G4double GetFarDistance (G4double cameraDistance, G4double nearDistance, G4double radius) const
G4double GetFrontHalfHeight (G4double nearDistance, G4double radius) const
void SetDrawingStyle (G4ViewParameters::DrawingStyle style)
void SetAuxEdgeVisible (G4bool)
void SetRepStyle (G4ViewParameters::RepStyle style)
void SetCulling (G4bool)
void SetCullingInvisible (G4bool)
void SetDensityCulling (G4bool)
void SetVisibleDensity (G4double visibleDensity)
void SetCullingCovered (G4bool)
void SetSectionPlane (const G4Plane3D &sectionPlane)
void UnsetSectionPlane ()
void SetCutawayMode (CutawayMode)
void AddCutawayPlane (const G4Plane3D &cutawayPlane)
void ChangeCutawayPlane (size_t index, const G4Plane3D &cutawayPlane)
void ClearCutawayPlanes ()
void SetExplodeFactor (G4double explodeFactor)
void UnsetExplodeFactor ()
void SetExplodeCentre (const G4Point3D &explodeCentre)
G4int SetNoOfSides (G4int nSides)
void SetViewpointDirection (const G4Vector3D &viewpointDirection)
void SetViewAndLights (const G4Vector3D &viewpointDirection)
void SetUpVector (const G4Vector3D &upVector)
void SetFieldHalfAngle (G4double fieldHalfAngle)
void SetOrthogonalProjection ()
void SetPerspectiveProjection (G4double fieldHalfAngle=30.*CLHEP::deg)
void SetZoomFactor (G4double zoomFactor)
void MultiplyZoomFactor (G4double zoomFactorMultiplier)
void SetScaleFactor (const G4Vector3D &scaleFactor)
void MultiplyScaleFactor (const G4Vector3D &scaleFactorMultiplier)
void SetCurrentTargetPoint (const G4Point3D &currentTargetPoint)
void SetDolly (G4double dolly)
void IncrementDolly (G4double dollyIncrement)
void SetLightpointDirection (const G4Vector3D &lightpointDirection)
void SetLightsMoveWithCamera (G4bool moves)
void SetPan (G4double right, G4double up)
void IncrementPan (G4double right, G4double up)
void IncrementPan (G4double right, G4double up, G4double forward)
void SetDefaultVisAttributes (const G4VisAttributes &)
void SetDefaultColour (const G4Colour &)
void SetDefaultTextVisAttributes (const G4VisAttributes &)
void SetDefaultTextColour (const G4Colour &)
void SetDefaultMarker (const G4VMarker &defaultMarker)
void SetGlobalMarkerScale (G4double globalMarkerScale)
void SetGlobalLineWidthScale (G4double globalLineWidthScale)
void SetMarkerHidden ()
void SetMarkerNotHidden ()
void SetWindowSizeHint (G4int xHint, G4int yHint)
void SetWindowLocationHint (G4int xHint, G4int yHint)
void SetXGeometryString (const G4String &)
void SetAutoRefresh (G4bool)
void SetBackgroundColour (const G4Colour &)
void SetPicking (G4bool)
void SetRotationStyle (RotationStyle)
void AddVisAttributesModifier (const G4ModelingParameters::VisAttributesModifier &)
G4String CameraAndLightingCommands (const G4Point3D standardTargetPoint) const
G4String DrawingStyleCommands () const
G4String SceneModifyingCommands () const
G4String TouchableCommands () const
void PrintDifferences (const G4ViewParameters &v) const

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

enum G4ViewParameters::CutawayMode

Enumerator:
cutawayUnion 
cutawayIntersection 

Definition at line 106 of file G4ViewParameters.hh.

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

enum G4ViewParameters::DrawingStyle

Enumerator:
wireframe 
hlr 
hsr 
hlhsr 

Definition at line 94 of file G4ViewParameters.hh.

00094                     {
00095     wireframe,  // Draw edges    - no hidden line removal.
00096     hlr,        // Draw edges    - hidden lines removed.
00097     hsr,        // Draw surfaces - hidden surfaces removed.
00098     hlhsr       // Draw surfaces and edges - hidden removed.
00099   };

enum G4ViewParameters::RepStyle

Enumerator:
polyhedron 
nurbs 

Definition at line 101 of file G4ViewParameters.hh.

00101                 {
00102     polyhedron, // Use G4Polyhedron.
00103     nurbs       // Use G4NURBS.
00104   };

enum G4ViewParameters::RotationStyle

Enumerator:
constrainUpDirection 
freeRotation 

Definition at line 111 of file G4ViewParameters.hh.

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

Constructor & Destructor Documentation

G4ViewParameters::G4ViewParameters (  ) 

Definition at line 42 of file G4ViewParameters.cc.

References G4VMarker::SetScreenSize().

00042                                    :
00043   fDrawingStyle (wireframe),
00044   fAuxEdgeVisible (false),
00045   fRepStyle (polyhedron),
00046   fCulling (true),
00047   fCullInvisible (true),
00048   fDensityCulling (false),
00049   fVisibleDensity (0.01 * g / cm3),
00050   fCullCovered (false),
00051   fSection (false),
00052   fSectionPlane (),
00053   fCutawayMode (cutawayUnion),
00054   fCutawayPlanes (),
00055   fExplodeFactor (1.),
00056   fNoOfSides (24),
00057   fViewpointDirection (G4Vector3D (0., 0., 1.)),  // On z-axis.
00058   fUpVector (G4Vector3D (0., 1., 0.)),            // y-axis up.
00059   fFieldHalfAngle (0.),                           // Orthogonal projection.
00060   fZoomFactor (1.),
00061   fScaleFactor (G4Vector3D (1., 1., 1.)),
00062   fCurrentTargetPoint (),
00063   fDolly (0.),
00064   fLightsMoveWithCamera (false),
00065   fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
00066   fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
00067   fDefaultVisAttributes (),
00068   fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
00069   fDefaultMarker (),
00070   fGlobalMarkerScale (1.),
00071   fGlobalLineWidthScale (1.),
00072   fMarkerNotHidden (true),
00073   fWindowSizeHintX (600),
00074   fWindowSizeHintY (600),
00075   fWindowLocationHintX(0),
00076   fWindowLocationHintY(0),
00077   fWindowLocationHintXNegative(true),
00078   fWindowLocationHintYNegative(false),
00079   fGeometryMask(0),
00080   fAutoRefresh (false),
00081   fBackgroundColour (G4Colour(0.,0.,0.)),         // Black
00082   fPicking (false),
00083   fRotationStyle (constrainUpDirection)
00084 {
00085   fDefaultMarker.SetScreenSize (5.);
00086   // Markers are 5 pixels "overall" size, i.e., diameter.
00087 }

G4ViewParameters::~G4ViewParameters (  ) 

Definition at line 89 of file G4ViewParameters.cc.

00089 {}

Member Function Documentation

void G4ViewParameters::AddCutawayPlane ( const G4Plane3D &  cutawayPlane  ) 

Definition at line 151 of file G4ViewParameters.cc.

References G4cout, and G4endl.

Referenced by G4VisCommandViewerAddCutawayPlane::SetNewValue().

00151                                                                      {
00152   if (fCutawayPlanes.size () < 3 ) {
00153     fCutawayPlanes.push_back (cutawayPlane);
00154   }
00155   else {
00156     G4cout <<
00157       "ERROR: G4ViewParameters::AddCutawayPlane:"
00158       "\n  A maximum of 3 cutaway planes supported." << G4endl;
00159   }
00160 }

void G4ViewParameters::AddVisAttributesModifier ( const G4ModelingParameters::VisAttributesModifier &   )  [inline]

Definition at line 400 of file G4ViewParameters.icc.

Referenced by G4VisCommandsTouchableSet::SetNewValue().

00400                                                        {
00401   fVisAttributesModifiers.push_back(vam);
00402 }

G4String G4ViewParameters::CameraAndLightingCommands ( const G4Point3D  standardTargetPoint  )  const

Definition at line 253 of file G4ViewParameters.cc.

References G4BestUnit, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4Colour::GetColour(), G4Colour::GetGreen(), and G4Colour::GetRed().

00254 {
00255   std::ostringstream oss;
00256 
00257   oss << "#\n# Camera and lights commands";
00258   
00259   oss << "\n/vis/viewer/set/viewpointVector "
00260   << fViewpointDirection.x()
00261   << ' ' << fViewpointDirection.y()
00262   << ' ' << fViewpointDirection.z();
00263   
00264   oss << "\n/vis/viewer/set/upVector "
00265   << fUpVector.x()
00266   << ' ' << fUpVector.y()
00267   << ' ' << fUpVector.z();
00268   
00269   oss << "\n/vis/viewer/set/projection ";
00270     if (fFieldHalfAngle == 0.) {
00271     oss
00272     << "orthogonal";
00273   } else {
00274     oss
00275     << "perspective "
00276     << fFieldHalfAngle/deg
00277     << " deg";
00278   }
00279   
00280   oss << "\n/vis/viewer/zoomTo "
00281   << fZoomFactor;
00282   
00283   oss << "\n/vis/viewer/scaleTo "
00284   << fScaleFactor.x()
00285   << ' ' << fScaleFactor.y()
00286   << ' ' << fScaleFactor.z();
00287   
00288   oss << "\n/vis/viewer/set/targetPoint "
00289   << G4BestUnit(standardTargetPoint+fCurrentTargetPoint,"Length")
00290   << "\n# Note that if you have not set a target point, the vis system sets"
00291   << "\n# a target point based on the scene - plus any panning and dollying -"
00292   << "\n# so don't be alarmed by strange coordinates here.";
00293   
00294   oss << "\n/vis/viewer/dollyTo "
00295   << G4BestUnit(fDolly,"Length");
00296   
00297   oss << "\n/vis/viewer/set/lightsMove ";
00298   if (fLightsMoveWithCamera) {
00299     oss << "camera";
00300   } else {
00301     oss << "object";
00302   }
00303   
00304   oss << "\n/vis/viewer/set/lightsVector "
00305   << fRelativeLightpointDirection.x()
00306   << ' ' << fRelativeLightpointDirection.y()
00307   << ' ' << fRelativeLightpointDirection.z();
00308   
00309   oss << "\n/vis/viewer/set/rotationStyle ";
00310   if (fRotationStyle == constrainUpDirection) {
00311     oss << "constrainUpDirection";
00312   } else {
00313     oss << "freeRotation";
00314   }
00315   
00316   G4Colour c = fBackgroundColour;
00317   oss << "\n/vis/viewer/set/background "
00318   << c.GetRed()
00319   << ' ' << c.GetGreen()
00320   << ' ' << c.GetBlue()
00321   << ' ' << c.GetAlpha();
00322   
00323   c = fDefaultVisAttributes.GetColour();
00324   oss << "\n/vis/viewer/set/defaultColour "
00325   << c.GetRed()
00326   << ' ' << c.GetGreen()
00327   << ' ' << c.GetBlue()
00328   << ' ' << c.GetAlpha();
00329   
00330   c = fDefaultTextVisAttributes.GetColour();
00331   oss << "\n/vis/viewer/set/defaultTextColour "
00332   << c.GetRed()
00333   << ' ' << c.GetGreen()
00334   << ' ' << c.GetBlue()
00335   << ' ' << c.GetAlpha();
00336   
00337   oss << std::endl;
00338   
00339   return oss.str();
00340 }

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

Definition at line 163 of file G4ViewParameters.cc.

References G4cout, and G4endl.

Referenced by G4VisCommandViewerChangeCutawayPlane::SetNewValue().

00163                                               {
00164   if (index >= fCutawayPlanes.size()) {
00165     G4cout <<
00166       "ERROR: G4ViewParameters::ChangeCutawayPlane:"
00167       "\n  Plane " << index << " does not exist." << G4endl;
00168   } else {
00169     fCutawayPlanes[index] = cutawayPlane;
00170   }
00171 }

void G4ViewParameters::ClearCutawayPlanes (  )  [inline]

Definition at line 263 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerClearCutawayPlanes::SetNewValue().

00263                                                   {
00264   fCutawayPlanes.clear ();
00265 }

G4String G4ViewParameters::DrawingStyleCommands (  )  const

Definition at line 342 of file G4ViewParameters.cc.

References hlhsr, hlr, and wireframe.

00343 {
00344   std::ostringstream oss;
00345   
00346   oss << "#\n# Drawing style commands";
00347   
00348   oss << "\n/vis/viewer/set/style ";
00349   if (fDrawingStyle == wireframe || fDrawingStyle == hlr) {
00350     oss << "wireframe";
00351   } else {
00352     oss << "surface";
00353   }
00354   
00355   oss << "\n/vis/viewer/set/hiddenEdge ";
00356   if (fDrawingStyle == hlr || fDrawingStyle == hlhsr) {
00357     oss << "true";
00358   } else {
00359     oss << "false";
00360   }
00361   
00362   oss << "\n/vis/viewer/set/auxiliaryEdge ";
00363   if (fAuxEdgeVisible) {
00364     oss << "true";
00365   } else {
00366     oss << "false";
00367   }
00368   
00369   oss << "\n/vis/viewer/set/hiddenMarker ";
00370   if (fMarkerNotHidden) {
00371     oss << "false";
00372   } else {
00373     oss << "true";
00374   }
00375   
00376   oss << "\n/vis/viewer/set/globalLineWidthScale "
00377   << fGlobalLineWidthScale;
00378   
00379   oss << "\n/vis/viewer/set/globalMarkerScale "
00380   << fGlobalMarkerScale;
00381   
00382   oss << std::endl;
00383   
00384   return oss.str();
00385 }

G4Vector3D & G4ViewParameters::GetActualLightpointDirection (  ) 

Definition at line 98 of file G4ViewParameters.cc.

References SetViewAndLights().

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

00098                                                             {
00099   SetViewAndLights (fViewpointDirection);
00100   return fActualLightpointDirection;
00101 }

const G4Colour & G4ViewParameters::GetBackgroundColour (  )  const [inline]

Definition at line 203 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VisCommandsViewerSet::SetNewValue(), and G4RayTracerViewer::SetView().

00203                                                                     {
00204   return fBackgroundColour;
00205 }

G4double G4ViewParameters::GetCameraDistance ( G4double  radius  )  const

Definition at line 111 of file G4ViewParameters.cc.

Referenced by operator<<(), and G4RayTracerViewer::SetView().

00111                                                                    {
00112   G4double cameraDistance;
00113   if (fFieldHalfAngle == 0.) {
00114     cameraDistance = radius;
00115   }
00116   else {
00117     cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
00118   }
00119   return cameraDistance;
00120 }

const G4Point3D & G4ViewParameters::GetCurrentTargetPoint (  )  const [inline]

Definition at line 121 of file G4ViewParameters.icc.

Referenced by G4DAWNFILEViewer::SendViewParameters(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerPan::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), and G4RayTracerViewer::SetView().

00121                                                                        {
00122   return fCurrentTargetPoint;
00123 }

G4ViewParameters::CutawayMode G4ViewParameters::GetCutawayMode (  )  const [inline]

Definition at line 78 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00079 { return fCutawayMode;}

const G4Planes & G4ViewParameters::GetCutawayPlanes (  )  const [inline]

Definition at line 81 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerChangeCutawayPlane::SetNewValue(), and G4VisCommandViewerAddCutawayPlane::SetNewValue().

00081                                                                  {
00082   return fCutawayPlanes;
00083 }

const G4VMarker & G4ViewParameters::GetDefaultMarker (  )  const [inline]

Definition at line 147 of file G4ViewParameters.icc.

00147                                                                   {
00148   return fDefaultMarker;
00149 }

const G4VisAttributes * G4ViewParameters::GetDefaultTextVisAttributes (  )  const [inline]

Definition at line 143 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), and G4VisCommandsViewerSet::SetNewValue().

00143                                                      {
00144   return &fDefaultTextVisAttributes;
00145 }

const G4VisAttributes * G4ViewParameters::GetDefaultVisAttributes (  )  const [inline]

Definition at line 138 of file G4ViewParameters.icc.

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

00138                                                  {
00139   return &fDefaultVisAttributes;
00140 }

G4double G4ViewParameters::GetDolly (  )  const [inline]

Definition at line 125 of file G4ViewParameters.icc.

Referenced by G4DAWNFILEViewer::SendViewParameters(), G4VisCommandViewerDolly::SetNewValue(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00125                                                   {
00126   return fDolly;
00127 }

G4ViewParameters::DrawingStyle G4ViewParameters::GetDrawingStyle (  )  const [inline]

Definition at line 34 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerDefaultStyle::SetNewValue(), and G4VisCommandViewerDefaultHiddenEdge::SetNewValue().

00034                                          {
00035   return fDrawingStyle;
00036 }

const G4Point3D & G4ViewParameters::GetExplodeCentre (  )  const [inline]

Definition at line 93 of file G4ViewParameters.icc.

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

00093                                                                   {
00094   return fExplodeCentre;
00095 }

G4double G4ViewParameters::GetExplodeFactor (  )  const [inline]

Definition at line 89 of file G4ViewParameters.icc.

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

00089                                                           {
00090   return fExplodeFactor;
00091 }

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

Definition at line 130 of file G4ViewParameters.cc.

Referenced by operator<<().

00132                                                                   {
00133   G4double farDistance = cameraDistance + radius;
00134   if (farDistance < nearDistance) farDistance = nearDistance;
00135   return farDistance;
00136 }

G4double G4ViewParameters::GetFieldHalfAngle (  )  const [inline]

Definition at line 109 of file G4ViewParameters.icc.

Referenced by G4RayTracerViewer::DrawView(), G4DAWNFILEViewer::SendViewParameters(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00109                                                            {
00110   return fFieldHalfAngle;
00111 }

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

Definition at line 138 of file G4ViewParameters.cc.

Referenced by operator<<(), and G4RayTracerViewer::SetView().

00139                                                                       {
00140   G4double frontHalfHeight;
00141   if (fFieldHalfAngle == 0.) {
00142     frontHalfHeight = radius / fZoomFactor;
00143   }
00144   else {
00145     frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
00146   }
00147   return frontHalfHeight;
00148 }

G4double G4ViewParameters::GetGlobalLineWidthScale (  )  const [inline]

Definition at line 155 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00155                                                                  {
00156   return fGlobalLineWidthScale;
00157 }

G4double G4ViewParameters::GetGlobalMarkerScale (  )  const [inline]

Definition at line 151 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00151                                                               {
00152   return fGlobalMarkerScale;
00153 }

const G4Vector3D & G4ViewParameters::GetLightpointDirection (  )  const [inline]

Definition at line 129 of file G4ViewParameters.icc.

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

00129                                                                          {
00130   return fRelativeLightpointDirection;
00131 }

G4bool G4ViewParameters::GetLightsMoveWithCamera (  )  const [inline]

Definition at line 133 of file G4ViewParameters.icc.

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

00133                                                                {
00134   return fLightsMoveWithCamera;
00135 }

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

Definition at line 122 of file G4ViewParameters.cc.

Referenced by operator<<(), and G4RayTracerViewer::SetView().

00123                                                                    {
00124   const G4double small = 1.e-6 * radius;
00125   G4double nearDistance = cameraDistance - radius;
00126   if (nearDistance < small) nearDistance = small;
00127   return nearDistance;
00128 }

G4int G4ViewParameters::GetNoOfSides (  )  const [inline]

Definition at line 97 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VSceneHandler::GetNoOfSides().

00097                                                    {
00098   return fNoOfSides;
00099 }

G4ViewParameters::RepStyle G4ViewParameters::GetRepStyle (  )  const [inline]

Definition at line 42 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), and G4XXXSGViewer::CompareForKernelVisit().

00042                                                                      {
00043   return fRepStyle;
00044 }

G4ViewParameters::RotationStyle G4ViewParameters::GetRotationStyle (  )  const [inline]

Definition at line 212 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00212 {return fRotationStyle;}

const G4Vector3D & G4ViewParameters::GetScaleFactor (  )  const [inline]

Definition at line 117 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerScale::SetNewValue(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00117                                                                  {
00118   return fScaleFactor;
00119 }

const G4Plane3D & G4ViewParameters::GetSectionPlane (  )  const [inline]

Definition at line 70 of file G4ViewParameters.icc.

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

00070                                                                  {
00071   return fSectionPlane;
00072 }

const G4Vector3D & G4ViewParameters::GetUpVector (  )  const [inline]

Definition at line 105 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4RayTracerViewer::SetView().

00105                                                               {
00106   return fUpVector;
00107 }

const G4Vector3D & G4ViewParameters::GetViewpointDirection (  )  const [inline]

Definition at line 101 of file G4ViewParameters.icc.

Referenced by G4DAWNFILEViewer::SendViewParameters(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), and G4RayTracerViewer::SetView().

00101                                                                         {
00102   return fViewpointDirection;
00103 }

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

Definition at line 215 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), and G4VSceneHandler::CreateModelingParameters().

00215                                                   {
00216   return fVisAttributesModifiers;
00217 }

G4double G4ViewParameters::GetVisibleDensity (  )  const [inline]

Definition at line 58 of file G4ViewParameters.icc.

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

00058                                                            {
00059   return fVisibleDensity;
00060 }

G4int G4ViewParameters::GetWindowAbsoluteLocationHintX ( G4int   )  const

Definition at line 978 of file G4ViewParameters.cc.

00978                                                                           {
00979   if ( fWindowLocationHintXNegative ) {
00980     return  sizeX  + fWindowLocationHintX - fWindowSizeHintX;
00981   }
00982   return fWindowLocationHintX;
00983 }

G4int G4ViewParameters::GetWindowAbsoluteLocationHintY ( G4int   )  const

Definition at line 985 of file G4ViewParameters.cc.

00985                                                                           {
00986   if (  fWindowLocationHintYNegative ) {
00987     return  sizeY  + fWindowLocationHintY - fWindowSizeHintY;
00988   }
00989   return fWindowLocationHintY;
00990 }

G4int G4ViewParameters::GetWindowLocationHintX (  )  const [inline]

Definition at line 187 of file G4ViewParameters.icc.

00187                                                              {
00188   return fWindowLocationHintX;
00189 }

G4int G4ViewParameters::GetWindowLocationHintY (  )  const [inline]

Definition at line 191 of file G4ViewParameters.icc.

00191                                                              {
00192   return fWindowLocationHintY;
00193 }

unsigned int G4ViewParameters::GetWindowSizeHintX (  )  const [inline]

Definition at line 179 of file G4ViewParameters.icc.

00179                                                                 {
00180   return fWindowSizeHintX;
00181 }

unsigned int G4ViewParameters::GetWindowSizeHintY (  )  const [inline]

Definition at line 183 of file G4ViewParameters.icc.

00183                                                                 {
00184   return fWindowSizeHintY;
00185 }

const G4String & G4ViewParameters::GetXGeometryString (  )  const [inline]

Definition at line 195 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerClone::SetNewValue().

00195                                                                    {
00196   return fXGeometryString;
00197 }

G4double G4ViewParameters::GetZoomFactor (  )  const [inline]

Definition at line 113 of file G4ViewParameters.icc.

Referenced by G4DAWNFILEViewer::SendViewParameters(), G4VisCommandViewerZoom::SetNewValue(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00113                                                        {
00114   return fZoomFactor;
00115 }

void G4ViewParameters::IncrementDolly ( G4double  dollyIncrement  )  [inline]

Definition at line 323 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerDolly::SetNewValue().

00323                                                                      {
00324   fDolly += dollyIncrement;
00325 }

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

Definition at line 246 of file G4ViewParameters.cc.

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

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

Definition at line 242 of file G4ViewParameters.cc.

Referenced by G4VisCommandViewerPan::SetNewValue().

00242                                                                 {
00243   IncrementPan (right,up, 0);
00244 }

G4bool G4ViewParameters::IsAutoRefresh (  )  const [inline]

Definition at line 199 of file G4ViewParameters.icc.

Referenced by G4VVisCommandViewer::RefreshIfRequired(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), and G4VisCommandDrawView::SetNewValue().

00199                                                      {
00200   return fAutoRefresh;
00201 }

G4bool G4ViewParameters::IsAuxEdgeVisible (  )  const [inline]

Definition at line 38 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VSceneHandler::GetAuxEdgeVisible(), and G4VisCommandsViewerSet::SetNewValue().

00038                                                         {
00039   return fAuxEdgeVisible;
00040 }

G4bool G4ViewParameters::IsCulling (  )  const [inline]

Definition at line 46 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VisManager::CreateViewer(), G4VisCommandGeometrySetVisibility::SetNewValue(), G4VisCommandGeometrySetDaughtersInvisible::SetNewValue(), and G4VisCommandGeometrySetVisibility::SetNewValueOnLV().

00046                                                  {
00047   return fCulling;
00048 }

G4bool G4ViewParameters::IsCullingCovered (  )  const [inline]

Definition at line 62 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), and G4VisManager::CreateViewer().

00062                                                         {
00063   return fCullCovered;
00064 }

G4bool G4ViewParameters::IsCullingInvisible (  )  const [inline]

Definition at line 50 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), G4VSceneHandler::CreateModelingParameters(), G4VisManager::CreateViewer(), G4VisCommandGeometrySetVisibility::SetNewValue(), and G4VisCommandGeometrySetVisibility::SetNewValueOnLV().

00050                                                           {
00051   return fCullInvisible;
00052 }

G4bool G4ViewParameters::IsCutaway (  )  const [inline]

Definition at line 74 of file G4ViewParameters.icc.

Referenced by G4VSceneHandler::CreateModelingParameters(), operator!=(), operator<<(), and PrintDifferences().

00074                                                  {
00075   return fCutawayPlanes.size() > 0;
00076 }

G4bool G4ViewParameters::IsDensityCulling (  )  const [inline]

Definition at line 54 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), and G4VSceneHandler::CreateModelingParameters().

00054                                                         {
00055   return fDensityCulling;
00056 }

G4bool G4ViewParameters::IsExplode (  )  const [inline]

Definition at line 85 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), operator!=(), and PrintDifferences().

00085                                                  {
00086   return fExplodeFactor > 1.;
00087 }

G4bool G4ViewParameters::IsMarkerNotHidden (  )  const [inline]

Definition at line 159 of file G4ViewParameters.icc.

Referenced by G4XXXStoredViewer::CompareForKernelVisit(), G4XXXSGViewer::CompareForKernelVisit(), and G4VisCommandsViewerSet::SetNewValue().

00159                                                          {
00160   return fMarkerNotHidden;
00161 }

G4bool G4ViewParameters::IsPicking (  )  const [inline]

Definition at line 207 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00207                                                  {
00208   return fPicking;
00209 }

G4bool G4ViewParameters::IsSection (  )  const [inline]

Definition at line 66 of file G4ViewParameters.icc.

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

00066                                                  {
00067   return fSection;
00068 }

bool G4ViewParameters::IsWindowLocationHintX (  )  const [inline]

Definition at line 171 of file G4ViewParameters.icc.

00171                                                            {
00172   return (fGeometryMask & fXValue);
00173 }

bool G4ViewParameters::IsWindowLocationHintY (  )  const [inline]

Definition at line 175 of file G4ViewParameters.icc.

00175                                                            {
00176   return (fGeometryMask & fYValue);
00177 }

bool G4ViewParameters::IsWindowSizeHintX (  )  const [inline]

Definition at line 163 of file G4ViewParameters.icc.

00163                                                        {
00164   return (fGeometryMask & fWidthValue);
00165 }

bool G4ViewParameters::IsWindowSizeHintY (  )  const [inline]

Definition at line 167 of file G4ViewParameters.icc.

00167                                                        {
00168   return (fGeometryMask & fHeightValue);
00169 }

void G4ViewParameters::MultiplyScaleFactor ( const G4Vector3D &  scaleFactorMultiplier  ) 

Definition at line 92 of file G4ViewParameters.cc.

Referenced by G4VisCommandViewerScale::SetNewValue().

00092                                           {
00093   fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
00094   fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
00095   fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
00096 }

void G4ViewParameters::MultiplyZoomFactor ( G4double  zoomFactorMultiplier  )  [inline]

Definition at line 306 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerZoom::SetNewValue().

00306                                                                    {
00307   fZoomFactor *= zoomFactorMultiplier;
00308 }

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

Definition at line 822 of file G4ViewParameters.cc.

References fAutoRefresh, fAuxEdgeVisible, fBackgroundColour, fCullCovered, fCulling, fCullInvisible, fCurrentTargetPoint, fCutawayPlanes, fDefaultMarker, fDefaultTextVisAttributes, fDefaultVisAttributes, fDensityCulling, fDolly, fDrawingStyle, fExplodeCentre, fExplodeFactor, fFieldHalfAngle, fGeometryMask, fGlobalLineWidthScale, fGlobalMarkerScale, fLightsMoveWithCamera, fMarkerNotHidden, fNoOfSides, fPicking, fRelativeLightpointDirection, fRepStyle, fRotationStyle, fScaleFactor, fSection, fSectionPlane, fUpVector, fViewpointDirection, fVisAttributesModifiers, fVisibleDensity, fWindowSizeHintX, fWindowSizeHintY, fXGeometryString, fZoomFactor, IsCutaway(), IsExplode(), and G4ModelingParameters::VAMSNotEqual().

00822                                                                      {
00823 
00824   // Put performance-sensitive parameters first.
00825   if (
00826       // This first to optimise spin, etc.
00827       (fViewpointDirection   != v.fViewpointDirection)   ||
00828 
00829       // No particular order from here on.
00830       (fDrawingStyle         != v.fDrawingStyle)         ||
00831       (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
00832       (fRepStyle             != v.fRepStyle)             ||
00833       (fCulling              != v.fCulling)              ||
00834       (fCullInvisible        != v.fCullInvisible)        ||
00835       (fDensityCulling       != v.fDensityCulling)       ||
00836       (fCullCovered          != v.fCullCovered)          ||
00837       (fSection              != v.fSection)              ||
00838       (IsCutaway()           != v.IsCutaway())           ||
00839       (IsExplode()           != v.IsExplode())           ||
00840       (fNoOfSides            != v.fNoOfSides)            ||
00841       (fUpVector             != v.fUpVector)             ||
00842       (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
00843       (fZoomFactor           != v.fZoomFactor)           ||
00844       (fScaleFactor          != v.fScaleFactor)          ||
00845       (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
00846       (fDolly                != v.fDolly)                ||
00847       (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
00848       (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
00849       (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
00850       (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
00851       (fDefaultMarker        != v.fDefaultMarker)        ||
00852       (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
00853       (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
00854       (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
00855       (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
00856       (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
00857       (fXGeometryString      != v.fXGeometryString)      ||
00858       (fGeometryMask         != v.fGeometryMask)         ||
00859       (fAutoRefresh          != v.fAutoRefresh)          ||
00860       (fBackgroundColour     != v.fBackgroundColour)     ||
00861       (fPicking              != v.fPicking)              ||
00862       (fRotationStyle        != v.fRotationStyle)
00863       )
00864     return true;
00865 
00866   if (fDensityCulling &&
00867       (fVisibleDensity != v.fVisibleDensity)) return true;
00868 
00869   if (fSection &&
00870       (!(fSectionPlane == v.fSectionPlane))) return true;
00871 
00872   if (IsCutaway()) {
00873     if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
00874       return true;
00875     else {
00876       for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
00877         if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
00878       }
00879     }
00880   }
00881 
00882   if (IsExplode() &&
00883       ((fExplodeFactor != v.fExplodeFactor) ||
00884        (fExplodeCentre != v.fExplodeCentre))) return true;
00885 
00886   if (G4ModelingParameters::VAMSNotEqual
00887       (fVisAttributesModifiers, v.fVisAttributesModifiers))
00888     return true;
00889 
00890   return false;
00891 }

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

Definition at line 576 of file G4ViewParameters.cc.

References fAutoRefresh, fAuxEdgeVisible, fBackgroundColour, fCullCovered, fCulling, fCullInvisible, fCurrentTargetPoint, fCutawayPlanes, fDefaultMarker, fDefaultTextVisAttributes, fDefaultVisAttributes, fDensityCulling, fDolly, fDrawingStyle, fExplodeCentre, fExplodeFactor, fFieldHalfAngle, fGeometryMask, fGlobalLineWidthScale, fGlobalMarkerScale, fLightsMoveWithCamera, fMarkerNotHidden, fNoOfSides, fPicking, fRelativeLightpointDirection, fRepStyle, fRotationStyle, fScaleFactor, fSection, fSectionPlane, fUpVector, fViewpointDirection, fVisibleDensity, fWindowSizeHintX, fWindowSizeHintY, fXGeometryString, fZoomFactor, G4cout, G4endl, IsCutaway(), and IsExplode().

00576                                                                         {
00577 
00578   // Put performance-sensitive parameters first.
00579   if (
00580       // This first to optimise spin, etc.
00581       (fViewpointDirection   != v.fViewpointDirection)   ||
00582 
00583       // No particular order from here on.
00584       (fDrawingStyle         != v.fDrawingStyle)         ||
00585       (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
00586       (fRepStyle             != v.fRepStyle)             ||
00587       (fCulling              != v.fCulling)              ||
00588       (fCullInvisible        != v.fCullInvisible)        ||
00589       (fDensityCulling       != v.fDensityCulling)       ||
00590       (fVisibleDensity       != v.fVisibleDensity)       ||
00591       (fCullCovered          != v.fCullCovered)          ||
00592       (fSection              != v.fSection)              ||
00593       (fNoOfSides            != v.fNoOfSides)            ||
00594       (fUpVector             != v.fUpVector)             ||
00595       (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
00596       (fZoomFactor           != v.fZoomFactor)           ||
00597       (fScaleFactor          != v.fScaleFactor)          ||
00598       (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
00599       (fDolly                != v.fDolly)                ||
00600       (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
00601       (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
00602       (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
00603       (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
00604       (fDefaultMarker        != v.fDefaultMarker)        ||
00605       (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
00606       (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
00607       (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
00608       (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
00609       (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
00610       (fXGeometryString      != v.fXGeometryString)      ||
00611       (fGeometryMask         != v.fGeometryMask)         ||
00612       (fAutoRefresh          != v.fAutoRefresh)          ||
00613       (fBackgroundColour     != v.fBackgroundColour)     || 
00614       (fPicking              != v.fPicking)              ||
00615       (fRotationStyle        != v.fRotationStyle)
00616       )
00617     G4cout << "Difference in 1st batch." << G4endl;
00618 
00619   if (fSection) {
00620     if (!(fSectionPlane == v.fSectionPlane))
00621       G4cout << "Difference in section planes batch." << G4endl;
00622   }
00623 
00624   if (IsCutaway()) {
00625     if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
00626       G4cout << "Difference in no of cutaway planes." << G4endl;
00627     }
00628     else {
00629       for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
00630         if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
00631           G4cout << "Difference in cutaway plane no. " << i << G4endl;
00632       }
00633     }
00634   }
00635 
00636   if (IsExplode()) {
00637     if (fExplodeFactor != v.fExplodeFactor)
00638       G4cout << "Difference in explode factor." << G4endl;
00639     if (fExplodeCentre != v.fExplodeCentre)
00640       G4cout << "Difference in explode centre." << G4endl;
00641   }
00642 }

G4String G4ViewParameters::SceneModifyingCommands (  )  const

Definition at line 387 of file G4ViewParameters.cc.

References cutawayUnion, and G4BestUnit.

00388 {
00389   std::ostringstream oss;
00390   
00391   oss << "#\n# Scene-modifying commands";
00392   
00393   oss << "\n/vis/viewer/set/culling global ";
00394   if (fCulling) {
00395     oss << "true";
00396   } else {
00397     oss << "false";
00398   }
00399 
00400   oss << "\n/vis/viewer/set/culling invisible ";
00401   if (fCullInvisible) {
00402     oss << "true";
00403   } else {
00404     oss << "false";
00405   }
00406   
00407   oss << "\n/vis/viewer/set/culling density ";
00408   if (fDensityCulling) {
00409     oss << "true " << fVisibleDensity/(g/cm3) << " g/cm3";
00410   } else {
00411     oss << "false";
00412   }
00413   
00414   oss << "\n/vis/viewer/set/culling coveredDaughters ";
00415   if (fCullCovered) {
00416     oss << "true";
00417   } else {
00418     oss << "false";
00419   }
00420   
00421   oss << "\n/vis/viewer/set/sectionPlane ";
00422   if (fSection) {
00423     oss << "on "
00424     << G4BestUnit(fSectionPlane.point(),"Length")
00425     << fSectionPlane.normal().x()
00426     << ' ' << fSectionPlane.normal().y()
00427     << ' ' << fSectionPlane.normal().z();
00428   } else {
00429     oss << "off";
00430   }
00431   
00432   oss << "\n/vis/viewer/set/cutawayMode ";
00433   if (fCutawayMode == cutawayUnion) {
00434     oss << "union";
00435   } else {
00436     oss << "intersection";
00437   }
00438   
00439   oss << "\n/vis/viewer/clearCutawayPlanes";
00440   if (fCutawayPlanes.size()) {
00441     for (size_t i = 0; i < fCutawayPlanes.size(); i++) {
00442       oss << "\n/vis/viewer/addCutawayPlane "
00443       << G4BestUnit(fCutawayPlanes[i].point(),"Length")
00444       << fCutawayPlanes[i].normal().x()
00445       << ' ' << fCutawayPlanes[i].normal().y()
00446       << ' ' << fCutawayPlanes[i].normal().z();
00447     }
00448   } else {
00449     oss << "\n# No cutaway planes defined.";
00450   }
00451   
00452   oss << "\n/vis/viewer/set/explodeFactor "
00453   << fExplodeFactor
00454   << ' ' << G4BestUnit(fExplodeCentre,"Length");
00455   
00456   oss << "\n/vis/viewer/set/lineSegmentsPerCircle "
00457   << fNoOfSides;
00458   
00459   oss << std::endl;
00460   
00461   return oss.str();
00462 }

void G4ViewParameters::SetAutoRefresh ( G4bool   )  [inline]

Definition at line 382 of file G4ViewParameters.icc.

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

00382                                                           {
00383   fAutoRefresh = state;
00384 }

void G4ViewParameters::SetAuxEdgeVisible ( G4bool   )  [inline]

Definition at line 224 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00224                                                            {
00225   fAuxEdgeVisible = vis;
00226 }

void G4ViewParameters::SetBackgroundColour ( const G4Colour &   )  [inline]

Definition at line 386 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00386                                                                          {
00387   fBackgroundColour = colour;
00388 }

void G4ViewParameters::SetCulling ( G4bool   )  [inline]

Definition at line 233 of file G4ViewParameters.icc.

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

00233                                                       {
00234   fCulling = value;
00235 }

void G4ViewParameters::SetCullingCovered ( G4bool   )  [inline]

Definition at line 245 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00245                                                              {
00246   fCullCovered = value;
00247 }

void G4ViewParameters::SetCullingInvisible ( G4bool   )  [inline]

Definition at line 237 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00237                                                                {
00238   fCullInvisible = value;
00239 }

void G4ViewParameters::SetCurrentTargetPoint ( const G4Point3D &  currentTargetPoint  )  [inline]

Definition at line 315 of file G4ViewParameters.icc.

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

00315                                                                             {
00316   fCurrentTargetPoint = currentTargetPoint;
00317 }

void G4ViewParameters::SetCutawayMode ( CutawayMode   )  [inline]

Definition at line 259 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00259                                           {
00260   fCutawayMode = cutawayMode;
00261 }

void G4ViewParameters::SetDefaultColour ( const G4Colour &   )  [inline]

Definition at line 336 of file G4ViewParameters.icc.

References G4VisAttributes::SetColour().

00336                                                                       {
00337   fDefaultVisAttributes.SetColour (colour);
00338 }

void G4ViewParameters::SetDefaultMarker ( const G4VMarker &  defaultMarker  )  [inline]

Definition at line 350 of file G4ViewParameters.icc.

00350                                                                   {
00351   fDefaultMarker = defaultMarker;
00352 }

void G4ViewParameters::SetDefaultTextColour ( const G4Colour &   )  [inline]

Definition at line 345 of file G4ViewParameters.icc.

References G4VisAttributes::SetColour().

00345                                                                           {
00346   fDefaultTextVisAttributes.SetColour (colour);
00347 }

void G4ViewParameters::SetDefaultTextVisAttributes ( const G4VisAttributes &   )  [inline]

Definition at line 341 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00341                                                   {
00342   fDefaultTextVisAttributes = defaultTextVisAttributes;
00343 }

void G4ViewParameters::SetDefaultVisAttributes ( const G4VisAttributes &   )  [inline]

Definition at line 332 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00332                                               {
00333   fDefaultVisAttributes = defaultVisAttributes;
00334 }

void G4ViewParameters::SetDensityCulling ( G4bool   )  [inline]

Definition at line 241 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00241                                                              {
00242   fDensityCulling = value;
00243 }

void G4ViewParameters::SetDolly ( G4double  dolly  )  [inline]

Definition at line 319 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerDolly::SetNewValue(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00319                                                       {
00320   fDolly = dolly;
00321 }

void G4ViewParameters::SetDrawingStyle ( G4ViewParameters::DrawingStyle  style  )  [inline]

Definition at line 220 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerDefaultStyle::SetNewValue(), and G4VisCommandViewerDefaultHiddenEdge::SetNewValue().

00220                                                                      {
00221   fDrawingStyle = style;
00222 }

void G4ViewParameters::SetExplodeCentre ( const G4Point3D &  explodeCentre  )  [inline]

Definition at line 282 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00282                                  {
00283   fExplodeCentre = explodeCentre;
00284 }

void G4ViewParameters::SetExplodeFactor ( G4double  explodeFactor  )  [inline]

Definition at line 272 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00272                                                                       {
00273   fExplodeFactor = explodeFactor;
00274   if (fExplodeFactor < 1.) fExplodeFactor = 1.;
00275 }

void G4ViewParameters::SetFieldHalfAngle ( G4double  fieldHalfAngle  )  [inline]

Definition at line 289 of file G4ViewParameters.icc.

Referenced by G4RayTracerViewer::DrawView(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), SetOrthogonalProjection(), and SetPerspectiveProjection().

00289                                                                         {
00290   fFieldHalfAngle = fieldHalfAngle;
00291 }

void G4ViewParameters::SetGlobalLineWidthScale ( G4double  globalLineWidthScale  )  [inline]

Definition at line 360 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00360                                                                         {
00361   fGlobalLineWidthScale = globalLineWidthScale;
00362 }

void G4ViewParameters::SetGlobalMarkerScale ( G4double  globalMarkerScale  )  [inline]

Definition at line 355 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00355                                                                   {
00356   fGlobalMarkerScale = globalMarkerScale;
00357 }

void G4ViewParameters::SetLightpointDirection ( const G4Vector3D &  lightpointDirection  ) 

Definition at line 231 of file G4ViewParameters.cc.

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

00231                                         {
00232   fRelativeLightpointDirection = lightpointDirection;
00233   SetViewAndLights (fViewpointDirection);
00234 }

void G4ViewParameters::SetLightsMoveWithCamera ( G4bool  moves  )  [inline]

Definition at line 327 of file G4ViewParameters.icc.

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

00327                                                                    {
00328   fLightsMoveWithCamera = moves;
00329 }

void G4ViewParameters::SetMarkerHidden (  )  [inline]

Definition at line 364 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00364                                                {
00365   fMarkerNotHidden = false;
00366 }

void G4ViewParameters::SetMarkerNotHidden (  )  [inline]

Definition at line 368 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00368                                                   {
00369   fMarkerNotHidden = true;
00370 }

G4int G4ViewParameters::SetNoOfSides ( G4int  nSides  ) 

Definition at line 190 of file G4ViewParameters.cc.

References G4cout, and G4endl.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00190                                                   {
00191   const G4int  nSidesMin = 12;
00192   if (nSides < nSidesMin) {
00193     nSides = nSidesMin;
00194     G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
00195       "\nnumber of sides per circle < " << nSidesMin
00196          << "; forced to " << nSides << G4endl;
00197   }
00198   fNoOfSides = nSides;
00199   return fNoOfSides;
00200 }

void G4ViewParameters::SetOrthogonalProjection (  )  [inline]

Definition at line 293 of file G4ViewParameters.icc.

References SetFieldHalfAngle().

00293                                                        {
00294   SetFieldHalfAngle(0.);
00295 }

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

Definition at line 236 of file G4ViewParameters.cc.

Referenced by G4VisCommandViewerPan::SetNewValue().

00236                                                           {
00237   G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
00238   G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
00239   fCurrentTargetPoint  = right * unitRight + up * unitUp;
00240 }

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

Definition at line 297 of file G4ViewParameters.icc.

References SetFieldHalfAngle().

00297                                                                               {
00298   SetFieldHalfAngle(fieldHalfAngle);
00299 }

void G4ViewParameters::SetPicking ( G4bool   )  [inline]

Definition at line 390 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00390                                                         {
00391   fPicking = picking;
00392 }

void G4ViewParameters::SetRepStyle ( G4ViewParameters::RepStyle  style  )  [inline]

Definition at line 229 of file G4ViewParameters.icc.

00229                                                              {
00230   fRepStyle = style;
00231 }

void G4ViewParameters::SetRotationStyle ( RotationStyle   )  [inline]

Definition at line 395 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00395                                         {
00396   fRotationStyle = style;
00397 }

void G4ViewParameters::SetScaleFactor ( const G4Vector3D &  scaleFactor  )  [inline]

Definition at line 310 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerScale::SetNewValue(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00310                                                                            {
00311   fScaleFactor = scaleFactor;
00312 }

void G4ViewParameters::SetSectionPlane ( const G4Plane3D &  sectionPlane  )  [inline]

Definition at line 249 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00249                                                                             {
00250   fSection = true;
00251   fSectionPlane = sectionPlane;
00252 }

void G4ViewParameters::SetUpVector ( const G4Vector3D &  upVector  )  [inline]

Definition at line 285 of file G4ViewParameters.icc.

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

00285                                                                      {
00286   fUpVector = upVector;
00287 }

void G4ViewParameters::SetViewAndLights ( const G4Vector3D &  viewpointDirection  ) 

Definition at line 203 of file G4ViewParameters.cc.

References G4cout, and G4endl.

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

00203                                        {
00204 
00205   fViewpointDirection = viewpointDirection;
00206 
00207   // If the requested viewpoint direction is parallel to the up
00208   // vector, the orientation of the view is undefined...
00209   if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
00210     G4cout <<
00211       "WARNING: Viewpoint direction is very close to the up vector direction."
00212       "\n  Consider setting the up vector to obtain definable behaviour."
00213            << G4endl;
00214   }
00215 
00216   // Move the lights too if requested...
00217   if (fLightsMoveWithCamera) {
00218     G4Vector3D zprime = fViewpointDirection.unit ();
00219     G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
00220     G4Vector3D yprime = zprime.cross (xprime);
00221     fActualLightpointDirection =
00222       fRelativeLightpointDirection.x () * xprime +
00223       fRelativeLightpointDirection.y () * yprime +
00224       fRelativeLightpointDirection.x () * zprime;     
00225   } else {
00226     fActualLightpointDirection = fRelativeLightpointDirection;
00227   }
00228 }

void G4ViewParameters::SetViewpointDirection ( const G4Vector3D &  viewpointDirection  )  [inline]

Definition at line 268 of file G4ViewParameters.icc.

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

00268                                        {
00269   SetViewAndLights (viewpointDirection);
00270 }

void G4ViewParameters::SetVisibleDensity ( G4double  visibleDensity  ) 

Definition at line 173 of file G4ViewParameters.cc.

References G4BestUnit, G4cout, and G4endl.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00173                                                                  {
00174   const G4double reasonableMaximum = 10.0 * g / cm3;
00175   if (visibleDensity < 0) {
00176     G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
00177       "density - ignored." << G4endl;
00178   }
00179   else {
00180     if (visibleDensity > reasonableMaximum) {
00181       G4cout << "G4ViewParameters::SetVisibleDensity: density > "
00182              << G4BestUnit (reasonableMaximum, "Volumic Mass")
00183              << " - did you mean this?"
00184              << G4endl;
00185     }
00186     fVisibleDensity = visibleDensity;
00187   }
00188 }

void G4ViewParameters::SetWindowLocationHint ( G4int  xHint,
G4int  yHint 
) [inline]

Definition at line 377 of file G4ViewParameters.icc.

00377                                                                              {
00378   fWindowLocationHintX = xHint;
00379   fWindowLocationHintY = yHint;
00380 }

void G4ViewParameters::SetWindowSizeHint ( G4int  xHint,
G4int  yHint 
) [inline]

Definition at line 372 of file G4ViewParameters.icc.

00372                                                                          {
00373   fWindowSizeHintX = xHint;
00374   fWindowSizeHintY = yHint;
00375 }

void G4ViewParameters::SetXGeometryString ( const G4String &   ) 

Definition at line 894 of file G4ViewParameters.cc.

References G4cout, and G4endl.

Referenced by G4VisManager::CreateViewer().

00894                                                                         {
00895 
00896 
00897   G4int x,y = 0;
00898   unsigned int w,h = 0;
00899   G4String geomString = geomStringArg;
00900   // Parse windowSizeHintString for backwards compatibility...
00901   const G4String delimiters("xX+-");
00902   G4String::size_type i = geomString.find_first_of(delimiters);
00903   if (i == G4String::npos) {  // Does not contain "xX+-".  Assume single number
00904     std::istringstream iss(geomString);
00905     G4int size;
00906     iss >> size;
00907     if (!iss) {
00908       size = 600;
00909       G4cout << "Unrecognised windowSizeHint string: \""
00910              << geomString
00911              << "\".  Asuuming " << size << G4endl;
00912     }
00913     std::ostringstream oss;
00914     oss << size << 'x' << size;
00915     geomString = oss.str();
00916   }
00917  
00918   fGeometryMask = ParseGeometry( geomString, &x, &y, &w, &h );
00919 
00920   // Handle special case :
00921   if ((fGeometryMask & fYValue) == 0)
00922     {  // Using default
00923       y =  fWindowLocationHintY;
00924     }
00925   if ((fGeometryMask & fXValue) == 0)
00926     {  // Using default
00927       x =  fWindowLocationHintX;
00928     }
00929 
00930   // Check errors
00931   // if there is no Width and Height
00932   if ( ((fGeometryMask & fHeightValue) == 0 ) &&
00933        ((fGeometryMask & fWidthValue)  == 0 )) {
00934     h = fWindowSizeHintY;
00935     w = fWindowSizeHintX;
00936   } else  if ((fGeometryMask & fHeightValue) == 0 ) {
00937 
00938     // if there is only Width. Special case to be backward compatible
00939     // We set Width and Height the same to obtain a square windows.
00940     
00941     G4cout << "Unrecognised geometry string \""
00942            << geomString
00943            << "\".  No Height found. Using Width value instead"
00944            << G4endl;
00945     h = w;
00946   }
00947   if ( ((fGeometryMask & fXValue) == 0 ) ||
00948        ((fGeometryMask & fYValue)  == 0 )) {
00949     //Using defaults
00950     x = fWindowLocationHintX;
00951     y = fWindowLocationHintY;
00952   }
00953   // Set the string
00954   fXGeometryString = geomString;
00955   
00956   // Set values
00957   fWindowSizeHintX = w;
00958   fWindowSizeHintY = h;
00959   fWindowLocationHintX = x;
00960   fWindowLocationHintY = y;
00961 
00962   if ( ((fGeometryMask & fXValue)) &&
00963        ((fGeometryMask & fYValue))) {
00964 
00965     if ( (fGeometryMask & fXNegative) ) {
00966       fWindowLocationHintXNegative = true;
00967     } else {
00968       fWindowLocationHintXNegative = false;
00969     }
00970     if ( (fGeometryMask & fYNegative) ) {
00971     fWindowLocationHintYNegative = true;
00972     } else {
00973       fWindowLocationHintYNegative = false;
00974     }
00975   }
00976 }

void G4ViewParameters::SetZoomFactor ( G4double  zoomFactor  )  [inline]

Definition at line 301 of file G4ViewParameters.icc.

Referenced by G4VisCommandViewerZoom::SetNewValue(), and G4VisCommandViewerCopyViewFrom::SetNewValue().

00301                                                                 {
00302   fZoomFactor = zoomFactor;
00303 }

G4String G4ViewParameters::TouchableCommands (  )  const

Definition at line 464 of file G4ViewParameters.cc.

References G4VisAttributes::dashed, G4VisAttributes::dotted, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4VisAttributes::GetForcedDrawingStyle(), G4VisAttributes::GetForcedLineSegmentsPerCircle(), G4Colour::GetGreen(), G4VisAttributes::GetLineStyle(), G4VisAttributes::GetLineWidth(), G4Colour::GetRed(), G4VisAttributes::IsDaughtersInvisible(), G4VisAttributes::IsForceAuxEdgeVisible(), G4VisAttributes::IsForceDrawingStyle(), G4VisAttributes::IsVisible(), G4VisAttributes::solid, G4VisAttributes::unbroken, G4ModelingParameters::VASColour, G4ModelingParameters::VASDaughtersInvisible, G4ModelingParameters::VASForceAuxEdgeVisible, G4ModelingParameters::VASForceLineSegmentsPerCircle, G4ModelingParameters::VASForceSolid, G4ModelingParameters::VASForceWireframe, G4ModelingParameters::VASLineStyle, G4ModelingParameters::VASLineWidth, G4ModelingParameters::VASVisibility, and G4VisAttributes::wireframe.

00465 {
00466   std::ostringstream oss;
00467   
00468   oss << "#\n# Touchable commands";
00469   
00470   const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
00471     fVisAttributesModifiers;
00472 
00473   if (vams.empty()) {
00474     oss << "\n# None";
00475     oss << std::endl;
00476     return oss.str();
00477   }
00478   
00479   std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
00480     iModifier;
00481   for (iModifier = vams.begin();
00482        iModifier != vams.end();
00483        ++iModifier) {
00484     oss << "\n/vis/set/touchable";
00485     const G4ModelingParameters::PVNameCopyNoPath& vamPath =
00486       iModifier->GetPVNameCopyNoPath();
00487     G4ModelingParameters::PVNameCopyNoPathConstIterator iVAM;
00488     for (iVAM = vamPath.begin();
00489          iVAM != vamPath.end();
00490          ++iVAM) {
00491       oss << ' ' << iVAM->GetName() << ' ' << iVAM->GetCopyNo();
00492     }
00493     const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
00494     const G4Colour& c = vamVisAtts.GetColour();
00495     switch (iModifier->GetVisAttributesSignifier()) {
00496       case G4ModelingParameters::VASVisibility:
00497         oss << "\n/vis/touchable/set/visibility ";
00498         if (vamVisAtts.IsVisible()) {
00499           oss << "true";
00500         } else {
00501           oss << "false";
00502         }
00503         break;
00504       case G4ModelingParameters::VASDaughtersInvisible:
00505         oss << "\n/vis/touchable/set/daughtersInvisible ";
00506         if (vamVisAtts.IsDaughtersInvisible()) {
00507           oss << "true";
00508         } else {
00509           oss << "false";
00510         }
00511         break;
00512       case G4ModelingParameters::VASColour:
00513         oss << "\n/vis/touchable/set/colour "
00514         << c.GetRed()
00515         << ' ' << c.GetGreen()
00516         << ' ' << c.GetBlue()
00517         << ' ' << c.GetAlpha();
00518         break;
00519       case G4ModelingParameters::VASLineStyle:
00520         oss << "\n/vis/touchable/set/lineStyle ";
00521         switch (vamVisAtts.GetLineStyle()) {
00522           case G4VisAttributes::unbroken:
00523             oss << "unbroken";
00524             break;
00525           case G4VisAttributes::dashed:
00526             oss << "dashed";
00527             break;
00528           case G4VisAttributes::dotted:
00529           oss << "dotted";
00530         }
00531         break;
00532       case G4ModelingParameters::VASLineWidth:
00533         oss << "\n/vis/touchable/set/lineWidth "
00534         << vamVisAtts.GetLineWidth();
00535         break;
00536       case G4ModelingParameters::VASForceWireframe:
00537         if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
00538           oss << "\n/vis/touchable/set/forceWireframe ";
00539           if (vamVisAtts.IsForceDrawingStyle()) {
00540             oss << "true";
00541           } else {
00542             oss << "false";
00543           }
00544         }
00545         break;
00546       case G4ModelingParameters::VASForceSolid:
00547         if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
00548           oss << "\n/vis/touchable/set/forceSolid ";
00549           if (vamVisAtts.IsForceDrawingStyle()) {
00550             oss << "true";
00551           } else {
00552             oss << "false";
00553           }
00554         }
00555         break;
00556       case G4ModelingParameters::VASForceAuxEdgeVisible:
00557         oss << "\n/vis/touchable/set/forceAuxEdgeVisible ";
00558         if (vamVisAtts.IsForceAuxEdgeVisible()) {
00559           oss << "true";
00560         } else {
00561           oss << "false";
00562         }
00563         break;
00564       case G4ModelingParameters::VASForceLineSegmentsPerCircle:
00565         oss << "\n/vis/touchable/set/lineSegmentsPerCircle "
00566         << vamVisAtts.GetForcedLineSegmentsPerCircle();
00567         break;
00568     }
00569   }
00570   
00571   oss << std::endl;
00572   
00573   return oss.str();
00574 }

void G4ViewParameters::UnsetExplodeFactor (  )  [inline]

Definition at line 277 of file G4ViewParameters.icc.

00277                                                   {
00278   fExplodeFactor = 1.;
00279 }

void G4ViewParameters::UnsetSectionPlane (  )  [inline]

Definition at line 254 of file G4ViewParameters.icc.

Referenced by G4VisCommandsViewerSet::SetNewValue().

00254                                                  {
00255   fSection = false;
00256 }

Friends And Related Function Documentation

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

Definition at line 660 of file G4ViewParameters.cc.

00660                                                                     {
00661   os << "View parameters and options:";
00662 
00663   os << "\n  Drawing style: ";
00664   switch (v.fDrawingStyle) {
00665   case G4ViewParameters::wireframe:
00666     os << "edges, wireframe"; break;
00667   case G4ViewParameters::hlr:
00668     os << "edges, hidden line removal"; break;
00669   case G4ViewParameters::hsr:
00670     os << "surfaces, hidden surface removal"; break;
00671   case G4ViewParameters::hlhsr:
00672     os << "surfaces and edges, hidden line and surface removal"; break;
00673   default: os << "unrecognised"; break;
00674   }
00675 
00676   os << "\n  Auxiliary edges: ";
00677   if (!v.fAuxEdgeVisible) os << "in";
00678   os << "visible";
00679 
00680   os << "\n  Representation style: ";
00681   switch (v.fRepStyle) {
00682   case G4ViewParameters::polyhedron:
00683     os << "polyhedron"; break;
00684   case G4ViewParameters::nurbs:
00685     os << "nurbs"; break;
00686   default: os << "unrecognised"; break;
00687   }
00688 
00689   os << "\n  Culling: ";
00690   if (v.fCulling) os << "on";
00691   else            os << "off";
00692 
00693   os << "\n  Culling invisible objects: ";
00694   if (v.fCullInvisible) os << "on";
00695   else                  os << "off";
00696 
00697   os << "\n  Density culling: ";
00698   if (v.fDensityCulling) {
00699     os << "on - invisible if density less than "
00700        << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
00701   }
00702   else os << "off";
00703 
00704   os << "\n  Culling daughters covered by opaque mothers: ";
00705   if (v.fCullCovered) os << "on";
00706   else                os << "off";
00707 
00708   os << "\n  Section flag: ";
00709   if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
00710   else            os << "false";
00711 
00712   if (v.IsCutaway()) {
00713     os << "\n  Cutaway planes: ";
00714     for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
00715       os << ' ' << v.fCutawayPlanes[i];
00716     }
00717   }
00718   else {
00719     os << "\n  No cutaway planes";
00720   }
00721 
00722   os << "\n  Explode factor: " << v.fExplodeFactor
00723      << " about centre: " << v.fExplodeCentre;
00724 
00725   os << "\n  No. of sides used in circle polygon approximation: "
00726      << v.fNoOfSides;
00727 
00728   os << "\n  Viewpoint direction:  " << v.fViewpointDirection;
00729 
00730   os << "\n  Up vector:            " << v.fUpVector;
00731 
00732   os << "\n  Field half angle:     " << v.fFieldHalfAngle;
00733 
00734   os << "\n  Zoom factor:          " << v.fZoomFactor;
00735 
00736   os << "\n  Scale factor:         " << v.fScaleFactor;
00737 
00738   os << "\n  Current target point: " << v.fCurrentTargetPoint;
00739 
00740   os << "\n  Dolly distance:       " << v.fDolly;
00741 
00742   os << "\n  Light ";
00743   if (v.fLightsMoveWithCamera) os << "moves";
00744   else                         os << "does not move";
00745   os << " with camera";
00746 
00747   os << "\n  Relative lightpoint direction: "
00748      << v.fRelativeLightpointDirection;
00749 
00750   os << "\n  Actual lightpoint direction: "
00751      << v.fActualLightpointDirection;
00752 
00753   os << "\n  Derived parameters for standard view of object of unit radius:";
00754   G4ViewParameters tempVP = v;
00755   tempVP.fDolly = 0.;
00756   tempVP.fZoomFactor = 1.;
00757   const G4double radius = 1.;
00758   const G4double cameraDistance = tempVP.GetCameraDistance (radius);
00759   const G4double nearDistance =
00760     tempVP.GetNearDistance (cameraDistance, radius);
00761   const G4double farDistance =
00762     tempVP.GetFarDistance  (cameraDistance, nearDistance, radius);
00763   const G4double right  = tempVP.GetFrontHalfHeight (nearDistance, radius);
00764   os << "\n    Camera distance:   " << cameraDistance;
00765   os << "\n    Near distance:     " << nearDistance;
00766   os << "\n    Far distance:      " << farDistance;
00767   os << "\n    Front half height: " << right;
00768 
00769   os << "\n  Default VisAttributes:\n  " << v.fDefaultVisAttributes;
00770 
00771   os << "\n  Default TextVisAttributes:\n  " << v.fDefaultTextVisAttributes;
00772 
00773   os << "\n  Default marker: " << v.fDefaultMarker;
00774 
00775   os << "\n  Global marker scale: " << v.fGlobalMarkerScale;
00776 
00777   os << "\n  Global lineWidth scale: " << v.fGlobalLineWidthScale;
00778 
00779   os << "\n  Marker ";
00780   if (v.fMarkerNotHidden) os << "not ";
00781   os << "hidden by surfaces.";
00782 
00783   os << "\n  Window size hint: "
00784      << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
00785 
00786   os << "\n  X geometry string: " << v.fXGeometryString;
00787   os << "\n  X geometry mask: "
00788      << std::showbase << std::hex << v.fGeometryMask
00789      << std::noshowbase << std::dec;
00790 
00791   os << "\n  Auto refresh: ";
00792   if (v.fAutoRefresh) os << "true";
00793   else os << "false";
00794 
00795   os << "\n  Background colour: " << v.fBackgroundColour;
00796 
00797   os << "\n  Picking requested: ";
00798   if (v.fPicking) os << "true";
00799   else os << "false";
00800 
00801   os << "\n  Rotation style: ";
00802   switch (v.fRotationStyle) {
00803   case G4ViewParameters::constrainUpDirection:
00804     os << "constrainUpDirection (conventional HEP view)"; break;
00805   case G4ViewParameters::freeRotation:
00806     os << "freeRotation (Google-like rotation, using mouse-grab)"; break;
00807   default: os << "unrecognised"; break;
00808   }
00809 
00810   os << "\n  Vis attributes modifiers: ";
00811   const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
00812     v.fVisAttributesModifiers;
00813   if (vams.empty()) {
00814     os << "None";
00815   } else {
00816     os << vams;
00817   }
00818 
00819   return os;
00820 }

std::ostream& operator<< ( std::ostream &  ,
const DrawingStyle &   
) [friend]

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:44 2013 for Geant4 by  doxygen 1.4.7