1 | |
---|
2 | <HTML> |
---|
3 | <TITLE>Visualization Attributes |
---|
4 | </TITLE> |
---|
5 | <!-- Changed by: Katsuya Dosanjh, 15-Jul-2000 --> |
---|
6 | <!-- Changed by: Dennis Wright, 27-Nov-2001 --> |
---|
7 | <!-- Changed by: Satoshi Tanaka, 8-Dec-2002 --> |
---|
8 | <!-- Proof read by: Joe Chuma, 5-Jul-1999 --> |
---|
9 | |
---|
10 | <!-- 3.16.3 Visualization attributes --> |
---|
11 | <!-- *spell, *tag, *contents, *s --> |
---|
12 | <BODY> |
---|
13 | |
---|
14 | <TABLE WIDTH="100%" > |
---|
15 | <TR> |
---|
16 | <TD> |
---|
17 | </A> |
---|
18 | <A HREF="index.html"> |
---|
19 | <IMG SRC="../../../../resources/html/IconsGIF/Contents.gif" ALT="Contents" HEIGHT=16 WIDTH=59></A> |
---|
20 | <A HREF="compiledcontrol.html"> |
---|
21 | <IMG SRC="../../../../resources/html/IconsGIF/Previous.gif" ALT="Previous" HEIGHT=16 WIDTH=59></A> |
---|
22 | <a href="enhanceddrawing.html"> |
---|
23 | <IMG SRC="../../../../resources/html/IconsGIF/Next.gif" ALT="Next" HEIGHT=16 WIDTH=59></a> |
---|
24 | </TD> |
---|
25 | |
---|
26 | <TD ALIGN="Right"><FONT COLOR="#238E23"><FONT SIZE=-1> |
---|
27 | <B>Geant4 User's Guide</B> <BR> |
---|
28 | <B>For Application Developers</B> <BR> |
---|
29 | <B>Visualization</B> </FONT></FONT> </TD> |
---|
30 | </TR> |
---|
31 | </TABLE> |
---|
32 | |
---|
33 | <CENTER><FONT COLOR="#238E23"><FONT SIZE=+3> |
---|
34 | <b>8.6 Visualization Attributes</b><BR> |
---|
35 | </FONT></FONT></CENTER> |
---|
36 | <BR> |
---|
37 | |
---|
38 | <HR ALIGN="Center" SIZE="7%"><BR> |
---|
39 | |
---|
40 | <!-- ============================================== Section --> |
---|
41 | |
---|
42 | Visualization attributes are extra pieces of information associated with the |
---|
43 | visualizable objects. This information is necessary only for |
---|
44 | visualization, and is not included in geometrical information such as |
---|
45 | shapes, position, and orientation. |
---|
46 | Typical examples of visualization attributes are Color, Visible/Invisible, Wireframe/Solid. |
---|
47 | For example, in visualizing a box, the Visualization Manager must know its colour. |
---|
48 | If an object to be visualized has not been assigned |
---|
49 | a set of visualization attributes, then an appropriate default set is used automatically. |
---|
50 | <P> |
---|
51 | A set of visualization attributes is held by an instance of class |
---|
52 | <i>G4VisAttributes</i> defined in the <tt>graphics_reps</tt> category. In the |
---|
53 | following, we explain the main fields of the <i>G4VisAttributes</i> one by one. |
---|
54 | <P> |
---|
55 | <!------------------------------------------------------> |
---|
56 | |
---|
57 | <h4>8.6.1 Visibility </h4> |
---|
58 | |
---|
59 | Visibility is a boolean flag to control the visibility of objects that are |
---|
60 | passed to the Visualization Manager for visualization. Visibility is set with |
---|
61 | the following access function: |
---|
62 | <PRE> |
---|
63 | void G4VisAttributes::SetVisibility (G4bool visibility); |
---|
64 | </PRE> |
---|
65 | If you give <tt>false</tt> to the argument, and if culling is activated (see below), |
---|
66 | visualization is skipped for objects for which this set of |
---|
67 | visualization attributes is assigned. The default value of visibility |
---|
68 | is <tt>true</tt>. |
---|
69 | <P> |
---|
70 | Note that whether an object is visible or not is also affected by the current |
---|
71 | culling policy, which can be tuned with visualization commands. |
---|
72 | <P> |
---|
73 | By default the following public static function is defined: |
---|
74 | <PRE> |
---|
75 | static const G4VisAttributes& GetInvisible(); |
---|
76 | </PRE> |
---|
77 | which returns a reference to a const object in which visibility is set to |
---|
78 | <tt>false</tt>. It can be used as follows: |
---|
79 | <PRE> |
---|
80 | experimentalHall_logical -> SetVisAttributes (G4VisAttributes::GetInvisible()); |
---|
81 | </PRE> |
---|
82 | Direct access to the public static const data member |
---|
83 | <tt>G4VisAttributes::Invisible</tt> is also possible but deprecated on |
---|
84 | account of initialisation issues with dynamic libraries. |
---|
85 | <P> |
---|
86 | |
---|
87 | <!------------------------------------------------------> |
---|
88 | <h4>8.6.2 Colour </h4> |
---|
89 | <h4>8.6.2.1 Construction </h4> |
---|
90 | |
---|
91 | Class <i>G4Colour</i> (an equivalent class name, <i>G4Color</i>, is also available) has 4 fields, which represent the RGBA |
---|
92 | (red, green, blue, and alpha) components of colour. |
---|
93 | Each component takes a value between 0 and 1. |
---|
94 | If an irrelevant value, i.e., a value less than 0 or greater than 1, |
---|
95 | is given as an argument of the constructor, |
---|
96 | such a value is automatically clipped to 0 or 1. |
---|
97 | Alpha is opacity, which is not used at present. |
---|
98 | You can use its default value <tt>1</tt>, which means "opaque" in instantiation |
---|
99 | of <i>G4Colour</i>. |
---|
100 | <P> |
---|
101 | A <i>G4Colour</i> object is instantiated by giving red, green, and blue components to |
---|
102 | its constructor, i.e., |
---|
103 | <PRE> |
---|
104 | G4Colour::G4Colour ( G4double r = 1.0, |
---|
105 | G4double g = 1.0, |
---|
106 | G4double b = 1.0, |
---|
107 | G4double a = 1.0); |
---|
108 | // 0<=red, green, blue <= 1.0 |
---|
109 | </PRE> |
---|
110 | The default value of each component is 1.0. |
---|
111 | That is to say, the default colour is "white" (opaque). |
---|
112 | <P> |
---|
113 | For example, colours which are often used can be instantiated as follows: |
---|
114 | <PRE> |
---|
115 | G4Colour white () ; // <FONT COLOR=#FFFFFF>white</FONT> |
---|
116 | G4Colour white (1.0, 1.0, 1.0) ; // <FONT COLOR=#FFFFFF>white</FONT> |
---|
117 | G4Colour gray (0.5, 0.5, 0.5) ; // <FONT COLOR=#808080>gray</FONT> |
---|
118 | G4Colour black (0.0, 0.0, 0.0) ; // <FONT COLOR=#000000>black</FONT> |
---|
119 | G4Colour red (1.0, 0.0, 0.0) ; // <FONT COLOR=#FF0000>red</FONT> |
---|
120 | G4Colour green (0.0, 1.0, 0.0) ; // <FONT COLOR=#00FF00>green</FONT> |
---|
121 | G4Colour blue (0.0, 0.0, 1.0) ; // <FONT COLOR=#0000FF>blue</FONT> |
---|
122 | G4Colour cyan (0.0, 1.0, 1.0) ; // <FONT COLOR=#00FFFF>cyan</FONT> |
---|
123 | G4Colour magenta (1.0, 0.0, 1.0) ; // <FONT COLOR=#FF00FF>magenta</FONT> |
---|
124 | G4Colour yellow (1.0, 1.0, 0.0) ; // <FONT COLOR=#FFFF00>yellow</FONT> |
---|
125 | </PRE> |
---|
126 | <P> |
---|
127 | It is also possible to instantiate common colours through static public data member functions: |
---|
128 | <PRE> |
---|
129 | static const G4Colour& White (); |
---|
130 | static const G4Colour& Gray (); |
---|
131 | static const G4Colour& Grey (); |
---|
132 | static const G4Colour& Black (); |
---|
133 | static const G4Colour& Red (); |
---|
134 | static const G4Colour& Green (); |
---|
135 | static const G4Colour& Blue (); |
---|
136 | static const G4Colour& Cyan (); |
---|
137 | static const G4Colour& Magenta (); |
---|
138 | static const G4Colour& Yellow (); |
---|
139 | </PRE> |
---|
140 | <P> |
---|
141 | For example, a local <i>G4Colour</i> could be constructed as: |
---|
142 | <PRE> |
---|
143 | G4Colour myRed(G4Colour::Red()); |
---|
144 | </PRE> |
---|
145 | <P> |
---|
146 | After instantiation of a <i>G4Colour</i> object, you can access to its components |
---|
147 | with the following access functions: |
---|
148 | <PRE> |
---|
149 | G4double G4Colour::GetRed () const ; // Get the red component. |
---|
150 | G4double G4Colour::GetGreen () const ; // Get the green component. |
---|
151 | G4double G4Colour::GetBlue () const ; // Get the blue component. |
---|
152 | </PRE> |
---|
153 | |
---|
154 | <P> |
---|
155 | <!------------------------------------------------------> |
---|
156 | <h4>8.6.2.2 Colour Map</h4> |
---|
157 | <i>G4Colour</i> also provides a static colour map, giving access to predefined <i>G4Colour</i>'s through a <i>G4String</i> key. The default mapping is: |
---|
158 | |
---|
159 | <PRE> |
---|
160 | G4String G4Colour |
---|
161 | --------------------------------------- |
---|
162 | white G4Colour::White () |
---|
163 | gray G4Colour::Gray () |
---|
164 | grey G4Colour::Grey () |
---|
165 | black G4Colour::Black () |
---|
166 | red G4Colour::Red () |
---|
167 | green G4Colour::Green () |
---|
168 | blue G4Colour::Blue () |
---|
169 | cyan G4Colour::Cyan () |
---|
170 | magenta G4Colour::Magenta () |
---|
171 | yellow G4Colour::Yellow () |
---|
172 | </PRE> |
---|
173 | <P> |
---|
174 | Colours can be retrieved through the GetColour method: |
---|
175 | |
---|
176 | <PRE> |
---|
177 | bool G4Colour::GetColour(const G4String& key, G4Colour& result) |
---|
178 | </PRE> |
---|
179 | |
---|
180 | For example: |
---|
181 | |
---|
182 | <PRE> |
---|
183 | G4Colour myColour(G4Colour::Black()); |
---|
184 | if (G4Colour::GetColour("red", myColour)) { |
---|
185 | // Successfully retrieved colour "red". myColour is now red |
---|
186 | } |
---|
187 | else { |
---|
188 | // Colour did not exist in map. myColour is still black |
---|
189 | } |
---|
190 | </PRE> |
---|
191 | <P> |
---|
192 | If the key is not registered in the colour map, a warning message is |
---|
193 | printed and the input colour is not changed. The colour map is case insensitive. |
---|
194 | |
---|
195 | |
---|
196 | <P> |
---|
197 | It is also possible to load user defined <i>G4Colour</i>'s into the map through |
---|
198 | the public AddToMap method. For example: |
---|
199 | |
---|
200 | <PRE> |
---|
201 | G4Colour myColour(0.2, 0.2, 0.2, 1); |
---|
202 | G4Colour::AddToMap("custom", myColour); |
---|
203 | </PRE> |
---|
204 | <P> |
---|
205 | |
---|
206 | This loads a user defined <i>G4Colour</i> with key "custom" into the colour map. |
---|
207 | |
---|
208 | <h4>8.6.2.3 Colour and <i>G4VisAttributes</i> </h4> |
---|
209 | Class <i>G4VisAttributes</i> holds its colour entry as an object of class <i>G4Colour</i>. |
---|
210 | A <i>G4Colour</i> object is passed to a <i>G4VisAttributes</i> object with the following |
---|
211 | access functions: |
---|
212 | <PRE> |
---|
213 | //----- Set functions of G4VisAttributes. |
---|
214 | void G4VisAttributes::SetColour (const G4Colour& colour); |
---|
215 | void G4VisAttributes::SetColor (const G4Color& color ); |
---|
216 | </PRE> |
---|
217 | We can also set RGBA components directly: |
---|
218 | <PRE> |
---|
219 | //----- Set functions of G4VisAttributes |
---|
220 | void G4VisAttributes::SetColour ( G4double red , |
---|
221 | G4double green , |
---|
222 | G4double blue , |
---|
223 | G4double alpha = 1.0); |
---|
224 | |
---|
225 | void G4VisAttributes::SetColor ( G4double red , |
---|
226 | G4double green , |
---|
227 | G4double blue , |
---|
228 | G4double alpha = 1.); |
---|
229 | </PRE> |
---|
230 | The following constructor with <i>G4Colour</i> as its argument is also supported: |
---|
231 | <PRE> |
---|
232 | //----- Constructor of G4VisAttributes |
---|
233 | G4VisAttributes::G4VisAttributes (const G4Colour& colour); |
---|
234 | </PRE> |
---|
235 | <P> |
---|
236 | Note that colour assigned to a <i>G4VisAttributes</i> object is not always the colour |
---|
237 | that ultimately appears in the visualization. The ultimate appearance may be affected |
---|
238 | by shading and lighting models applied in the selected visualization driver or stand-alone |
---|
239 | graphics system. |
---|
240 | |
---|
241 | |
---|
242 | <P> |
---|
243 | <!------------------------------------------------------> |
---|
244 | <h4>8.6.3 Forcing attributes</h4> |
---|
245 | |
---|
246 | As you will see later, you can select a "drawing style" from various options. |
---|
247 | For example, you can select your detector components to be visualized in |
---|
248 | "wireframe" or with "surfaces". In the former, only the edges of your detector |
---|
249 | are drawn and so the detector looks transparent. In the latter, your detector |
---|
250 | looks opaque with shading effects. |
---|
251 | <P> |
---|
252 | The forced wireframe and forced solid styles make it possible to mix the |
---|
253 | wireframe and surface visualization (if your selected graphics system supports |
---|
254 | such visualization). For example, you can make only the outer |
---|
255 | wall of your detector "wired" (transparent) and can see inside in detail. |
---|
256 | <P> |
---|
257 | Forced wireframe style is set with the following access function: |
---|
258 | <PRE> |
---|
259 | void G4VisAttributes::SetForceWireframe (G4bool force); |
---|
260 | </PRE> |
---|
261 | If you give <tt>true</tt> as the argument, objects for which this set of |
---|
262 | visualization attributes is assigned are always visualized in |
---|
263 | wireframe even if in general, the surface drawing style has been |
---|
264 | requested. The default value of the forced wireframe style is <tt>false</tt>. |
---|
265 | <P> |
---|
266 | Similarly, forced solid style, i.e., to force that objects are always |
---|
267 | visualized with surfaces, is set with: |
---|
268 | <PRE> |
---|
269 | void G4VisAttributes::SetForceSolid (G4bool force); |
---|
270 | </PRE> |
---|
271 | The default value of the forced solid style is <tt>false</tt>, too. |
---|
272 | <P> |
---|
273 | You can also force auxiliary edges to be visible. Normally they are |
---|
274 | not visible unless you set the appropriate view parameter. Forcing |
---|
275 | the auxiliary edges to be visible means that auxiliary edges will be |
---|
276 | seen whatever the view parameters. |
---|
277 | <P> |
---|
278 | Auxiliary edges are not genuine edges of the volume. They may be in |
---|
279 | a curved surface made out of polygons, for example, or in plane |
---|
280 | surface of complicated shape that has to be broken down into simpler |
---|
281 | polygons. HepPolyhedron breaks all surfaces into triangles or |
---|
282 | quadrilaterals. There will be auxiliary edges for any volumes with a |
---|
283 | curved surface, such as a tube or a sphere, or a volume resulting |
---|
284 | from a Boolean operation. Normally, they are not shown, but |
---|
285 | sometimes it is useful to see them. In particular, a sphere, because |
---|
286 | it has no egdes, will not be seen in wireframe mode in some graphics |
---|
287 | systems unless requested by the view parameters or forced, as |
---|
288 | described here. |
---|
289 | <P> |
---|
290 | To force auxiliary edges to be visible, use: |
---|
291 | <PRE> |
---|
292 | void G4VisAttributes::SetForceAuxEdgeVisible (G4bool force); |
---|
293 | </PRE> |
---|
294 | The default value of the force auxiliary edges visible flag is |
---|
295 | <tt>false</tt>. |
---|
296 | <P> |
---|
297 | For volumes with edges that are parts of a circle, such as a tube |
---|
298 | (G4Tubs), etc., it is possible to force the precision of polyhedral |
---|
299 | representation for visualisation. This is recommended for volumes |
---|
300 | containing only a small angle of circle, for example, a thin tube |
---|
301 | segment. |
---|
302 | <P> |
---|
303 | For visualisation, a circle is represented by an N-sided polygon. |
---|
304 | The default is 24 sides or segments. The user may change this for |
---|
305 | all volumes in a particular viewer at run time with |
---|
306 | /vis/viewer/set/lineSegmentsPerCircle; alternatively it can be forced |
---|
307 | for a particular volume with: |
---|
308 | <PRE> |
---|
309 | void G4VisAttributes::SetForceLineSegmentsPerCircle (G4int nSegments); |
---|
310 | </PRE> |
---|
311 | <P> |
---|
312 | |
---|
313 | <!------------------------------------------------------> |
---|
314 | <h4>8.6.4 Constructors of <i>G4VisAttributes</i> </h4> |
---|
315 | |
---|
316 | The following constructors are supported for class <i>G4VisAttributes</i>: |
---|
317 | <PRE> |
---|
318 | //----- Constructors of class G4VisAttributes |
---|
319 | G4VisAttributes (void); |
---|
320 | G4VisAttributes (G4bool visibility); |
---|
321 | G4VisAttributes (const G4Colour& colour); |
---|
322 | G4VisAttributes (G4bool visibility, const G4Colour& colour); |
---|
323 | </PRE> |
---|
324 | <P> |
---|
325 | |
---|
326 | <!------------------------------------------------------> |
---|
327 | <h4>8.6.5 How to assign <i>G4VisAttributes</i> to a logical volume</h4> |
---|
328 | |
---|
329 | In constructing your detector components, you may assign a set of |
---|
330 | visualization attributes to each "logical volume" in order to |
---|
331 | visualize them later (if you do not do this, the graphics system |
---|
332 | will use a default set). You cannot make a solid such as <i>G4Box</i> hold a |
---|
333 | set of visualization attributes; this is because a solid should hold |
---|
334 | only geometrical information. At present, you cannot make a physical |
---|
335 | volume hold one, but there are plans to design a memory-efficient way |
---|
336 | to do it; however, you can visualize a transient piece of solid or |
---|
337 | physical volume with a temporary assigned set of visualization attributes. |
---|
338 | <P> |
---|
339 | Class <i>G4LogicalVolume</i> holds a pointer of <i>G4VisAttributes.</i> This field is |
---|
340 | set and referenced with the following access functions: |
---|
341 | <PRE> |
---|
342 | //----- Set functions of G4VisAttributes |
---|
343 | void G4VisAttributes::SetVisAttributes (const G4VisAttributes* pVA); |
---|
344 | void G4VisAttributes::SetVisAttributes (const G4VisAttributes& VA); |
---|
345 | |
---|
346 | //----- Get functions of G4VisAttributes |
---|
347 | const G4VisAttributes* G4VisAttributes::GetVisAttributes () const; |
---|
348 | </PRE> |
---|
349 | <P> |
---|
350 | The following is sample C++ source codes for assigning a set of visualization |
---|
351 | attributes with cyan colour and forced wireframe style to a logical volume: |
---|
352 | <PRE> |
---|
353 | //----- C++ source codes: Assigning G4VisAttributes to a logical volume |
---|
354 | ... |
---|
355 | // Instantiation of a logical volume |
---|
356 | myTargetLog = new G4LogicalVolume( myTargetTube,BGO, "TLog", 0, 0, 0); |
---|
357 | ... |
---|
358 | // Instantiation of a set of visualization attributes with cyan colour |
---|
359 | G4VisAttributes * calTubeVisAtt = new G4VisAttributes(G4Colour(0.,1.,1.)); |
---|
360 | // Set the forced wireframe style |
---|
361 | calTubeVisAtt->SetForceWireframe(true); |
---|
362 | // Assignment of the visualization attributes to the logical volume |
---|
363 | myTargetLog->SetVisAttributes(calTubeVisAtt); |
---|
364 | |
---|
365 | //----- end of C++ source codes |
---|
366 | </PRE> |
---|
367 | <P> |
---|
368 | Note that the life of the visualization attributes must be at least as |
---|
369 | long as the objects to which they are assigned; it is the users' |
---|
370 | responsibility to ensure this, and to delete the visualization |
---|
371 | attributes when they are no longer needed (or just leave them to die |
---|
372 | at the end of the job). |
---|
373 | <P> |
---|
374 | |
---|
375 | <!------------------------------------------------------> |
---|
376 | <h4>8.6.6 Additional User-Defined Attributes</h4> |
---|
377 | Geant4 Trajectories and Hits can be assigned additional arbitrary attributes that will be displayed when |
---|
378 | you click on the relevant object in the WIRED or FRED HepRep browsers. |
---|
379 | WIRED then lets you label objects by any of these attributes or cut visibility based on these attributes. |
---|
380 | <P> |
---|
381 | Define the attributes with lines such as: |
---|
382 | <PRE> |
---|
383 | std::map<G4String,G4AttDef>* store = G4AttDefStore::GetInstance("G4Trajectory",isNew); |
---|
384 | G4String PN("PN"); |
---|
385 | (*store)[PN] = G4AttDef(PN,"Particle Name","Physics","","G4String"); |
---|
386 | G4String IMom("IMom"); |
---|
387 | (*store)[IMom] = G4AttDef(IMom, "Momentum of track at start of trajectory", "Physics","","G4ThreeVector"); |
---|
388 | </PRE> |
---|
389 | Then fill the attributes with lines such as: |
---|
390 | <PRE> |
---|
391 | std::vector<G4AttValue>* values = new std::vector<G4AttValue>; |
---|
392 | values->push_back(G4AttValue("PN",ParticleName,"")); |
---|
393 | s.seekp(std::ios::beg); |
---|
394 | s << G4BestUnit(initialMomentum,"Energy") << std::ends; |
---|
395 | values->push_back(G4AttValue("IMom",c,"")); |
---|
396 | </PRE> |
---|
397 | See geant4/source/tracking/src/G4Trajectory.cc for a good example. |
---|
398 | <P> |
---|
399 | <i>G4AttValue</i> objects are light, containing just the value; for the |
---|
400 | long description and other sharable information the <i>G4AttValue</i> object |
---|
401 | refers to a <i>G4AttDef</i> object. They are based on the |
---|
402 | HepRep standard described at |
---|
403 | <A HREF="http://www.slac.stanford.edu/~perl/heprep/">http://www.slac.stanford.edu/~perl/heprep/</a>. |
---|
404 | Geant4 also provides an <i>G4AttDefStore</i>. |
---|
405 | |
---|
406 | <P> |
---|
407 | Geant4 provides some default examples of the use of this facility |
---|
408 | in the trajectory classes in /source/tracking such as |
---|
409 | <i>G4Trajectory</i>, <i>G4SmoothTrajectory</i>. |
---|
410 | <i>G4Trajectory::CreateAttValues</i> |
---|
411 | shows how <i>G4AttValue</i> objects can be made and |
---|
412 | <i>G4Trajectory::GetAttDefs</i> |
---|
413 | shows how to make the corresponding <i>G4AttDef</i> objects and use the |
---|
414 | <i>G4AttDefStore</i>. |
---|
415 | Note that the "user" of CreateAttValues guarantees to |
---|
416 | destroy them; this is a way of allowing creation on demand and leaving |
---|
417 | the <i>G4Trajectory</i> object, for example, free of such objects in memory. |
---|
418 | The comments in <i>G4VTrajectory.hh</i> explain further and additional |
---|
419 | insights might be obtained by looking at two methods which use them, |
---|
420 | namely <i>G4VTrajectory::DrawTrajectory</i> and |
---|
421 | <i>G4VTrajectory::ShowTrajectory</i>. |
---|
422 | |
---|
423 | <P> |
---|
424 | Hits classes in examples /extended/analysis/A01 and /extended/runAndEvent/RE01 |
---|
425 | show how to do the same for your hits. The base |
---|
426 | class no-action methods CreateAttValues and GetAttDefs should be |
---|
427 | overridden in your concrete class. The comments in <i>G4VHit.hh</i> explain |
---|
428 | further. |
---|
429 | |
---|
430 | <P> |
---|
431 | In addition, the user is free to add a <i>G4std::vector<G4AttValue>*</i> and |
---|
432 | a <i>G4std::vector<G4AttDef>*</i> to a <i>G4VisAttributes</i> |
---|
433 | object as could, for |
---|
434 | example, be used by a <i>G4LogicalVolume</i> object. |
---|
435 | |
---|
436 | <P> |
---|
437 | At the time of writing, only the HepRep graphics systems are capable of |
---|
438 | displaying the G4AttValue information, but this information will become useful for all |
---|
439 | Geant4 visualization systems through improvements in release 8.1 or later. |
---|
440 | <P> |
---|
441 | |
---|
442 | |
---|
443 | <HR> |
---|
444 | <A HREF="enhanceddrawing.html">Next section</A><BR> |
---|
445 | <A HREF="index.html">Back to contents</A> |
---|
446 | |
---|
447 | </BODY> |
---|
448 | </HTML> |
---|