source: trunk/geant4/visualization/management/src/G4ViewParameters.cc @ 656

Last change on this file since 656 was 593, checked in by garnier, 17 years ago

r627@mac-90108: laurentgarnier | 2007-11-09 07:57:42 +0100
modif dans les includes directives
  • Property svn:mime-type set to text/cpp
File size: 18.1 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27// $Id: G4ViewParameters.cc,v 1.29 2007/04/03 13:33:16 allison Exp $
28// GEANT4 tag $Name: geant4-09-00-ref-01 $
29//
30//
31// John Allison  19th July 1996
32// View parameters and options.
33
34#include "G4ViewParameters.hh"
35
36#include "G4VisManager.hh"
37#include "G4UnitsTable.hh"
38#include "G4ios.hh"
39
40G4ViewParameters::G4ViewParameters ():
41  fDrawingStyle (wireframe),
42  fAuxEdgeVisible (false),
43  fRepStyle (polyhedron),
44  fCulling (true),
45  fCullInvisible (true),
46  fDensityCulling (false),
47  fVisibleDensity (0.01 * g / cm3),
48  fCullCovered (false),
49  fSection (false),
50  fSectionPlane (),
51  fCutawayMode (cutawayUnion),
52  fCutawayPlanes (),
53  fExplodeFactor (1.),
54  fNoOfSides (24),
55  fViewpointDirection (G4Vector3D (0., 0., 1.)),  // On z-axis.
56  fUpVector (G4Vector3D (0., 1., 0.)),            // y-axis up.
57  fFieldHalfAngle (0.),                           // Orthogonal projection.
58  fZoomFactor (1.),
59  fScaleFactor (G4Vector3D (1., 1., 1.)),
60  fCurrentTargetPoint (),
61  fDolly (0.),
62  fLightsMoveWithCamera (false),
63  fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
64  fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
65  fDefaultVisAttributes (),
66  fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
67  fDefaultMarker (),
68  fGlobalMarkerScale (1.),
69  fGlobalLineWidthScale (1.),
70  fMarkerNotHidden (true),
71  fWindowSizeHintX (600),
72  fWindowSizeHintY (600),
73  fAutoRefresh (false),
74  fBackgroundColour (G4Colour(0.,0.,0.)),         // Black
75  fPicking (false)
76{
77  fDefaultMarker.SetScreenSize (5.);
78  // Markers are 5 pixels "overall" size, i.e., diameter.
79}
80
81G4ViewParameters::~G4ViewParameters () {}
82
83void G4ViewParameters::MultiplyScaleFactor
84(const G4Vector3D& scaleFactorMultiplier) {
85  fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
86  fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
87  fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
88}
89
90G4Vector3D& G4ViewParameters::GetActualLightpointDirection () {
91  SetViewAndLights (fViewpointDirection);
92  return fActualLightpointDirection;
93}
94
95// Useful quantities - begin snippet.
96// Here Follow functions to evaluate the above algorithms as a
97// function of the radius of the Bounding Sphere of the object being
98// viewed.  Call them in the order given - for efficiency, later
99// functions depend on the results of earlier ones (Store the
100// results of earlier functions in your own temporary variables -
101// see, for example, G4OpenGLView::SetView ().)
102
103G4double G4ViewParameters::GetCameraDistance (G4double radius) const {
104  G4double cameraDistance;
105  if (fFieldHalfAngle == 0.) {
106    cameraDistance = radius;
107  }
108  else {
109    cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
110  }
111  return cameraDistance;
112}
113
114G4double G4ViewParameters::GetNearDistance (G4double cameraDistance,
115                                            G4double radius) const {
116  const G4double small = 1.e-6 * radius;
117  G4double nearDistance = cameraDistance - radius;
118  if (nearDistance < small) nearDistance = small;
119  return nearDistance;
120}
121
122G4double G4ViewParameters::GetFarDistance (G4double cameraDistance,
123                                           G4double nearDistance,
124                                           G4double radius) const {
125  G4double farDistance = cameraDistance + radius;
126  if (farDistance < nearDistance) farDistance = nearDistance;
127  return farDistance;
128}
129
130G4double G4ViewParameters::GetFrontHalfHeight (G4double nearDistance,
131                                               G4double radius) const {
132  G4double frontHalfHeight;
133  if (fFieldHalfAngle == 0.) {
134    frontHalfHeight = radius / fZoomFactor;
135  }
136  else {
137    frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
138  }
139  return frontHalfHeight;
140}
141// Useful quantities - end snippet.
142
143void G4ViewParameters::AddCutawayPlane (const G4Plane3D& cutawayPlane) {
144  if (fCutawayPlanes.size () < 3 ) {
145    fCutawayPlanes.push_back (cutawayPlane);
146  }
147  else {
148    G4cout <<
149      "ERROR: G4ViewParameters::AddCutawayPlane:"
150      "\n  A maximum of 3 cutaway planes supported." << G4endl;
151  }
152}
153
154void G4ViewParameters::ChangeCutawayPlane
155(size_t index, const G4Plane3D& cutawayPlane) {
156  if (index >= fCutawayPlanes.size()) {
157    G4cout <<
158      "ERROR: G4ViewParameters::ChangeCutawayPlane:"
159      "\n  Plane " << index << " does not exist." << G4endl;
160  } else {
161    fCutawayPlanes[index] = cutawayPlane;
162  }
163}
164
165void G4ViewParameters::SetVisibleDensity (G4double visibleDensity) {
166  const G4double reasonableMaximum = 10.0 * g / cm3;
167  if (visibleDensity < 0) {
168    G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
169      "density - ignored." << G4endl;
170  }
171  else {
172    if (visibleDensity > reasonableMaximum) {
173      G4cout << "G4ViewParameters::SetVisibleDensity: density > "
174             << G4BestUnit (reasonableMaximum, "Volumic Mass")
175             << " - did you mean this?"
176             << G4endl;
177    }
178    fVisibleDensity = visibleDensity;
179  }
180}
181
182G4int G4ViewParameters::SetNoOfSides (G4int nSides) {
183  const G4int  nSidesMin = 12;
184  if (nSides < nSidesMin) {
185    nSides = nSidesMin;
186    G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
187      "\nnumber of sides per circle < " << nSidesMin
188         << "; forced to " << nSides << G4endl;
189  }
190  fNoOfSides = nSides;
191  return fNoOfSides;
192}
193
194void G4ViewParameters::SetViewAndLights
195(const G4Vector3D& viewpointDirection) {
196
197  fViewpointDirection = viewpointDirection;
198
199  // If the requested viewpoint direction is parallel to the up
200  // vector, the orientation of the view is undefined...
201  if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
202    G4cout <<
203      "WARNING: Viewpoint direction is very close to the up vector direction."
204      "\n  Consider setting the up vector to obtain definable behaviour."
205           << G4endl;
206  }
207
208  // Move the lights too if requested...
209  if (fLightsMoveWithCamera) {
210    G4Vector3D zprime = fViewpointDirection.unit ();
211    G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
212    G4Vector3D yprime = zprime.cross (xprime);
213    fActualLightpointDirection =
214      fRelativeLightpointDirection.x () * xprime +
215      fRelativeLightpointDirection.y () * yprime +
216      fRelativeLightpointDirection.x () * zprime;     
217  } else {
218    fActualLightpointDirection = fRelativeLightpointDirection;
219  }
220}
221
222void G4ViewParameters::SetLightpointDirection
223(const G4Vector3D& lightpointDirection) {
224  fRelativeLightpointDirection = lightpointDirection;
225  SetViewAndLights (fViewpointDirection);
226}
227
228void G4ViewParameters::SetPan (G4double right, G4double up) {
229  G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
230  G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
231  fCurrentTargetPoint  = right * unitRight + up * unitUp;
232}
233
234void G4ViewParameters::IncrementPan (G4double right, G4double up) {
235  G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
236  G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
237  fCurrentTargetPoint += right * unitRight + up * unitUp;
238}
239
240void G4ViewParameters::PrintDifferences (const G4ViewParameters& v) const {
241
242  // Put performance-sensitive parameters first.
243  if (
244      // This first to optimise spin, etc.
245      (fViewpointDirection   != v.fViewpointDirection)   ||
246
247      // No particular order from here on.
248      (fDrawingStyle         != v.fDrawingStyle)         ||
249      (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
250      (fRepStyle             != v.fRepStyle)             ||
251      (fCulling              != v.fCulling)              ||
252      (fCullInvisible        != v.fCullInvisible)        ||
253      (fDensityCulling       != v.fDensityCulling)       ||
254      (fVisibleDensity       != v.fVisibleDensity)       ||
255      (fCullCovered          != v.fCullCovered)          ||
256      (fSection              != v.fSection)              ||
257      (fNoOfSides            != v.fNoOfSides)            ||
258      (fUpVector             != v.fUpVector)             ||
259      (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
260      (fZoomFactor           != v.fZoomFactor)           ||
261      (fScaleFactor          != v.fScaleFactor)          ||
262      (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
263      (fDolly                != v.fDolly)                ||
264      (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
265      (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
266      (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
267      (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
268      (fDefaultMarker        != v.fDefaultMarker)        ||
269      (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
270      (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
271      (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
272      (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
273      (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
274      (fXGeometryString      != v.fXGeometryString)      ||
275      (fAutoRefresh          != v.fAutoRefresh)          ||
276      (fBackgroundColour     != v.fBackgroundColour)     ||
277      (fPicking              != v.fPicking)
278      )
279    G4cout << "Difference in 1st batch." << G4endl;
280
281  if (fSection) {
282    if (!(fSectionPlane == v.fSectionPlane))
283      G4cout << "Difference in section planes batch." << G4endl;
284  }
285
286  if (IsCutaway()) {
287    if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
288      G4cout << "Difference in no of cutaway planes." << G4endl;
289    }
290    else {
291      for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
292        if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
293          G4cout << "Difference in cutaway plane no. " << i << G4endl;
294      }
295    }
296  }
297
298  if (IsExplode()) {
299    if (fExplodeFactor != v.fExplodeFactor)
300      G4cout << "Difference in explode factor." << G4endl;
301    if (fExplodeCentre != v.fExplodeCentre)
302      G4cout << "Difference in explode centre." << G4endl;
303  }
304}
305
306std::ostream& operator << (std::ostream& os,
307                             const G4ViewParameters::DrawingStyle& style) {
308  switch (style) {
309  case G4ViewParameters::wireframe:
310    os << "wireframe"; break;
311  case G4ViewParameters::hlr:
312    os << "hlr - hidden lines removed"; break;
313  case G4ViewParameters::hsr:
314    os << "hsr - hidden surfaces removed"; break;
315  case G4ViewParameters::hlhsr:
316    os << "hlhsr - hidden line, hidden surface removed"; break;
317  default: os << "unrecognised"; break;
318  }
319  return os;
320}
321
322std::ostream& operator << (std::ostream& os, const G4ViewParameters& v) {
323  os << "View parameters and options:";
324
325  os << "\n  Drawing style: " << v.fDrawingStyle;
326
327  os << "\n  Auxiliary edges: ";
328  if (!v.fAuxEdgeVisible) os << "in";
329  os << "visible";
330
331  os << "\n  Representation style: ";
332  switch (v.fRepStyle) {
333  case G4ViewParameters::polyhedron:
334    os << "polyhedron"; break;
335  case G4ViewParameters::nurbs:
336    os << "nurbs"; break;
337  default: os << "unrecognised"; break;
338  }
339
340  os << "\n  Culling: ";
341  if (v.fCulling) os << "on";
342  else            os << "off";
343
344  os << "\n  Culling invisible objects: ";
345  if (v.fCullInvisible) os << "on";
346  else                  os << "off";
347
348  os << "\n  Density culling: ";
349  if (v.fDensityCulling) {
350    os << "on - invisible if density less than "
351       << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
352  }
353  else os << "off";
354
355  os << "\n  Culling daughters covered by opaque mothers: ";
356  if (v.fCullCovered) os << "on";
357  else                os << "off";
358
359  os << "\n  Section flag: ";
360  if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
361  else            os << "false";
362
363  if (v.IsCutaway()) {
364    os << "\n  Cutaway planes: ";
365    for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
366      os << ' ' << v.fCutawayPlanes[i];
367    }
368  }
369  else {
370    os << "\n  No cutaway planes";
371  }
372
373  os << "\n  Explode factor: " << v.fExplodeFactor
374     << " about centre: " << v.fExplodeCentre;
375
376  os << "\n  No. of sides used in circle polygon approximation: "
377     << v.fNoOfSides;
378
379  os << "\n  Viewpoint direction:  " << v.fViewpointDirection;
380
381  os << "\n  Up vector:            " << v.fUpVector;
382
383  os << "\n  Field half angle:     " << v.fFieldHalfAngle;
384
385  os << "\n  Zoom factor:          " << v.fZoomFactor;
386
387  os << "\n  Scale factor:         " << v.fScaleFactor;
388
389  os << "\n  Current target point: " << v.fCurrentTargetPoint;
390
391  os << "\n  Dolly distance:       " << v.fDolly;
392
393  os << "\n  Light ";
394  if (v.fLightsMoveWithCamera) os << "moves";
395  else                         os << "does not move";
396  os << " with camera";
397
398  os << "\n  Relative lightpoint direction: "
399     << v.fRelativeLightpointDirection;
400
401  os << "\n  Actual lightpoint direction: "
402     << v.fActualLightpointDirection;
403
404  os << "\n  Derived parameters for standard view of object of unit radius:";
405  G4ViewParameters tempVP = v;
406  tempVP.fDolly = 0.;
407  tempVP.fZoomFactor = 1.;
408  const G4double radius = 1.;
409  const G4double cameraDistance = tempVP.GetCameraDistance (radius);
410  const G4double nearDistance =
411    tempVP.GetNearDistance (cameraDistance, radius);
412  const G4double farDistance =
413    tempVP.GetFarDistance  (cameraDistance, nearDistance, radius);
414  const G4double right  = tempVP.GetFrontHalfHeight (nearDistance, radius);
415  os << "\n    Camera distance:   " << cameraDistance;
416  os << "\n    Near distance:     " << nearDistance;
417  os << "\n    Far distance:      " << farDistance;
418  os << "\n    Front half height: " << right;
419
420  os << "\n  Default VisAttributes:\n  " << v.fDefaultVisAttributes;
421
422  os << "\n  Default TextVisAttributes:\n  " << v.fDefaultTextVisAttributes;
423
424  os << "\n  Default marker: " << v.fDefaultMarker;
425
426  os << "\n  Global marker scale: " << v.fGlobalMarkerScale;
427
428  os << "\n  Global lineWidth scale: " << v.fGlobalLineWidthScale;
429
430  os << "\n  Marker ";
431  if (v.fMarkerNotHidden) os << "not ";
432  os << "hidden by surfaces.";
433
434  os << "\n  Window size hint: "
435     << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
436
437  os << "\n  X geometry string: " << v.fXGeometryString;
438
439  os << "\n  Auto refresh: ";
440  if (v.fAutoRefresh) os << "true";
441  else os << "false";
442
443  os << "\n  Background colour: " << v.fBackgroundColour;
444
445  os << "\n  Picking requested: ";
446  if (v.fPicking) os << "true";
447  else os << "false";
448
449  return os;
450}
451
452G4bool G4ViewParameters::operator != (const G4ViewParameters& v) const {
453
454  // Put performance-sensitive parameters first.
455  if (
456      // This first to optimise spin, etc.
457      (fViewpointDirection   != v.fViewpointDirection)   ||
458
459      // No particular order from here on.
460      (fDrawingStyle         != v.fDrawingStyle)         ||
461      (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
462      (fRepStyle             != v.fRepStyle)             ||
463      (fCulling              != v.fCulling)              ||
464      (fCullInvisible        != v.fCullInvisible)        ||
465      (fDensityCulling       != v.fDensityCulling)       ||
466      (fCullCovered          != v.fCullCovered)          ||
467      (fSection              != v.fSection)              ||
468      (IsCutaway()           != v.IsCutaway())           ||
469      (IsExplode()           != v.IsExplode())           ||
470      (fNoOfSides            != v.fNoOfSides)            ||
471      (fUpVector             != v.fUpVector)             ||
472      (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
473      (fZoomFactor           != v.fZoomFactor)           ||
474      (fScaleFactor          != v.fScaleFactor)          ||
475      (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
476      (fDolly                != v.fDolly)                ||
477      (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
478      (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
479      (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
480      (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
481      (fDefaultMarker        != v.fDefaultMarker)        ||
482      (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
483      (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
484      (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
485      (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
486      (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
487      (fXGeometryString      != v.fXGeometryString)      ||
488      (fAutoRefresh          != v.fAutoRefresh)          ||
489      (fBackgroundColour     != v.fBackgroundColour)     ||
490      (fPicking              != v.fPicking)
491      )
492    return true;
493
494  if (fDensityCulling &&
495      (fVisibleDensity != v.fVisibleDensity)) return true;
496
497  if (fSection &&
498      (!(fSectionPlane == v.fSectionPlane))) return true;
499
500  if (IsCutaway()) {
501    if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
502      return true;
503    else {
504      for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
505        if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
506      }
507    }
508  }
509
510  if (IsExplode() &&
511      (fExplodeFactor != v.fExplodeFactor) ||
512      (fExplodeCentre != v.fExplodeCentre)) return true;
513
514  return false;
515}
Note: See TracBrowser for help on using the repository browser.