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