source: trunk/Documentation/geant4/UserDocumentation/UsersGuides/ForApplicationDeveloper/html/ch08s05.html @ 901

Last change on this file since 901 was 901, checked in by garnier, 16 years ago

Add Geant4 Documentation at 8.12.2008
File size: 26.8 KB
Line 
1<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>8.5.  Controlling Visualization from Compiled Code</title><link rel="stylesheet" href="../xml/XSLCustomizationLayer/G4HTMLStylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.71.1"><link rel="start" href="index.html" title="Geant4 User's Guide for Application Developers"><link rel="up" href="ch08.html" title="Chapter 8.  Visualization"><link rel="prev" href="ch08s04.html" title="8.4.  Controlling Visualization from Commands"><link rel="next" href="ch08s06.html" title="8.6.  Visualization Attributes"><script language="JavaScript">
2function remote_win(fName)
3{
4   var url = "AllResources/Detector/geometry.src/" + fName;
5   RemoteWin=window.open(url,"","resizable=no,toolbar=0,location=0,directories=0,status=0,menubar=0,scrollbars=0,copyhistory=0,width=520,height=520")
6   RemoteWin.creator=self
7}
8</script></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">8.5. 
9Controlling Visualization from Compiled Code
10</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch08s04.html"><img src="AllResources/IconsGIF/prev.gif" alt="Prev"></a> </td><th width="60%" align="center">Chapter 8. 
11Visualization
12</th><td width="20%" align="right"> <a accesskey="n" href="ch08s06.html"><img src="AllResources/IconsGIF/next.gif" alt="Next"></a></td></tr></table><hr></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="sect.VisCntCmpl"></a>8.5. 
13Controlling Visualization from Compiled Code
14</h2></div></div></div><p>
15While a Geant4 simulation is running, visualization can be
16performed without user intervention. This is accomplished by
17calling methods of the Visualization Manager from methods of the
18user action classes (<span class="emphasis"><em>G4UserRunAction</em></span> and
19<span class="emphasis"><em>G4UserEventAction</em></span>, for example). In this section methods of
20the class <span class="emphasis"><em>G4VVisManager</em></span>, which is part of the
21<code class="literal">graphics_reps</code> category, are described and examples of
22their use are given.
23</p><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.VsMng"></a>8.5.1. 
24G4VVisManager
25</h3></div></div></div><p>
26The Visualization Manager is implemented by classes
27<span class="emphasis"><em>G4VisManager</em></span> and <span class="emphasis"><em>G4VisExecutive</em></span>.
28See <a href="ch08s02.html" title="8.2. 
29Adding Visualization to Your Executable
30">Section 8.2</a>
31"<span class="bold"><strong>Making a Visualization Executable</strong></span>". In order
32that your Geant4 be compilable either with or without the visualization
33category, you should not use these classes directly in your C++
34source code, other than in the <code class="literal">main()</code> function. Instead,
35you should use their abstract base class <span class="emphasis"><em>G4VVisManager</em></span>,
36defined in the <code class="literal">intercoms</code> category.
37</p><p>
38The pointer to the concrete instance of the real Visualization
39Manager can be obtained as follows:
40
41</p><div class="informalexample"><pre class="programlisting">
42  //----- Getting a pointer to the concrete Visualization Manager instance
43  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
44</pre></div><p> 
45</p><p>
46The method <code class="literal">G4VVisManager::GetConcreteInstance()</code> returns
47<code class="literal">NULL</code> if Geant4 is not ready for visualization. Thus your
48C++ source code should be protected as follows:
49
50</p><div class="informalexample"><pre class="programlisting">
51  //----- How to protect your C++ source codes in visualization
52  if (pVVisManager) {
53      ....
54      pVVisManager -&gt;Draw (...);
55      ....
56  }
57</pre></div><p> 
58</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.DtcCmp"></a>8.5.2. 
59Visualization of detector components
60</h3></div></div></div><p>
61If you have already constructed detector components with logical
62volumes to which visualization attributes are properly assigned,
63you are almost ready for visualizing detector components. All you
64have to do is to describe proper visualization commands within your
65C++ codes, using the <code class="literal">ApplyCommand()</code> method.
66</p><p>
67For example, the following is sample C++ source codes to
68visualize the detector components:
69
70</p><div class="informalexample"><pre class="programlisting">
71  //----- C++ source code: How to visualize detector components (2)
72  //                       ... using visualization commands in source codes
73 
74  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance() ;
75
76  if(pVVisManager)
77  {
78      ... (camera setting etc) ...
79      G4UImanager::GetUIpointer()-&gt;ApplyCommand("/vis/drawVolume");
80      G4UImanager::GetUIpointer()-&gt;ApplyCommand("/vis/viewer/flush");
81  }
82
83  //-----  end of C++ source code
84 
85</pre></div><p>
86</p><p>
87In the above, you should also describe <code class="literal">/vis/open</code> command
88somewhere in your C++ codes or execute the command from (G)UI at
89the executing stage.
90</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.Trjct"></a>8.5.3. 
91Visualization of trajectories
92</h3></div></div></div><p>
93In order to visualize trajectories, you can use the method <code class="literal">void
94G4Trajectory::DrawTrajectory()</code> defined in the tracking
95category. In the implementation of this method, the following
96drawing method of <span class="emphasis"><em>G4VVisManager</em></span> is used:
97
98</p><div class="informalexample"><pre class="programlisting">
99    //----- A drawing method of G4Polyline
100    virtual void G4VVisManager::Draw (const G4Polyline&amp;, ...) ;
101</pre></div><p>
102</p><p>
103The real implementation of this method is described in the class
104<span class="emphasis"><em>G4VisManager</em></span>.
105</p><p>
106At the end of one event, a set of trajectories can be stored as
107a list of <span class="emphasis"><em>G4Trajectory</em></span> objects. Therefore you can visualize
108trajectories, for example, at the end of each event, by
109implementing the method <code class="literal">MyEventAction::EndOfEventAction()</code>
110as follows:
111
112</p><div class="informalexample"><pre class="programlisting">
113  //----- C++ source codes
114  void ExN03EventAction::EndOfEventAction(const G4Event* evt)
115  {
116    ..... 
117    // extract the trajectories and draw them
118    if (G4VVisManager::GetConcreteInstance())
119      {
120       G4TrajectoryContainer* trajectoryContainer = evt-&gt;GetTrajectoryContainer();
121       G4int n_trajectories = 0;
122       if (trajectoryContainer) n_trajectories = trajectoryContainer-&gt;entries();
123 
124       for (G4int i=0; i &lt; n_trajectories; i++)
125          { G4Trajectory* trj=(G4Trajectory*)((*(evt-&gt;GetTrajectoryContainer()))[i]);
126            if (drawFlag == "all") trj-&gt;DrawTrajectory(50);
127            else if ((drawFlag == "charged")&amp;&amp;(trj-&gt;GetCharge() != 0.))
128                                    trj-&gt;DrawTrajectory(50);
129            else if ((drawFlag == "neutral")&amp;&amp;(trj-&gt;GetCharge() == 0.))
130                                    trj-&gt;DrawTrajectory(50);
131          }
132    }
133  } 
134  //----- end of C++ source codes
135</pre></div><p>
136</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.EnhTrjct"></a>8.5.4. 
137Enhanced trajectory drawing
138</h3></div></div></div><p>
139It is possible to use the enhanced trajectory drawing functionality
140in compiled code as well as from commands. Multiple trajectory
141models can be instantiated, configured and registered with
142G4VisManager. For details, see the section on
143<a href="ch08s07.html#sect.VisEnhTrj.CntlCmpl" title="8.7.4. 
144Controlling from Compiled Code
145">Section 8.7.4</a> 
146Enhanced Trajectory Drawing.
147</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.AttTrjct"></a>8.5.5. 
148HepRep Attributes for Trajectories
149</h3></div></div></div><p>
150The HepRep file formats, HepRepFile and HepRepXML, attach various
151attributes to trajectories such that you can view these attributes,
152label trajectories by these attributes or make visibility cuts
153based on these attributes. If you use the default Geant4 trajectory
154class, from /tracking/src/G4Trajectory.cc, available attributes
155will be:
156
157</p><div class="itemizedlist"><ul type="disc" compact><li><p>
158    Track ID
159  </p></li><li><p>
160    Parent ID
161  </p></li><li><p>
162    Particle Name
163  </p></li><li><p>
164    Charge
165  </p></li><li><p>
166    PDG Encoding
167  </p></li><li><p>
168    Momentum 3-Vector
169  </p></li><li><p>
170    Momentum magnitude
171  </p></li><li><p>
172    Number of points
173  </p></li></ul></div><p>
174</p><p>
175You can add additional attributes of your choosing by modifying the
176relevant part of G4Trajectory (look for the methods GetAttDefs and
177CreateAttValues). If you are using your own trajectory class, you
178may want to consider copying these methods from G4Trajectory.
179</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.Hits"></a>8.5.6. 
180Visualization of hits
181</h3></div></div></div><p>
182Hits are visualized with classes <span class="emphasis"><em>G4Square</em></span> or
183<span class="emphasis"><em>G4Circle</em></span>, or other user-defined classes inheriting the
184abstract base class <span class="emphasis"><em>G4VMarker</em></span>. Drawing methods for hits are
185not supported by default. Instead, ways of their implementation are
186guided by virtual methods, <code class="literal">G4VHit::Draw()</code> and
187<code class="literal">G4VHitsCollection::DrawAllHits()</code>, of the abstract base
188classes <span class="emphasis"><em>G4VHit</em></span> and <span class="emphasis"><em>G4VHitsCollection</em></span>.
189These methods are defined as empty functions in the <code class="literal">digits+hits</code>
190category. You can overload these methods, using the following
191drawing methods of class <span class="emphasis"><em>G4VVisManager</em></span>, in order to
192visualize hits:
193
194</p><div class="informalexample"><pre class="programlisting">
195  //----- Drawing methods of G4Square and G4Circle
196  virtual void G4VVisManager::Draw (const G4Circle&amp;, ...) ;
197  virtual void G4VVisManager::Draw (const G4Square&amp;, ...) ;
198</pre></div><p>
199</p><p>
200The real implementations of these <code class="literal">Draw()</code> methods are
201described in class <span class="emphasis"><em>G4VisManager</em></span>.
202</p><p>
203The overloaded implementation of <code class="literal">G4VHits::Draw()</code> will
204be held by, for example, class <span class="emphasis"><em>MyTrackerHits</em></span> inheriting
205<span class="emphasis"><em>G4VHit</em></span> as follows:
206
207</p><div class="informalexample"><pre class="programlisting">
208  //----- C++ source codes: An example of giving concrete implementation of
209  //       G4VHit::Draw(), using  class MyTrackerHit : public G4VHit {...}
210  //     
211 void MyTrackerHit::Draw()
212 {
213    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
214    if(pVVisManager)
215    {
216      // define a circle in a 3D space
217      G4Circle circle(pos);
218      circle.SetScreenSize(0.3);
219      circle.SetFillStyle(G4Circle::filled);
220
221      // make the circle red
222      G4Colour colour(1.,0.,0.);
223      G4VisAttributes attribs(colour);
224      circle.SetVisAttributes(attribs);
225
226      // make a 3D data for visualization
227      pVVisManager-&gt;Draw(circle);
228    }
229  }
230
231  //----- end of C++ source codes
232 
233</pre></div><p>
234</p><p>
235The overloaded implementation of
236<code class="literal">G4VHitsCollection::DrawAllHits()</code> will be held by, for
237example, class <span class="emphasis"><em>MyTrackerHitsCollection</em></span> inheriting class
238<span class="emphasis"><em>G4VHitsCollection</em></span> as follows:
239
240</p><div class="informalexample"><pre class="programlisting">
241  //----- C++ source codes: An example of giving concrete implementation of
242  //       G4VHitsCollection::Draw(),
243  //       using  class MyTrackerHit : public G4VHitsCollection{...}
244  //     
245  void MyTrackerHitsCollection::DrawAllHits()
246  {
247    G4int n_hit = theCollection.entries();
248    for(G4int i=0;i &lt; n_hit;i++)
249    {
250      theCollection[i].Draw();
251    }
252  }
253
254  //----- end of C++ source codes
255 
256</pre></div><p>
257</p><p>
258Thus, you can visualize hits as well as trajectories, for
259example, at the end of each event by implementing the method
260<code class="literal">MyEventAction::EndOfEventAction()</code> as follows:
261
262</p><div class="informalexample"><pre class="programlisting">
263  void MyEventAction::EndOfEventAction()
264  {
265    const G4Event* evt = fpEventManager-&gt;get_const_currentEvent();
266
267    G4SDManager * SDman = G4SDManager::get_SDMpointer();
268    G4String colNam;
269    G4int trackerCollID = SDman-&gt;get_collectionID(colNam="TrackerCollection");
270    G4int calorimeterCollID = SDman-&gt;get_collectionID(colNam="CalCollection");
271
272    G4TrajectoryContainer * trajectoryContainer = evt-&gt;get_trajectoryContainer();
273    G4int n_trajectories = 0;
274    if(trajectoryContainer)
275    { n_trajectories = trajectoryContainer-&gt;entries(); }
276
277    G4HCofThisEvent * HCE = evt-&gt;get_HCofThisEvent();
278    G4int n_hitCollection = 0;
279    if(HCE)
280    { n_hitCollection = HCE-&gt;get_capacity(); }
281 
282    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
283
284    if(pVVisManager)
285    {
286 
287      // Declare begininng of visualization
288      G4UImanager::GetUIpointer()-&gt;ApplyCommand("/vis/scene/notifyHandlers");
289
290      // Draw trajectories
291      for(G4int i=0; i &lt; n_trajectories; i++)
292      {
293          (*(evt-&gt;get_trajectoryContainer()))[i]-&gt;DrawTrajectory();
294      }
295
296      // Construct 3D data for hits
297      MyTrackerHitsCollection* THC
298        = (MyTrackerHitsCollection*)(HCE-&gt;get_HC(trackerCollID));
299      if(THC) THC-&gt;DrawAllHits();
300      MyCalorimeterHitsCollection* CHC
301        = (MyCalorimeterHitsCollection*)(HCE-&gt;get_HC(calorimeterCollID));
302      if(CHC) CHC-&gt;DrawAllHits();
303
304      // Declare end of visualization
305      G4UImanager::GetUIpointer()-&gt;ApplyCommand("/vis/viewer/update");
306   
307    }
308
309  }
310
311  //----- end of C++ codes
312 
313</pre></div><p>
314</p><p>
315You can re-visualize a physical volume, where a hit is detected,
316with a highlight color, in addition to the whole set of detector
317components. It is done by calling a drawing method of a physical
318volume directly. The method is:
319
320</p><div class="informalexample"><pre class="programlisting">
321
322  //----- Drawing methods of a physical volume
323  virtual void Draw (const G4VPhysicalVolume&amp;, ...) ;
324 
325</pre></div><p>
326</p><p>
327This method is, for example, called in a method
328<code class="literal">MyXXXHit::Draw()</code>, describing the visualization of hits
329with markers. The following is an example for this:
330
331</p><div class="informalexample"><pre class="programlisting">
332  //----- C++ source codes: An example of visualizing hits with
333  void MyCalorimeterHit::Draw()
334  {
335    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
336    if(pVVisManager)
337    {
338      G4Transform3D trans(rot,pos);
339      G4VisAttributes attribs;
340      G4LogicalVolume* logVol = pPhys-&gt;GetLogicalVolume();
341      const G4VisAttributes* pVA = logVol-&gt;GetVisAttributes();
342      if(pVA) attribs = *pVA;
343      G4Colour colour(1.,0.,0.);
344      attribs.SetColour(colour);
345      attribs.SetForceSolid(true);
346
347      //----- Re-visualization of a selected physical volume with red color
348      pVVisManager-&gt;Draw(*pPhys,attribs,trans);
349
350    }
351  }
352
353  //----- end of C++ codes
354 
355</pre></div><p>
356</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.AttHits"></a>8.5.7. 
357HepRep Attributes for Hits
358</h3></div></div></div><p>
359The HepRep file formats, HepRepFile and HepRepXML, attach various
360attributes to hits such that you can view these attributes, label
361trajectories by these attributes or make visibility cuts based on
362these attributes. Examples of adding HepRep attributes to hit
363classes can be found in examples /extended/analysis/A01 and
364/extended/runAndEvent/RE01.
365</p><p>
366For example, in example RE01's class RE01CalorimeterHit.cc,
367available attributes will be:
368
369</p><div class="itemizedlist"><ul type="disc" compact><li><p>
370    Hit Type
371  </p></li><li><p>
372    Track ID
373  </p></li><li><p>
374    Z Cell ID
375  </p></li><li><p>
376    Phi Cell ID
377  </p></li><li><p>
378    Energy Deposited
379  </p></li><li><p>
380    Energy Deposited by Track
381  </p></li><li><p>
382    Position
383  </p></li><li><p>
384    Logical Volume
385  </p></li></ul></div><p>
386</p><p>
387You can add additional attributes of your choosing by modifying the
388relevant part of the hit class (look for the methods GetAttDefs and
389CreateAttValues).
390</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.txt"></a>8.5.8. 
391Visualization of text
392</h3></div></div></div><p>
393In Geant4 Visualization, a text, i.e., a character string, is
394described by class <span class="emphasis"><em>G4Text</em></span> inheriting
395<span class="emphasis"><em>G4VMarker</em></span> as well as <span class="emphasis"><em>G4Square</em></span> 
396and <span class="emphasis"><em>G4Circle</em></span>. Therefore, the way to
397visualize text is the same as for hits. The corresponding drawing
398method of <span class="emphasis"><em>G4VVisManager</em></span> is:
399
400</p><div class="informalexample"><pre class="programlisting">
401  //----- Drawing methods of G4Text
402  virtual void G4VVisManager::Draw (const G4Text&amp;, ...);
403 
404</pre></div><p>
405</p><p>
406The real implementation of this method is described in class
407<span class="emphasis"><em>G4VisManager</em></span>.
408</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.PlyTrkStp"></a>8.5.9. 
409Visualization of polylines and tracking steps
410</h3></div></div></div><p>
411Polylines, i.e., sets of successive line segments, are described by
412class <span class="emphasis"><em>G4Polyline</em></span>. For <span class="emphasis"><em>G4Polyline</em></span>,
413the following drawing method of class <span class="emphasis"><em>G4VVisManager</em></span> 
414is prepared:
415
416</p><div class="informalexample"><pre class="programlisting">
417   //----- A drawing method of G4Polyline
418    virtual void G4VVisManager::Draw (const G4Polyline&amp;, ...) ;
419 
420</pre></div><p>
421</p><p>
422The real implementation of this method is described in class
423<span class="emphasis"><em>G4VisManager</em></span>.
424</p><p>
425Using this method, C++ source codes to visualize
426<span class="emphasis"><em>G4Polyline</em></span> are described as follows:
427
428</p><div class="informalexample"><pre class="programlisting">
429 //----- C++ source code: How to visualize a polyline
430  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
431 
432  if (pVVisManager) {
433      G4Polyline polyline ;
434   
435      ..... (C++ source codes to set vertex positions, color, etc)
436 
437      pVVisManager -&gt; Draw(polyline);
438   
439  }
440 
441  //----- end of C++ source codes
442 
443</pre></div><p>
444</p><p>
445Tracking steps are able to be visualized based on the above
446visualization of <span class="emphasis"><em>G4Polyline</em></span>. You can visualize tracking
447steps at each step automatically by writing a proper implementation
448of class <span class="emphasis"><em>MySteppingAction</em></span> inheriting
449<span class="emphasis"><em>G4UserSteppingAction</em></span>, and also with the help of the Run
450Manager.
451</p><p>
452First, you must implement a method,
453<code class="literal">MySteppingAction::UserSteppingAction()</code>. A typical
454implementation of this method is as follows:
455
456</p><div class="informalexample"><pre class="programlisting">
457  //----- C++ source code: An example of visualizing tracking steps
458  void MySteppingAction::UserSteppingAction()
459  {
460      G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
461
462      if (pVVisManager) {
463
464        //----- Get the Stepping Manager
465        const G4SteppingManager* pSM = GetSteppingManager();
466
467        //----- Define a line segment
468        G4Polyline polyline;
469        G4double charge = pSM-&gt;GetTrack()-&gt;GetDefinition()-&gt;GetPDGCharge();
470        G4Colour colour;
471        if      (charge &lt; 0.) colour = G4Colour(1., 0., 0.);
472        else if (charge &lt; 0.) colour = G4Colour(0., 0., 1.);
473        else                  colour = G4Colour(0., 1., 0.);
474        G4VisAttributes attribs(colour);
475        polyline.SetVisAttributes(attribs);
476        polyline.push_back(pSM-&gt;GetStep()-&gt;GetPreStepPoint()-&gt;GetPosition());
477        polyline.push_back(pSM-&gt;GetStep()-&gt;GetPostStepPoint()-&gt;GetPosition());
478
479        //----- Call a drawing method for G4Polyline
480        pVVisManager -&gt; Draw(polyline);
481     
482      }
483  }
484
485  //----- end of C++ source code
486 
487</pre></div><p>
488</p><p>
489Next, in order that the above C++ source code works, you have to
490pass the information of the <span class="emphasis"><em>MySteppingAction</em></span> to the Run
491Manager in the <code class="literal">main()</code> function:
492
493</p><div class="informalexample"><pre class="programlisting">
494 
495  //----- C++ source code: Passing what to do at each step to the Run Manager
496
497  int main()
498  {
499     ...
500 
501     // Run Manager
502     G4RunManager * runManager = new G4RunManager;
503
504     // User initialization classes
505     ...
506     runManager-&gt;SetUserAction(new MySteppingAction);
507     ...
508  }
509
510  //----- end of C++ source code
511 
512</pre></div><p>
513</p><p>
514Thus you can visualize tracking steps with various visualization
515attributes, e.g., color, at each step, automatically.
516</p><p>
517As well as tracking steps, you can visualize any kind 3D object
518made of line segments, using class <span class="emphasis"><em>G4Polyline</em></span> and its
519drawing method, defined in class <span class="emphasis"><em>G4VVisManager</em></span>. See, for
520example, the implementation of the <code class="literal">/vis/scene/add/axes</code>
521command.
522</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.UsrAct"></a>8.5.10. 
523Visualization User Action
524</h3></div></div></div><p>
525You can implement the <code class="literal">Draw</code> method of
526<code class="literal">G4VUserVisAction</code>, e.g., the class definition could be:
527
528</p><div class="informalexample"><pre class="programlisting">
529class StandaloneVisAction: public G4VUserVisAction {
530  void Draw();
531};
532</pre></div><p>
533
534and the implementation:
535
536</p><div class="informalexample"><pre class="programlisting">
537void StandaloneVisAction::Draw() {
538  G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
539  if (pVisManager) {
540
541    // Simple box...
542    pVisManager-&gt;Draw(G4Box("box",2*m,2*m,2*m),
543                      G4VisAttributes(G4Colour(1,1,0)));
544
545    // Boolean solid...
546    G4Box boxA("boxA",3*m,3*m,3*m);
547    G4Box boxB("boxB",1*m,1*m,1*m);
548    G4SubtractionSolid subtracted("subtracted_boxes",&amp;boxA,&amp;boxB,
549                       G4Translate3D(3*m,3*m,3*m));
550    pVisManager-&gt;Draw(subtracted,
551                      G4VisAttributes(G4Colour(0,1,1)),
552                      G4Translate3D(6*m,6*m,6*m));
553  }
554}
555</pre></div><p>
556</p><p>
557Explicit use of polyhedron objects is equivalent, e.g.:
558
559</p><div class="informalexample"><pre class="programlisting">
560
561    // Same, but explicit polyhedron...
562    G4Polyhedron* pA = G4Box("boxA",3*m,3*m,3*m).CreatePolyhedron();
563    G4Polyhedron* pB = G4Box("boxB",1*m,1*m,1*m).CreatePolyhedron();
564    pB-&gt;Transform(G4Translate3D(3*m,3*m,3*m));
565    G4Polyhedron* pSubtracted = new G4Polyhedron(pA-&gt;subtract(*pB));
566    G4VisAttributes subVisAtts(G4Colour(0,1,1));
567    pSubtracted-&gt;SetVisAttributes(&amp;subVisAtts);
568    pVisManager-&gt;Draw(*pSubtracted,G4Translate3D(6*m,6*m,6*m));
569    delete pA;
570    delete pB;
571    delete pSubtracted;
572</pre></div><p>
573</p><p>
574If efficiency is an issue, create the objects in the constructor,
575delete them in the destructor and draw them in your <code class="literal">Draw</code>
576method. Anyway, an instance of your class needs to be registered
577with the vis manager, e.g.:
578
579</p><div class="informalexample"><pre class="programlisting">
580  ...
581  G4VisManager* visManager = new G4VisExecutive;
582  visManager-&gt;Initialize ();
583
584  visManager-&gt;SetUserAction
585    (new StandaloneVisAction,
586     G4VisExtent(-5*m,5*m,-5*m,5*m,-5*m,5*m));  // 2nd argument optional.
587  ...
588</pre></div><p>
589
590then activate by adding to a scene, e.g:
591
592</p><div class="informalexample"><pre class="programlisting">
593/control/verbose 2
594/vis/verbose c
595/vis/open OGLSXm
596/vis/scene/create
597#/vis/scene/add/userAction
598/vis/scene/add/userAction -10 10 -10 10 -10 10 m
599#/vis/scene/add/axes 0 0 0 10 m
600#/vis/scene/add/scale 10 m
601/vis/sceneHandler/attach
602/vis/viewer/refresh
603</pre></div><p>
604</p><p>
605The extent can be added on registration or on the command line or
606neither (if the extent of the scene is set by other components).
607Your <code class="literal">Draw</code> method will be called whenever needed to refresh
608the screen or rebuild a graphics database, for any chosen viewer.
609The scene can be attached to any scene handler and your drawing
610will be shown.
611</p></div><div class="sect2" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="sect.VisCntCmpl.StdAln"></a>8.5.11. 
612Standalone Visualization
613</h3></div></div></div><p>
614The above raises the possibility of using Geant4 as a "standalone"
615graphics package without invoking the run manager. The following
616main program, together with a user visualization action and a macro
617file, will allow you to view your drawing interactively on any of
618the supported graphics systems.
619
620</p><div class="informalexample"><pre class="programlisting">
621#include "globals.hh"
622#include "G4VisExecutive.hh"
623#include "G4VisExtent.hh"
624#include "G4UImanager.hh"
625#include "G4UIterminal.hh"
626#include "G4UItcsh.hh"
627
628#include "StandaloneVisAction.hh"
629
630int main() {
631
632  G4VisManager* visManager = new G4VisExecutive;
633  visManager-&gt;Initialize ();
634
635  visManager-&gt;SetUserAction
636    (new StandaloneVisAction,
637     G4VisExtent(-5*m,5*m,-5*m,5*m,-5*m,5*m));  // 2nd argument optional.
638
639  G4UImanager* UI = G4UImanager::GetUIpointer ();
640  UI-&gt;ApplyCommand ("/control/execute standalone.g4m");
641
642  G4UIsession* session = new G4UIterminal(new G4UItcsh);
643  session-&gt;SessionStart();
644
645  delete session;
646  delete visManager;
647}
648</pre></div><p>
649</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch08s04.html"><img src="AllResources/IconsGIF/prev.gif" alt="Prev"></a> </td><td width="20%" align="center"><a accesskey="u" href="ch08.html"><img src="AllResources/IconsGIF/up.gif" alt="Up"></a></td><td width="40%" align="right"> <a accesskey="n" href="ch08s06.html"><img src="AllResources/IconsGIF/next.gif" alt="Next"></a></td></tr><tr><td width="40%" align="left" valign="top">8.4. 
650Controlling Visualization from Commands
651 </td><td width="20%" align="center"><a accesskey="h" href="index.html"><img src="AllResources/IconsGIF/home.gif" alt="Home"></a></td><td width="40%" align="right" valign="top"> 8.6. 
652Visualization Attributes
653</td></tr></table></div></body></html>
Note: See TracBrowser for help on using the repository browser.