Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // 26 // 26 // >> 27 // $Id: G4VisCommandsViewerSet.cc 76477 2013-11-11 10:39:56Z gcosmo $ 27 28 28 // /vis/viewer/set commands - John Allison 16 29 // /vis/viewer/set commands - John Allison 16th May 2000 29 30 30 #include "G4VisCommandsViewerSet.hh" 31 #include "G4VisCommandsViewerSet.hh" 31 32 32 #include "G4UIcommand.hh" 33 #include "G4UIcommand.hh" 33 #include "G4UIcmdWithoutParameter.hh" << 34 #include "G4UIcmdWithAString.hh" 34 #include "G4UIcmdWithAString.hh" 35 #include "G4UIcmdWithABool.hh" 35 #include "G4UIcmdWithABool.hh" 36 #include "G4UIcmdWithAnInteger.hh" 36 #include "G4UIcmdWithAnInteger.hh" 37 #include "G4UIcmdWithADouble.hh" 37 #include "G4UIcmdWithADouble.hh" 38 #include "G4UIcmdWith3VectorAndUnit.hh" 38 #include "G4UIcmdWith3VectorAndUnit.hh" 39 #include "G4UnitsTable.hh" 39 #include "G4UnitsTable.hh" 40 #include "G4VisManager.hh" 40 #include "G4VisManager.hh" 41 #include "G4Polyhedron.hh" 41 #include "G4Polyhedron.hh" 42 #include "G4SystemOfUnits.hh" 42 #include "G4SystemOfUnits.hh" 43 43 44 #include <sstream> 44 #include <sstream> 45 #include <iomanip> << 45 #include <cctype> 46 #include <utility> << 47 << 48 #define G4warn G4cout << 49 46 50 G4VisCommandsViewerSet::G4VisCommandsViewerSet 47 G4VisCommandsViewerSet::G4VisCommandsViewerSet (): 51 fLightsVector (G4ThreeVector(1.,1.,1.)), << 48 fLightsVector (G4ThreeVector(1.,1.,1.)), 52 fUpVector (G4ThreeVector(0.,1.,0.)), << 49 fUpVector (G4ThreeVector(0.,1.,0.)), 53 fViewpointVector (G4ThreeVector(0.,0.,1.)) << 50 fViewpointVector (G4ThreeVector(0.,0.,1.)) 54 { 51 { 55 G4bool omitable; 52 G4bool omitable; 56 G4UIparameter* parameter; 53 G4UIparameter* parameter; 57 54 58 fpCommandAll = new G4UIcmdWithAString ("/vis 55 fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this); 59 fpCommandAll->SetGuidance 56 fpCommandAll->SetGuidance 60 ("Copies view parameters."); << 57 ("Copies view parameters."); 61 fpCommandAll->SetGuidance << 62 ("Copies ALL view parameters (except the aut << 63 "\nfrom-viewer to current viewer. You may n << 64 fpCommandAll->SetGuidance 58 fpCommandAll->SetGuidance 65 ("Note: to copy only the camera-specific par << 59 ("Copies view parameters (except the autoRefresh status) from" 66 "\n\"/vis/viewer/copyfrom\"."); << 60 "\nfrom-viewer to current viewer."); 67 fpCommandAll->SetParameterName ("from-viewer 61 fpCommandAll->SetParameterName ("from-viewer-name",omitable = false); 68 62 69 fpCommandAutoRefresh = new G4UIcmdWithABool 63 fpCommandAutoRefresh = new G4UIcmdWithABool 70 ("/vis/viewer/set/autoRefresh",this); << 64 ("/vis/viewer/set/autoRefresh",this); 71 fpCommandAutoRefresh->SetGuidance("Sets auto 65 fpCommandAutoRefresh->SetGuidance("Sets auto-refresh."); 72 fpCommandAutoRefresh->SetGuidance 66 fpCommandAutoRefresh->SetGuidance 73 ("If true, view is automatically refreshed a << 67 ("If true, view is automatically refreshed after a change of" 74 "\nview parameters."); << 68 "\nview parameters."); 75 fpCommandAutoRefresh->SetParameterName("auto 69 fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true); 76 fpCommandAutoRefresh->SetDefaultValue(true); 70 fpCommandAutoRefresh->SetDefaultValue(true); 77 71 78 fpCommandAuxEdge = new G4UIcmdWithABool 72 fpCommandAuxEdge = new G4UIcmdWithABool 79 ("/vis/viewer/set/auxiliaryEdge",this); << 73 ("/vis/viewer/set/auxiliaryEdge",this); 80 fpCommandAuxEdge->SetGuidance("Sets visibili 74 fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges"); 81 fpCommandAuxEdge->SetGuidance 75 fpCommandAuxEdge->SetGuidance 82 ("Auxiliary edges, i.e., those that are part << 76 ("Auxiliary edges, i.e., those that are part of a curved surface," 83 "\nsometimes called soft edges, become visi << 77 "\nsometimes called soft edges, become visible/invisible."); 84 fpCommandAuxEdge->SetParameterName("edge",om 78 fpCommandAuxEdge->SetParameterName("edge",omitable = true); 85 fpCommandAuxEdge->SetDefaultValue(true); 79 fpCommandAuxEdge->SetDefaultValue(true); 86 80 87 fpCommandBackground = new G4UIcommand 81 fpCommandBackground = new G4UIcommand 88 ("/vis/viewer/set/background",this); << 82 ("/vis/viewer/set/background",this); 89 fpCommandBackground->SetGuidance 83 fpCommandBackground->SetGuidance 90 ("Set background colour and transparency (de << 84 ("Set background colour and transparency (default black and opaque)."); 91 fpCommandBackground->SetGuidance(ConvertToCo << 85 fpCommandBackground->SetGuidance >> 86 ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or" >> 87 "\n(b) string such as \"white\", \"black\", \"grey\", \"red\"..." >> 88 "\n(c) an additional number for opacity, e.g., \".3 .4 .5 .6\"" >> 89 "\n or \"grey ! ! .6\" (note \"!\"'s for unused green and blue parameters)," >> 90 "\n e.g. \"! ! ! 0.\" for a transparent background."); 92 parameter = new G4UIparameter("red_or_string 91 parameter = new G4UIparameter("red_or_string", 's', omitable = true); 93 parameter -> SetDefaultValue ("0."); 92 parameter -> SetDefaultValue ("0."); 94 fpCommandBackground -> SetParameter (paramet 93 fpCommandBackground -> SetParameter (parameter); 95 parameter = new G4UIparameter("green", 'd', 94 parameter = new G4UIparameter("green", 'd', omitable = true); 96 parameter -> SetDefaultValue (0.); 95 parameter -> SetDefaultValue (0.); 97 fpCommandBackground -> SetParameter (paramet 96 fpCommandBackground -> SetParameter (parameter); 98 parameter = new G4UIparameter ("blue", 'd', 97 parameter = new G4UIparameter ("blue", 'd', omitable = true); 99 parameter -> SetDefaultValue (0.); 98 parameter -> SetDefaultValue (0.); 100 fpCommandBackground -> SetParameter (paramet 99 fpCommandBackground -> SetParameter (parameter); 101 parameter = new G4UIparameter ("opacity", 'd 100 parameter = new G4UIparameter ("opacity", 'd', omitable = true); 102 parameter -> SetDefaultValue (1.); 101 parameter -> SetDefaultValue (1.); 103 fpCommandBackground -> SetParameter (paramet 102 fpCommandBackground -> SetParameter (parameter); 104 103 105 fpCommandCulling = new G4UIcommand("/vis/vie 104 fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this); 106 fpCommandCulling->SetGuidance ("Set culling 105 fpCommandCulling->SetGuidance ("Set culling options."); 107 fpCommandCulling->SetGuidance 106 fpCommandCulling->SetGuidance 108 ("\"global\": enables/disables all other cul << 107 ("\"global\": enables/disables all other culling options."); 109 fpCommandCulling->SetGuidance 108 fpCommandCulling->SetGuidance 110 ("\"coveredDaughters\": culls, i.e., elimina << 109 ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not" 111 "\nbe seen because covered by ancestor volu << 110 "\nbe seen because covered by ancester volumes in surface drawing mode," 112 "\nand then only if the ancestors are visib << 111 "\nand then only if the ancesters are visible and opaque, and then only" 113 "\nif no sections or cutaways are in operat << 112 "\nif no sections or cutaways are in operation. Intended solely to" 114 "\nimprove the speed of rendering visible v << 113 "\nimprove the speed of rendering visible volumes."); 115 fpCommandCulling->SetGuidance 114 fpCommandCulling->SetGuidance 116 ("\"invisible\": culls objects with the invi << 115 ("\"invisible\": culls objects with the invisible attribute set."); 117 fpCommandCulling->SetGuidance 116 fpCommandCulling->SetGuidance 118 ("\"density\": culls volumes with density lo << 117 ("\"density\": culls volumes with density lower than threshold. Useful" 119 "\nfor eliminating \"container volumes\" wi << 118 "\nfor eliminating \"container volumes\" with no physical correspondence," 120 "\nwhose material is usually air. If this << 119 "\nwhose material is usually air. If this is selected, provide threshold" 121 "\ndensity and unit (e.g., g/cm3, mg/cm3 or << 120 "\ndensity and unit (g/cm3 mg/cm3 or kg/m3)." 122 ); << 121 ); 123 parameter = new G4UIparameter("culling-optio 122 parameter = new G4UIparameter("culling-option",'s',omitable = false); 124 parameter->SetParameterCandidates 123 parameter->SetParameterCandidates 125 ("global coveredDaughters invisible density" << 124 ("global coveredDaughters invisible density"); 126 fpCommandCulling->SetParameter(parameter); 125 fpCommandCulling->SetParameter(parameter); 127 parameter = new G4UIparameter("action",'b',o 126 parameter = new G4UIparameter("action",'b',omitable = true); 128 parameter->SetDefaultValue(1); 127 parameter->SetDefaultValue(1); 129 fpCommandCulling->SetParameter(parameter); 128 fpCommandCulling->SetParameter(parameter); 130 parameter = new G4UIparameter("density-thres 129 parameter = new G4UIparameter("density-threshold",'d',omitable = true); 131 parameter->SetDefaultValue("0.01"); 130 parameter->SetDefaultValue("0.01"); 132 fpCommandCulling->SetParameter(parameter); 131 fpCommandCulling->SetParameter(parameter); 133 parameter = new G4UIparameter("unit",'s',omi 132 parameter = new G4UIparameter("unit",'s',omitable = true); 134 // parameter->SetParameterCandidates ("g/cm3 << 133 parameter->SetParameterCandidates ("g/cm3, mg/cm3 kg/m3"); 135 // Instead of the above, SetNewValue accepts << 136 parameter->SetDefaultValue("g/cm3"); 134 parameter->SetDefaultValue("g/cm3"); 137 fpCommandCulling->SetParameter(parameter); 135 fpCommandCulling->SetParameter(parameter); 138 136 139 fpCommandCutawayMode = 137 fpCommandCutawayMode = 140 new G4UIcmdWithAString ("/vis/viewer/set/cut << 138 new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this); 141 fpCommandCutawayMode->SetGuidance 139 fpCommandCutawayMode->SetGuidance 142 ("Sets cutaway mode - add (union) or multipl << 140 ("Sets cutaway mode - add (union) or multiply (intersection)."); 143 fpCommandCutawayMode->SetParameterName ("cut 141 fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false); 144 fpCommandCutawayMode->SetCandidates ("add un 142 fpCommandCutawayMode->SetCandidates ("add union multiply intersection"); 145 fpCommandCutawayMode->SetDefaultValue("union 143 fpCommandCutawayMode->SetDefaultValue("union"); 146 144 147 fpCommandDefaultColour = new G4UIcommand 145 fpCommandDefaultColour = new G4UIcommand 148 ("/vis/viewer/set/defaultColour",this); << 146 ("/vis/viewer/set/defaultColour",this); >> 147 fpCommandDefaultColour->SetGuidance >> 148 ("Set defaultColour colour and transparency (default white and opaque)."); 149 fpCommandDefaultColour->SetGuidance 149 fpCommandDefaultColour->SetGuidance 150 ("Set defaultColour colour and transparency << 150 ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or" 151 fpCommandDefaultColour->SetGuidance(ConvertT << 151 "\n(b) string such as \"white\", \"black\", \"grey\", \"red\"..." >> 152 "\n(c) an additional number for opacity, e.g., \".3 .4 .5 .6\"" >> 153 "\n or \"grey ! ! .6\" (note \"!\"'s for unused green and blue parameters)," >> 154 "\n e.g. \"! ! ! 0.\" for a transparent colour."); 152 parameter = new G4UIparameter("red_or_string 155 parameter = new G4UIparameter("red_or_string", 's', omitable = true); 153 parameter -> SetDefaultValue ("1."); 156 parameter -> SetDefaultValue ("1."); 154 fpCommandDefaultColour -> SetParameter (para 157 fpCommandDefaultColour -> SetParameter (parameter); 155 parameter = new G4UIparameter("green", 'd', 158 parameter = new G4UIparameter("green", 'd', omitable = true); 156 parameter -> SetDefaultValue (1.); 159 parameter -> SetDefaultValue (1.); 157 fpCommandDefaultColour -> SetParameter (para 160 fpCommandDefaultColour -> SetParameter (parameter); 158 parameter = new G4UIparameter ("blue", 'd', 161 parameter = new G4UIparameter ("blue", 'd', omitable = true); 159 parameter -> SetDefaultValue (1.); 162 parameter -> SetDefaultValue (1.); 160 fpCommandDefaultColour -> SetParameter (para 163 fpCommandDefaultColour -> SetParameter (parameter); 161 parameter = new G4UIparameter ("opacity", 'd 164 parameter = new G4UIparameter ("opacity", 'd', omitable = true); 162 parameter -> SetDefaultValue (1.); 165 parameter -> SetDefaultValue (1.); 163 fpCommandDefaultColour -> SetParameter (para 166 fpCommandDefaultColour -> SetParameter (parameter); 164 167 165 fpCommandDefaultTextColour = new G4UIcommand 168 fpCommandDefaultTextColour = new G4UIcommand 166 ("/vis/viewer/set/defaultTextColour",this); << 169 ("/vis/viewer/set/defaultTextColour",this); 167 fpCommandDefaultTextColour->SetGuidance 170 fpCommandDefaultTextColour->SetGuidance 168 ("Set defaultTextColour colour and transpare << 171 ("Set defaultTextColour colour and transparency (default white and opaque)."); 169 fpCommandDefaultTextColour->SetGuidance(Conv << 172 fpCommandDefaultTextColour->SetGuidance >> 173 ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or" >> 174 "\n(b) string such as \"white\", \"black\", \"grey\", \"red\"..." >> 175 "\n(c) an additional number for opacity, e.g., \".3 .4 .5 .6\"" >> 176 "\n or \"grey ! ! .6\" (note \"!\"'s for unused green and blue parameters)," >> 177 "\n e.g. \"! ! ! 0.\" for a transparent colour."); 170 parameter = new G4UIparameter("red_or_string 178 parameter = new G4UIparameter("red_or_string", 's', omitable = true); 171 parameter -> SetDefaultValue ("0."); << 179 parameter -> SetDefaultValue ("1."); 172 fpCommandDefaultTextColour -> SetParameter ( 180 fpCommandDefaultTextColour -> SetParameter (parameter); 173 parameter = new G4UIparameter("green", 'd', 181 parameter = new G4UIparameter("green", 'd', omitable = true); 174 parameter -> SetDefaultValue (0.); << 182 parameter -> SetDefaultValue (1.); 175 fpCommandDefaultTextColour -> SetParameter ( 183 fpCommandDefaultTextColour -> SetParameter (parameter); 176 parameter = new G4UIparameter ("blue", 'd', 184 parameter = new G4UIparameter ("blue", 'd', omitable = true); 177 parameter -> SetDefaultValue (1.); 185 parameter -> SetDefaultValue (1.); 178 fpCommandDefaultTextColour -> SetParameter ( 186 fpCommandDefaultTextColour -> SetParameter (parameter); 179 parameter = new G4UIparameter ("opacity", 'd 187 parameter = new G4UIparameter ("opacity", 'd', omitable = true); 180 parameter -> SetDefaultValue (1.); 188 parameter -> SetDefaultValue (1.); 181 fpCommandDefaultTextColour -> SetParameter ( 189 fpCommandDefaultTextColour -> SetParameter (parameter); 182 190 183 fpCommandEdge = new G4UIcmdWithABool("/vis/v 191 fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this); 184 fpCommandEdge->SetGuidance 192 fpCommandEdge->SetGuidance 185 ("Edges become visible/invisible in surface << 193 ("Edges become visible/invisible in surface mode."); 186 fpCommandEdge->SetParameterName("edge",omita 194 fpCommandEdge->SetParameterName("edge",omitable = true); 187 fpCommandEdge->SetDefaultValue(true); 195 fpCommandEdge->SetDefaultValue(true); 188 196 189 fpCommandExplodeFactor = new G4UIcommand 197 fpCommandExplodeFactor = new G4UIcommand 190 ("/vis/viewer/set/explodeFactor", this); << 198 ("/vis/viewer/set/explodeFactor", this); 191 fpCommandExplodeFactor->SetGuidance 199 fpCommandExplodeFactor->SetGuidance 192 ("Moves top-level drawn volumes by this fact << 200 ("Moves top-level drawn volumes by this factor from this centre."); 193 parameter = new G4UIparameter("explodeFactor 201 parameter = new G4UIparameter("explodeFactor", 'd', omitable=true); 194 parameter->SetParameterRange("explodeFactor> 202 parameter->SetParameterRange("explodeFactor>=1."); 195 parameter->SetDefaultValue(1.); 203 parameter->SetDefaultValue(1.); 196 fpCommandExplodeFactor->SetParameter(paramet 204 fpCommandExplodeFactor->SetParameter(parameter); 197 parameter = new G4UIparameter("x",'d',omitab 205 parameter = new G4UIparameter("x",'d',omitable = true); 198 parameter->SetDefaultValue (0); 206 parameter->SetDefaultValue (0); 199 parameter->SetGuidance ("Coordinate of 207 parameter->SetGuidance ("Coordinate of explode centre."); 200 fpCommandExplodeFactor->SetParameter(paramet 208 fpCommandExplodeFactor->SetParameter(parameter); 201 parameter = new G4UIparameter("y",'d',omitab 209 parameter = new G4UIparameter("y",'d',omitable = true); 202 parameter->SetDefaultValue (0); 210 parameter->SetDefaultValue (0); 203 parameter->SetGuidance ("Coordinate of 211 parameter->SetGuidance ("Coordinate of explode centre."); 204 fpCommandExplodeFactor->SetParameter(paramet 212 fpCommandExplodeFactor->SetParameter(parameter); 205 parameter = new G4UIparameter("z",'d',omitab 213 parameter = new G4UIparameter("z",'d',omitable = true); 206 parameter->SetDefaultValue (0); 214 parameter->SetDefaultValue (0); 207 parameter->SetGuidance ("Coordinate of 215 parameter->SetGuidance ("Coordinate of explode centre."); 208 fpCommandExplodeFactor->SetParameter(paramet 216 fpCommandExplodeFactor->SetParameter(parameter); 209 parameter = new G4UIparameter("unit",'s',omi 217 parameter = new G4UIparameter("unit",'s',omitable = true); 210 parameter->SetDefaultValue ("m"); 218 parameter->SetDefaultValue ("m"); 211 parameter->SetGuidance ("Unit of explod 219 parameter->SetGuidance ("Unit of explode centre."); 212 fpCommandExplodeFactor->SetParameter(paramet 220 fpCommandExplodeFactor->SetParameter(parameter); 213 221 214 fpCommandGlobalLineWidthScale = new G4UIcmdW 222 fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble 215 ("/vis/viewer/set/globalLineWidthScale", thi << 223 ("/vis/viewer/set/globalLineWidthScale", this); 216 fpCommandGlobalLineWidthScale->SetGuidance 224 fpCommandGlobalLineWidthScale->SetGuidance 217 ("Multiplies line widths by this factor."); << 225 ("Multiplies line widths by this factor."); 218 fpCommandGlobalLineWidthScale-> 226 fpCommandGlobalLineWidthScale-> 219 SetParameterName("scale-factor", omitable=tr << 227 SetParameterName("scale-factor", omitable=true); 220 fpCommandGlobalLineWidthScale->SetDefaultVal 228 fpCommandGlobalLineWidthScale->SetDefaultValue(1.); 221 229 222 fpCommandGlobalMarkerScale = new G4UIcmdWith 230 fpCommandGlobalMarkerScale = new G4UIcmdWithADouble 223 ("/vis/viewer/set/globalMarkerScale", this); << 231 ("/vis/viewer/set/globalMarkerScale", this); 224 fpCommandGlobalMarkerScale->SetGuidance 232 fpCommandGlobalMarkerScale->SetGuidance 225 ("Multiplies marker sizes by this factor."); << 233 ("Multiplies marker sizes by this factor."); 226 fpCommandGlobalMarkerScale-> 234 fpCommandGlobalMarkerScale-> 227 SetParameterName("scale-factor", omitable=tr << 235 SetParameterName("scale-factor", omitable=true); 228 fpCommandGlobalMarkerScale->SetDefaultValue( 236 fpCommandGlobalMarkerScale->SetDefaultValue(1.); 229 237 230 fpCommandHiddenEdge = 238 fpCommandHiddenEdge = 231 new G4UIcmdWithABool("/vis/viewer/set/hidden << 239 new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this); 232 fpCommandHiddenEdge->SetGuidance 240 fpCommandHiddenEdge->SetGuidance 233 ("Edges become hidden/seen in wireframe or s << 241 ("Edges become hidden/seen in wireframe or surface mode."); 234 fpCommandHiddenEdge->SetParameterName("hidde 242 fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true); 235 fpCommandHiddenEdge->SetDefaultValue(true); 243 fpCommandHiddenEdge->SetDefaultValue(true); 236 244 237 fpCommandHiddenMarker = 245 fpCommandHiddenMarker = 238 new G4UIcmdWithABool("/vis/viewer/set/hidden << 246 new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this); 239 fpCommandHiddenMarker->SetGuidance 247 fpCommandHiddenMarker->SetGuidance 240 ("If true, closer objects hide markers. Othe << 248 ("If true, closer objects hide markers. Otherwise, markers always show."); 241 fpCommandHiddenMarker->SetParameterName("hid 249 fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true); 242 fpCommandHiddenMarker->SetDefaultValue(true) 250 fpCommandHiddenMarker->SetDefaultValue(true); 243 251 244 fpCommandLightsMove = new G4UIcmdWithAString 252 fpCommandLightsMove = new G4UIcmdWithAString 245 ("/vis/viewer/set/lightsMove",this); << 253 ("/vis/viewer/set/lightsMove",this); 246 fpCommandLightsMove->SetGuidance 254 fpCommandLightsMove->SetGuidance 247 ("Lights move with camera or with object"); << 255 ("Lights move with camera or with object"); 248 fpCommandLightsMove->SetParameterName("light 256 fpCommandLightsMove->SetParameterName("lightsMove",omitable = false); 249 fpCommandLightsMove->SetCandidates 257 fpCommandLightsMove->SetCandidates 250 ("cam camera with-camera obj object with-obj << 258 ("cam camera with-camera obj object with-object"); 251 259 252 fpCommandLightsThetaPhi = new G4UIcommand 260 fpCommandLightsThetaPhi = new G4UIcommand 253 ("/vis/viewer/set/lightsThetaPhi", this); << 261 ("/vis/viewer/set/lightsThetaPhi", this); 254 fpCommandLightsThetaPhi->SetGuidance 262 fpCommandLightsThetaPhi->SetGuidance 255 ("Set direction from target to lights."); << 263 ("Set direction from target to lights."); 256 parameter = new G4UIparameter("theta", 'd', 264 parameter = new G4UIparameter("theta", 'd', omitable = true); 257 parameter -> SetDefaultValue(60.); 265 parameter -> SetDefaultValue(60.); 258 fpCommandLightsThetaPhi -> SetParameter (par 266 fpCommandLightsThetaPhi -> SetParameter (parameter); 259 parameter = new G4UIparameter("phi", 'd', om 267 parameter = new G4UIparameter("phi", 'd', omitable = true); 260 parameter -> SetDefaultValue(45.); 268 parameter -> SetDefaultValue(45.); 261 fpCommandLightsThetaPhi -> SetParameter (par 269 fpCommandLightsThetaPhi -> SetParameter (parameter); 262 parameter = new G4UIparameter ("unit", 's', 270 parameter = new G4UIparameter ("unit", 's', omitable = true); 263 parameter -> SetDefaultValue ("deg"); 271 parameter -> SetDefaultValue ("deg"); 264 fpCommandLightsThetaPhi -> SetParameter (par 272 fpCommandLightsThetaPhi -> SetParameter (parameter); 265 273 266 fpCommandLightsVector = new G4UIcommand 274 fpCommandLightsVector = new G4UIcommand 267 ("/vis/viewer/set/lightsVector", this); << 275 ("/vis/viewer/set/lightsVector", this); 268 fpCommandLightsVector->SetGuidance 276 fpCommandLightsVector->SetGuidance 269 ("Set direction from target to lights."); << 277 ("Set direction from target to lights."); 270 parameter = new G4UIparameter("x", 'd', omit 278 parameter = new G4UIparameter("x", 'd', omitable = true); 271 parameter -> SetDefaultValue (1); 279 parameter -> SetDefaultValue (1); 272 fpCommandLightsVector -> SetParameter (param 280 fpCommandLightsVector -> SetParameter (parameter); 273 parameter = new G4UIparameter("y", 'd', omit 281 parameter = new G4UIparameter("y", 'd', omitable = true); 274 parameter -> SetDefaultValue (1); 282 parameter -> SetDefaultValue (1); 275 fpCommandLightsVector -> SetParameter (param 283 fpCommandLightsVector -> SetParameter (parameter); 276 parameter = new G4UIparameter ("z", 'd', omi 284 parameter = new G4UIparameter ("z", 'd', omitable = true); 277 parameter -> SetDefaultValue (1); 285 parameter -> SetDefaultValue (1); 278 fpCommandLightsVector -> SetParameter (param 286 fpCommandLightsVector -> SetParameter (parameter); 279 287 280 fpCommandLineSegments = new G4UIcmdWithAnInt 288 fpCommandLineSegments = new G4UIcmdWithAnInteger 281 ("/vis/viewer/set/lineSegmentsPerCircle",thi << 289 ("/vis/viewer/set/lineSegmentsPerCircle",this); 282 fpCommandLineSegments->SetGuidance 290 fpCommandLineSegments->SetGuidance 283 ("Set number of sides per circle for polygon << 291 ("Set number of sides per circle for polygon/polyhedron drawing."); 284 fpCommandLineSegments->SetGuidance 292 fpCommandLineSegments->SetGuidance 285 ("Refers to graphical representation of obje << 293 ("Refers to graphical representation of objects with curved lines/surfaces."); 286 fpCommandLineSegments->SetParameterName("lin 294 fpCommandLineSegments->SetParameterName("line-segments",omitable = true); 287 fpCommandLineSegments->SetDefaultValue(24); 295 fpCommandLineSegments->SetDefaultValue(24); 288 296 289 fpCommandLineWidth = new G4UIcmdWithoutParam << 290 ("/vis/viewer/set/lineWidth",this); << 291 fpCommandLineWidth->SetGuidance << 292 ("Use \"/vis/viewer/set/globalLineWidthScale << 293 "\nFor trajectories use \"/vis/modeling/tra << 294 "\nFor volumes use \"/vis/geometry/set/line << 295 << 296 fpCommandNumberOfCloudPoints = new G4UIcmdWi << 297 ("/vis/viewer/set/numberOfCloudPoints",this) << 298 fpCommandNumberOfCloudPoints->SetGuidance << 299 ("Set number of points to be used for cloud << 300 fpCommandNumberOfCloudPoints->SetParameterNa << 301 fpCommandNumberOfCloudPoints->SetDefaultValu << 302 << 303 fpCommandPicking = new G4UIcmdWithABool 297 fpCommandPicking = new G4UIcmdWithABool 304 ("/vis/viewer/set/picking",this); << 298 ("/vis/viewer/set/picking",this); 305 fpCommandPicking->SetGuidance("Sets picking, 299 fpCommandPicking->SetGuidance("Sets picking, if available."); 306 fpCommandPicking->SetGuidance 300 fpCommandPicking->SetGuidance 307 ("If true, view is set up for picking, if av << 301 ("If true, view is set up for picking, if available."); 308 fpCommandPicking->SetGuidance 302 fpCommandPicking->SetGuidance 309 ("You may need to issue \"/vis/viewer/update << 303 ("You may need to issue \"/vis/viewer/update\"."); 310 fpCommandPicking->SetGuidance 304 fpCommandPicking->SetGuidance 311 ("For required actions, watch for instructio << 305 ("For required actions, watch for instructions for viewer."); 312 fpCommandPicking->SetParameterName("picking" 306 fpCommandPicking->SetParameterName("picking",omitable = true); 313 fpCommandPicking->SetDefaultValue(true); 307 fpCommandPicking->SetDefaultValue(true); 314 308 315 fpCommandProjection = new G4UIcommand("/vis/ 309 fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this); 316 fpCommandProjection->SetGuidance 310 fpCommandProjection->SetGuidance 317 ("Set projection style - o[rthogonal] or p[e << 311 ("Set projection style - o[rthogonal] or p[erspective]." 318 "\nIf p[erspective], also set field half an << 312 "\nIf p[erspective], also set field half angle."); 319 parameter = new G4UIparameter("projection",' 313 parameter = new G4UIparameter("projection",'s',omitable = true); 320 parameter->SetParameterCandidates("o orthogo 314 parameter->SetParameterCandidates("o orthogonal p perspective"); 321 parameter->SetDefaultValue("orthogonal"); 315 parameter->SetDefaultValue("orthogonal"); 322 fpCommandProjection->SetParameter(parameter) 316 fpCommandProjection->SetParameter(parameter); 323 parameter = new G4UIparameter("field-half-an 317 parameter = new G4UIparameter("field-half-angle",'d',omitable = true); 324 parameter->SetDefaultValue(30.); 318 parameter->SetDefaultValue(30.); 325 //parameter->SetCurrentAsDefault(true); 319 //parameter->SetCurrentAsDefault(true); 326 fpCommandProjection->SetParameter(parameter) 320 fpCommandProjection->SetParameter(parameter); 327 parameter = new G4UIparameter("unit",'s',omi 321 parameter = new G4UIparameter("unit",'s',omitable = true); 328 parameter->SetDefaultValue("deg"); 322 parameter->SetDefaultValue("deg"); 329 //parameter->SetCurrentAsDefault(true); 323 //parameter->SetCurrentAsDefault(true); 330 fpCommandProjection->SetParameter(parameter) 324 fpCommandProjection->SetParameter(parameter); 331 325 332 fpCommandRotationStyle = new G4UIcmdWithAStr 326 fpCommandRotationStyle = new G4UIcmdWithAString 333 ("/vis/viewer/set/rotationStyle",this); << 327 ("/vis/viewer/set/rotationStyle",this); 334 fpCommandRotationStyle->SetGuidance 328 fpCommandRotationStyle->SetGuidance 335 ("Set style of rotation - constrainUpDirecti << 329 ("Set style of rotation - constrainUpDirection or freeRotation."); 336 fpCommandRotationStyle->SetGuidance 330 fpCommandRotationStyle->SetGuidance 337 ("constrainUpDirection: conventional HEP vie << 331 ("constrainUpDirection: conventional HEP view."); 338 fpCommandRotationStyle->SetGuidance 332 fpCommandRotationStyle->SetGuidance 339 ("freeRotation: Google-like rotation, using << 333 ("freeRotation: Google-like rotation, using mouse-grab."); 340 fpCommandRotationStyle->SetParameterName ("s 334 fpCommandRotationStyle->SetParameterName ("style",omitable = false); 341 fpCommandRotationStyle->SetCandidates("const 335 fpCommandRotationStyle->SetCandidates("constrainUpDirection freeRotation"); 342 336 343 fpCommandSectionPlane = new G4UIcommand("/vi 337 fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this); 344 fpCommandSectionPlane -> SetGuidance 338 fpCommandSectionPlane -> SetGuidance 345 ("Set plane for drawing section (DCUT)."); << 339 ("Set plane for drawing section (DCUT)."); 346 fpCommandSectionPlane -> SetGuidance 340 fpCommandSectionPlane -> SetGuidance 347 ("E.g., for a y-z plane at x = 1 cm:" << 341 ("E.g., for a y-z plane at x = 1 cm:" 348 "\n\"/vis/viewer/set/sectionPlane on 1 0 0 << 342 "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"." 349 "\nTo turn off: /vis/viewer/set/sectionPlan << 343 "\nTo turn off: /vis/viewer/set/sectionPlane off"); 350 parameter = new G4UIparameter("Selector",' 344 parameter = new G4UIparameter("Selector",'c',true); 351 parameter -> SetDefaultValue ("on"); 345 parameter -> SetDefaultValue ("on"); 352 fpCommandSectionPlane->SetParameter(paramete 346 fpCommandSectionPlane->SetParameter(parameter); 353 parameter = new G4UIparameter("x",'d',omit 347 parameter = new G4UIparameter("x",'d',omitable = true); 354 parameter -> SetDefaultValue (0); 348 parameter -> SetDefaultValue (0); 355 parameter -> SetGuidance ("Coordinate 349 parameter -> SetGuidance ("Coordinate of point on the plane."); 356 fpCommandSectionPlane->SetParameter(paramete 350 fpCommandSectionPlane->SetParameter(parameter); 357 parameter = new G4UIparameter("y",'d',omit 351 parameter = new G4UIparameter("y",'d',omitable = true); 358 parameter -> SetDefaultValue (0); 352 parameter -> SetDefaultValue (0); 359 parameter -> SetGuidance ("Coordinate 353 parameter -> SetGuidance ("Coordinate of point on the plane."); 360 fpCommandSectionPlane->SetParameter(paramete 354 fpCommandSectionPlane->SetParameter(parameter); 361 parameter = new G4UIparameter("z",'d',omit 355 parameter = new G4UIparameter("z",'d',omitable = true); 362 parameter -> SetDefaultValue (0); 356 parameter -> SetDefaultValue (0); 363 parameter -> SetGuidance ("Coordinate 357 parameter -> SetGuidance ("Coordinate of point on the plane."); 364 fpCommandSectionPlane->SetParameter(paramete 358 fpCommandSectionPlane->SetParameter(parameter); 365 parameter = new G4UIparameter("unit",'s',o 359 parameter = new G4UIparameter("unit",'s',omitable = true); 366 parameter -> SetDefaultValue ("m"); 360 parameter -> SetDefaultValue ("m"); 367 parameter -> SetGuidance ("Unit of poi 361 parameter -> SetGuidance ("Unit of point on the plane."); 368 fpCommandSectionPlane->SetParameter(paramete 362 fpCommandSectionPlane->SetParameter(parameter); 369 parameter = new G4UIparameter("nx",'d',omi 363 parameter = new G4UIparameter("nx",'d',omitable = true); 370 parameter -> SetDefaultValue (1); 364 parameter -> SetDefaultValue (1); 371 parameter -> SetGuidance ("Component o 365 parameter -> SetGuidance ("Component of plane normal."); 372 fpCommandSectionPlane->SetParameter(paramete 366 fpCommandSectionPlane->SetParameter(parameter); 373 parameter = new G4UIparameter("ny",'d',omi 367 parameter = new G4UIparameter("ny",'d',omitable = true); 374 parameter -> SetDefaultValue (0); 368 parameter -> SetDefaultValue (0); 375 parameter -> SetGuidance ("Component o 369 parameter -> SetGuidance ("Component of plane normal."); 376 fpCommandSectionPlane->SetParameter(paramete 370 fpCommandSectionPlane->SetParameter(parameter); 377 parameter = new G4UIparameter("nz",'d',omi 371 parameter = new G4UIparameter("nz",'d',omitable = true); 378 parameter -> SetDefaultValue (0); 372 parameter -> SetDefaultValue (0); 379 parameter -> SetGuidance ("Component o 373 parameter -> SetGuidance ("Component of plane normal."); 380 fpCommandSectionPlane->SetParameter(paramete 374 fpCommandSectionPlane->SetParameter(parameter); 381 375 382 fpCommandSpecialMeshRendering = new G4UIcmdW << 383 ("/vis/viewer/set/specialMeshRendering",this << 384 fpCommandSpecialMeshRendering -> SetGuidance << 385 ("Request special rendering of volumes (mesh << 386 fpCommandSpecialMeshRendering->SetParameterN << 387 fpCommandSpecialMeshRendering->SetDefaultVal << 388 << 389 fpCommandSpecialMeshRenderingOption = new G4 << 390 ("/vis/viewer/set/specialMeshRenderingOption << 391 fpCommandSpecialMeshRenderingOption->SetGuid << 392 ("Set special mesh rendering option - \"defa << 393 fpCommandSpecialMeshRenderingOption->SetPara << 394 fpCommandSpecialMeshRenderingOption->SetCand << 395 fpCommandSpecialMeshRenderingOption->SetDefa << 396 << 397 fpCommandSpecialMeshVolumes = new G4UIcomman << 398 ("/vis/viewer/set/specialMeshVolumes",this); << 399 fpCommandSpecialMeshVolumes -> SetGuidance << 400 ("Specify the volumes for special rendering. << 401 "\nand is interpreted to mean \"all found m << 402 fpCommandSpecialMeshVolumes->SetGuidance << 403 ("Please provide a list of space-separated p << 404 "\nnumber pairs. Negative copy number means << 405 parameter = new G4UIparameter("volumes",'s', << 406 parameter->SetGuidance << 407 ("List of physical volume names and copy num << 408 fpCommandSpecialMeshVolumes->SetParameter(pa << 409 << 410 fpCommandStyle = new G4UIcmdWithAString ("/v 376 fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this); 411 fpCommandStyle->SetGuidance 377 fpCommandStyle->SetGuidance 412 ("Set style of drawing - w[ireframe] or s[ur << 378 ("Set style of drawing - w[ireframe] or s[urface]."); 413 fpCommandStyle->SetGuidance << 379 fpCommandStyle->SetGuidance 414 ("(Hidden line drawing is controlled by \"/v << 380 ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)"); 415 fpCommandStyle->SetParameterName ("style",om 381 fpCommandStyle->SetParameterName ("style",omitable = false); 416 fpCommandStyle->SetCandidates("w wireframe s << 382 fpCommandStyle->SetCandidates("w wireframe s surface"); 417 383 418 fpCommandTargetPoint = new G4UIcmdWith3Vecto 384 fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit 419 ("/vis/viewer/set/targetPoint", this); << 385 ("/vis/viewer/set/targetPoint", this); 420 fpCommandTargetPoint->SetGuidance 386 fpCommandTargetPoint->SetGuidance 421 ("Set target point."); << 387 ("Set target point."); 422 fpCommandTargetPoint->SetGuidance 388 fpCommandTargetPoint->SetGuidance 423 ("This sets the \"Current Target Point\" rel << 389 ("This sets the \"Current Target Point\" relative to the \"Standard"); 424 fpCommandTargetPoint->SetGuidance 390 fpCommandTargetPoint->SetGuidance 425 ("Target Point\" so that the actual target p << 391 ("Target Point\" so that the actual target point is as requested."); 426 fpCommandTargetPoint->SetGuidance 392 fpCommandTargetPoint->SetGuidance 427 ("(See G4ViewParameters.hh for an explanatio << 393 ("(See G4ViewParameters.hh for an explanation of target points.)"); 428 fpCommandTargetPoint->SetParameterName("x", 394 fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false); 429 fpCommandTargetPoint->SetUnitCategory("Lengt 395 fpCommandTargetPoint->SetUnitCategory("Length"); 430 396 431 fpCommandUpThetaPhi = new G4UIcommand 397 fpCommandUpThetaPhi = new G4UIcommand 432 ("/vis/viewer/set/upThetaPhi", this); << 398 ("/vis/viewer/set/upThetaPhi", this); 433 fpCommandUpThetaPhi -> SetGuidance ("Set up 399 fpCommandUpThetaPhi -> SetGuidance ("Set up vector."); 434 fpCommandUpThetaPhi -> SetGuidance 400 fpCommandUpThetaPhi -> SetGuidance 435 ("Viewer will attempt always to show this di << 401 ("Viewer will attempt always to show this direction upwards."); 436 parameter = new G4UIparameter("theta", 'd', 402 parameter = new G4UIparameter("theta", 'd', omitable = true); 437 parameter -> SetDefaultValue (90.); 403 parameter -> SetDefaultValue (90.); 438 fpCommandUpThetaPhi -> SetParameter (paramet 404 fpCommandUpThetaPhi -> SetParameter (parameter); 439 parameter = new G4UIparameter("phi", 'd', om 405 parameter = new G4UIparameter("phi", 'd', omitable = true); 440 parameter -> SetDefaultValue (90.); 406 parameter -> SetDefaultValue (90.); 441 fpCommandUpThetaPhi -> SetParameter (paramet 407 fpCommandUpThetaPhi -> SetParameter (parameter); 442 parameter = new G4UIparameter ("unit", 's', 408 parameter = new G4UIparameter ("unit", 's', omitable = true); 443 parameter -> SetDefaultValue ("deg"); 409 parameter -> SetDefaultValue ("deg"); 444 fpCommandUpThetaPhi -> SetParameter (paramet 410 fpCommandUpThetaPhi -> SetParameter (parameter); 445 411 446 fpCommandUpVector = new G4UIcommand 412 fpCommandUpVector = new G4UIcommand 447 ("/vis/viewer/set/upVector", this); << 413 ("/vis/viewer/set/upVector", this); 448 fpCommandUpVector -> SetGuidance ("Set up ve 414 fpCommandUpVector -> SetGuidance ("Set up vector."); 449 fpCommandUpVector -> SetGuidance 415 fpCommandUpVector -> SetGuidance 450 ("Viewer will attempt always to show this di << 416 ("Viewer will attempt always to show this direction upwards."); 451 parameter = new G4UIparameter("x", 'd', omit 417 parameter = new G4UIparameter("x", 'd', omitable = true); 452 parameter -> SetDefaultValue (0.); 418 parameter -> SetDefaultValue (0.); 453 fpCommandUpVector -> SetParameter (parameter 419 fpCommandUpVector -> SetParameter (parameter); 454 parameter = new G4UIparameter("y", 'd', omit 420 parameter = new G4UIparameter("y", 'd', omitable = true); 455 parameter -> SetDefaultValue (1.); 421 parameter -> SetDefaultValue (1.); 456 fpCommandUpVector -> SetParameter (parameter 422 fpCommandUpVector -> SetParameter (parameter); 457 parameter = new G4UIparameter ("z", 'd', omi 423 parameter = new G4UIparameter ("z", 'd', omitable = true); 458 parameter -> SetDefaultValue (0.); 424 parameter -> SetDefaultValue (0.); 459 fpCommandUpVector -> SetParameter (parameter 425 fpCommandUpVector -> SetParameter (parameter); 460 426 461 fpCommandViewpointThetaPhi = new G4UIcommand 427 fpCommandViewpointThetaPhi = new G4UIcommand 462 ("/vis/viewer/set/viewpointThetaPhi", this); << 428 ("/vis/viewer/set/viewpointThetaPhi", this); 463 fpCommandViewpointThetaPhi -> SetGuidance 429 fpCommandViewpointThetaPhi -> SetGuidance 464 ("Set direction from target to camera."); << 430 ("Set direction from target to camera."); 465 fpCommandViewpointThetaPhi -> SetGuidance 431 fpCommandViewpointThetaPhi -> SetGuidance 466 ("Also changes lightpoint direction if light 432 ("Also changes lightpoint direction if lights are set to move with camera."); 467 parameter = new G4UIparameter("theta", 'd', 433 parameter = new G4UIparameter("theta", 'd', omitable = true); 468 parameter -> SetDefaultValue (60.); 434 parameter -> SetDefaultValue (60.); 469 fpCommandViewpointThetaPhi -> SetParameter ( 435 fpCommandViewpointThetaPhi -> SetParameter (parameter); 470 parameter = new G4UIparameter("phi", 'd', om 436 parameter = new G4UIparameter("phi", 'd', omitable = true); 471 parameter -> SetDefaultValue (45.); 437 parameter -> SetDefaultValue (45.); 472 fpCommandViewpointThetaPhi -> SetParameter ( 438 fpCommandViewpointThetaPhi -> SetParameter (parameter); 473 parameter = new G4UIparameter ("unit", 's', 439 parameter = new G4UIparameter ("unit", 's', omitable = true); 474 parameter -> SetDefaultValue ("deg"); 440 parameter -> SetDefaultValue ("deg"); 475 fpCommandViewpointThetaPhi -> SetParameter ( 441 fpCommandViewpointThetaPhi -> SetParameter (parameter); 476 442 477 fpCommandViewpointVector = new G4UIcommand 443 fpCommandViewpointVector = new G4UIcommand 478 ("/vis/viewer/set/viewpointVector", this); << 444 ("/vis/viewer/set/viewpointVector", this); 479 fpCommandViewpointVector -> SetGuidance 445 fpCommandViewpointVector -> SetGuidance 480 ("Set direction from target to camera."); << 446 ("Set direction from target to camera."); 481 fpCommandViewpointVector -> SetGuidance 447 fpCommandViewpointVector -> SetGuidance 482 ("Also changes lightpoint direction if light 448 ("Also changes lightpoint direction if lights are set to move with camera."); 483 parameter = new G4UIparameter("x", 'd', omit 449 parameter = new G4UIparameter("x", 'd', omitable = true); 484 parameter -> SetDefaultValue (1.); 450 parameter -> SetDefaultValue (1.); 485 fpCommandViewpointVector -> SetParameter (pa 451 fpCommandViewpointVector -> SetParameter (parameter); 486 parameter = new G4UIparameter("y", 'd', omit 452 parameter = new G4UIparameter("y", 'd', omitable = true); 487 parameter -> SetDefaultValue (1.); 453 parameter -> SetDefaultValue (1.); 488 fpCommandViewpointVector -> SetParameter (pa 454 fpCommandViewpointVector -> SetParameter (parameter); 489 parameter = new G4UIparameter ("z", 'd', omi 455 parameter = new G4UIparameter ("z", 'd', omitable = true); 490 parameter -> SetDefaultValue (1.); 456 parameter -> SetDefaultValue (1.); 491 fpCommandViewpointVector -> SetParameter (pa 457 fpCommandViewpointVector -> SetParameter (parameter); 492 << 493 fpTimeWindowDirectory = new G4UIdirectory (" << 494 fpTimeWindowDirectory -> SetGuidance ("Set t << 495 G4String timeWindowGuidance = << 496 "For these commands use" << 497 "\n /vis/scene/add/trajectories rich" << 498 "\n /vis/modeling/trajectories/drawByCharge << 499 "\nthen typically" << 500 "\n /vis/viewer/set/timeWindow/displayLight << 501 "\n /vis/viewer/set/timeWindow/displayHeadT << 502 "\n /vis/viewer/set/timeWindow/fadeFactor 1 << 503 "\n /run/beamOn # or several until you get << 504 "\n /vis/viewer/set/timeWindow/startTime 0 << 505 "\n /vis/viewer/save" << 506 "\n /vis/viewer/set/timeWindow/startTime 1 << 507 "\nthen zoom, pan etc to a view of interest << 508 "\n /vis/viewer/save" << 509 "\nthen repeat with next start time, another << 510 "\n /vis/viewer/interpolate"; << 511 << 512 fpCommandTimeWindowDisplayHeadTime = << 513 new G4UIcommand("/vis/viewer/set/timeWindow/ << 514 fpCommandTimeWindowDisplayHeadTime->SetGuida << 515 ("Display head time of range in 2D text."); << 516 fpCommandTimeWindowDisplayHeadTime->SetGuida << 517 parameter = new G4UIparameter ("displayHeadT << 518 parameter->SetDefaultValue(false); << 519 fpCommandTimeWindowDisplayHeadTime->SetParam << 520 parameter = new G4UIparameter ("screenX", 'd << 521 parameter->SetGuidance("-1 < screenX < 1"); << 522 parameter->SetParameterRange("screenX >= -1. << 523 parameter->SetDefaultValue(-0.9); << 524 fpCommandTimeWindowDisplayHeadTime->SetParam << 525 parameter = new G4UIparameter ("screenY", 'd << 526 parameter->SetGuidance("-1 < screenY < 1"); << 527 parameter->SetParameterRange("screenY >= -1. << 528 parameter->SetDefaultValue(-0.9); << 529 fpCommandTimeWindowDisplayHeadTime->SetParam << 530 parameter = new G4UIparameter ("screenSize", << 531 parameter->SetDefaultValue(24.); << 532 fpCommandTimeWindowDisplayHeadTime->SetParam << 533 parameter = new G4UIparameter ("red", 'd', o << 534 parameter->SetParameterRange("red >= 0. && r << 535 parameter->SetDefaultValue(0.); << 536 fpCommandTimeWindowDisplayHeadTime->SetParam << 537 parameter = new G4UIparameter ("green", 'd', << 538 parameter->SetParameterRange("green >= 0. && << 539 parameter->SetDefaultValue(1.); << 540 fpCommandTimeWindowDisplayHeadTime->SetParam << 541 parameter = new G4UIparameter ("blue", 'd', << 542 parameter->SetParameterRange("blue >= 0. && << 543 parameter->SetDefaultValue(1.); << 544 fpCommandTimeWindowDisplayHeadTime->SetParam << 545 << 546 fpCommandTimeWindowDisplayLightFront = << 547 new G4UIcommand("/vis/viewer/set/timeWindow/ << 548 fpCommandTimeWindowDisplayLightFront->SetGui << 549 ("Display the light front at head time."); << 550 fpCommandTimeWindowDisplayLightFront->SetGui << 551 ("Tip: The trajectories can appear of jump a << 552 "\nbecause their time range overlaps the vi << 553 "\naverage out this discrete time effect, a << 554 "\nhalf the trajectories interval. E.g., if << 555 "\ninterval is 0.01 ns:" << 556 "\n /vis/viewer/set/timeWindow/displayLigh << 557 "\nTo prevent them beating the light front << 558 "\n /vis/viewer/set/timeWindow/displayLigh << 559 fpCommandTimeWindowDisplayLightFront->SetGui << 560 parameter = new G4UIparameter ("displayLight << 561 parameter->SetDefaultValue(true); << 562 fpCommandTimeWindowDisplayLightFront->SetPar << 563 parameter = new G4UIparameter ("originX", 'd << 564 parameter->SetDefaultValue(0.); << 565 fpCommandTimeWindowDisplayLightFront->SetPar << 566 parameter = new G4UIparameter ("originY", 'd << 567 parameter->SetDefaultValue(0.); << 568 fpCommandTimeWindowDisplayLightFront->SetPar << 569 parameter = new G4UIparameter ("originZ", 'd << 570 parameter->SetDefaultValue(0.); << 571 fpCommandTimeWindowDisplayLightFront->SetPar << 572 parameter = new G4UIparameter ("space_unit", << 573 parameter->SetDefaultValue("m"); << 574 fpCommandTimeWindowDisplayLightFront->SetPar << 575 parameter = new G4UIparameter ("originT", 'd << 576 parameter->SetDefaultValue(0.); << 577 fpCommandTimeWindowDisplayLightFront->SetPar << 578 parameter = new G4UIparameter ("time_unit", << 579 parameter->SetDefaultValue("s"); << 580 fpCommandTimeWindowDisplayLightFront->SetPar << 581 parameter = new G4UIparameter ("red", 'd', o << 582 parameter->SetParameterRange("red >= 0. && r << 583 parameter->SetDefaultValue(0.); << 584 fpCommandTimeWindowDisplayLightFront->SetPar << 585 parameter = new G4UIparameter ("green", 'd', << 586 parameter->SetParameterRange("green >= 0. && << 587 parameter->SetDefaultValue(1.); << 588 fpCommandTimeWindowDisplayLightFront->SetPar << 589 parameter = new G4UIparameter ("blue", 'd', << 590 parameter->SetParameterRange("blue >= 0. && << 591 parameter->SetDefaultValue(0.); << 592 fpCommandTimeWindowDisplayLightFront->SetPar << 593 << 594 fpCommandTimeWindowEndTime = << 595 new G4UIcommand("/vis/viewer/set/timeWindow/ << 596 fpCommandTimeWindowEndTime->SetGuidance("Set << 597 fpCommandTimeWindowEndTime->SetGuidance(time << 598 parameter = new G4UIparameter ("end-time", ' << 599 parameter->SetDefaultValue(G4VisAttributes:: << 600 fpCommandTimeWindowEndTime->SetParameter(par << 601 parameter = new G4UIparameter ("end-time-uni << 602 parameter->SetDefaultValue("ns"); << 603 fpCommandTimeWindowEndTime->SetParameter(par << 604 parameter = new G4UIparameter ("time-range", << 605 parameter->SetDefaultValue(-1.); << 606 fpCommandTimeWindowEndTime->SetParameter(par << 607 parameter = new G4UIparameter ("time-range-u << 608 parameter->SetDefaultValue("ns"); << 609 fpCommandTimeWindowEndTime->SetParameter(par << 610 << 611 fpCommandTimeWindowFadeFactor = << 612 new G4UIcmdWithADouble("/vis/viewer/set/time << 613 fpCommandTimeWindowFadeFactor->SetGuidance << 614 ("0: no fade; 1: maximum fade with time wind << 615 fpCommandTimeWindowFadeFactor->SetGuidance(t << 616 fpCommandTimeWindowFadeFactor->SetParameterN << 617 fpCommandTimeWindowFadeFactor->SetRange("fad << 618 fpCommandTimeWindowFadeFactor->SetDefaultVal << 619 << 620 fpCommandTimeWindowStartTime = << 621 new G4UIcommand("/vis/viewer/set/timeWindow/ << 622 fpCommandTimeWindowStartTime->SetGuidance("S << 623 fpCommandTimeWindowStartTime->SetGuidance(ti << 624 parameter = new G4UIparameter ("start-time", << 625 parameter->SetDefaultValue(-G4VisAttributes: << 626 fpCommandTimeWindowStartTime->SetParameter(p << 627 parameter = new G4UIparameter ("start-time-u << 628 parameter->SetDefaultValue("ns"); << 629 fpCommandTimeWindowStartTime->SetParameter(p << 630 parameter = new G4UIparameter ("time-range", << 631 parameter->SetDefaultValue(-1.); << 632 fpCommandTimeWindowStartTime->SetParameter(p << 633 parameter = new G4UIparameter ("time-range-u << 634 parameter->SetDefaultValue("ns"); << 635 fpCommandTimeWindowStartTime->SetParameter(p << 636 } 458 } 637 459 638 G4VisCommandsViewerSet::~G4VisCommandsViewerSe 460 G4VisCommandsViewerSet::~G4VisCommandsViewerSet() { 639 delete fpCommandTimeWindowStartTime; << 461 delete fpCommandAll; 640 delete fpCommandTimeWindowFadeFactor; << 641 delete fpCommandTimeWindowEndTime; << 642 delete fpCommandTimeWindowDisplayLightFront; << 643 delete fpCommandTimeWindowDisplayHeadTime; << 644 delete fpTimeWindowDirectory; << 645 delete fpCommandViewpointVector; << 646 delete fpCommandViewpointThetaPhi; << 647 delete fpCommandUpVector; << 648 delete fpCommandUpThetaPhi; << 649 delete fpCommandTargetPoint; << 650 delete fpCommandStyle; << 651 delete fpCommandSpecialMeshVolumes; << 652 delete fpCommandSpecialMeshRenderingOption; << 653 delete fpCommandSpecialMeshRendering; << 654 delete fpCommandSectionPlane; << 655 delete fpCommandRotationStyle; << 656 delete fpCommandProjection; << 657 delete fpCommandPicking; << 658 delete fpCommandNumberOfCloudPoints; << 659 delete fpCommandLineWidth; << 660 delete fpCommandLineSegments; << 661 delete fpCommandLightsVector; << 662 delete fpCommandLightsThetaPhi; << 663 delete fpCommandLightsMove; << 664 delete fpCommandHiddenMarker; << 665 delete fpCommandHiddenEdge; << 666 delete fpCommandGlobalMarkerScale; << 667 delete fpCommandGlobalLineWidthScale; << 668 delete fpCommandExplodeFactor; << 669 delete fpCommandEdge; << 670 delete fpCommandDefaultTextColour; << 671 delete fpCommandDefaultColour; << 672 delete fpCommandCutawayMode; << 673 delete fpCommandCulling; << 674 delete fpCommandBackground; << 675 delete fpCommandAuxEdge; 462 delete fpCommandAuxEdge; 676 delete fpCommandAutoRefresh; 463 delete fpCommandAutoRefresh; 677 delete fpCommandAll; << 464 delete fpCommandBackground; >> 465 delete fpCommandCulling; >> 466 delete fpCommandCutawayMode; >> 467 delete fpCommandDefaultColour; >> 468 delete fpCommandDefaultTextColour; >> 469 delete fpCommandEdge; >> 470 delete fpCommandExplodeFactor; >> 471 delete fpCommandGlobalLineWidthScale; >> 472 delete fpCommandGlobalMarkerScale; >> 473 delete fpCommandHiddenEdge; >> 474 delete fpCommandHiddenMarker; >> 475 delete fpCommandLineSegments; >> 476 delete fpCommandLightsMove; >> 477 delete fpCommandLightsThetaPhi; >> 478 delete fpCommandLightsVector; >> 479 delete fpCommandPicking; >> 480 delete fpCommandProjection; >> 481 delete fpCommandRotationStyle; >> 482 delete fpCommandSectionPlane; >> 483 delete fpCommandStyle; >> 484 delete fpCommandTargetPoint; >> 485 delete fpCommandUpThetaPhi; >> 486 delete fpCommandUpVector; >> 487 delete fpCommandViewpointThetaPhi; >> 488 delete fpCommandViewpointVector; 678 } 489 } 679 490 680 G4String G4VisCommandsViewerSet::GetCurrentVal 491 G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) { 681 return ""; 492 return ""; 682 } 493 } 683 494 684 void G4VisCommandsViewerSet::SetNewValue 495 void G4VisCommandsViewerSet::SetNewValue 685 (G4UIcommand* command,G4String newValue) { 496 (G4UIcommand* command,G4String newValue) { 686 497 687 G4VisManager::Verbosity verbosity = fpVisMan 498 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity(); 688 499 689 G4VViewer* currentViewer = fpVisManager->Get 500 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer(); 690 if (!currentViewer) { 501 if (!currentViewer) { 691 if (verbosity >= G4VisManager::errors) { 502 if (verbosity >= G4VisManager::errors) { 692 G4warn << << 503 G4cout << 693 "ERROR: G4VisCommandsViewerSet::SetNewVa << 504 "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer." 694 << G4endl; << 505 << G4endl; 695 } 506 } 696 return; 507 return; 697 } 508 } 698 509 699 G4ViewParameters vp = currentViewer->GetView 510 G4ViewParameters vp = currentViewer->GetViewParameters(); 700 511 701 if (command == fpCommandAll) { 512 if (command == fpCommandAll) { 702 G4VViewer* fromViewer = fpVisManager->GetV 513 G4VViewer* fromViewer = fpVisManager->GetViewer(newValue); 703 if (!fromViewer) { 514 if (!fromViewer) { 704 if (verbosity >= G4VisManager::errors) { 515 if (verbosity >= G4VisManager::errors) { 705 G4warn << << 516 G4cout << 706 "ERROR: G4VisCommandsViewerSet::SetNew << 517 "ERROR: G4VisCommandsViewerSet::SetNewValue: all:" 707 "\n unrecognised from-viewer." << 518 "\n unrecognised from-viewer." 708 << G4endl; << 519 << G4endl; 709 } 520 } 710 return; 521 return; 711 } 522 } 712 if (fromViewer == currentViewer) { 523 if (fromViewer == currentViewer) { 713 if (verbosity >= G4VisManager::warnings) 524 if (verbosity >= G4VisManager::warnings) { 714 G4warn << << 525 G4cout << 715 "WARNING: G4VisCommandsViewerSet::SetN << 526 "WARNING: G4VisCommandsViewerSet::SetNewValue: all:" 716 "\n from-viewer and current viewer ar << 527 "\n from-viewer and current viewer are identical." 717 << G4endl; << 528 << G4endl; 718 } 529 } 719 return; 530 return; 720 } 531 } 721 // Copy view parameters except for autoRef << 532 // Copy view parameters except for autoRefresh... 722 auto keepAutoRefresh = vp.IsAutoRefresh(); << 533 G4bool currentAutoRefresh = 723 auto keepBackground = vp.GetBackgroundCol << 534 currentViewer->GetViewParameters().IsAutoRefresh(); 724 vp = fromViewer->GetViewParameters(); 535 vp = fromViewer->GetViewParameters(); 725 vp.SetAutoRefresh(keepAutoRefresh); << 536 vp.SetAutoRefresh(currentAutoRefresh); 726 vp.SetBackgroundColour(keepBackground); << 727 // Concatenate any private vis attributes 537 // Concatenate any private vis attributes modifiers... 728 const std::vector<G4ModelingParameters::Vi 538 const std::vector<G4ModelingParameters::VisAttributesModifier>* 729 privateVAMs = fromViewer->GetPrivateVisAtt << 539 privateVAMs = fromViewer->GetPrivateVisAttributesModifiers(); 730 if (privateVAMs) { 540 if (privateVAMs) { 731 std::vector<G4ModelingParameters::VisAtt 541 std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator i; 732 for (i = privateVAMs->begin(); i != priv 542 for (i = privateVAMs->begin(); i != privateVAMs->end(); ++i) { 733 vp.AddVisAttributesModifier(*i); 543 vp.AddVisAttributesModifier(*i); 734 } 544 } 735 } 545 } 736 if (verbosity >= G4VisManager::confirmatio 546 if (verbosity >= G4VisManager::confirmations) { 737 G4cout << "View parameters of viewer \"" 547 G4cout << "View parameters of viewer \"" << currentViewer->GetName() 738 << "\"\n set to those of viewer \"" << << 548 << "\"\n set to those of viewer \"" << fromViewer->GetName() 739 << "\"." << 549 << "\"." 740 << G4endl; << 550 << G4endl; 741 } << 742 if (verbosity >= G4VisManager::warnings) { << 743 G4warn << "You may need \"/vis/viewer/re << 744 << G4endl; << 745 } 551 } 746 } 552 } 747 553 748 else if (command == fpCommandAutoRefresh) { 554 else if (command == fpCommandAutoRefresh) { 749 G4bool autoRefresh = G4UIcommand::ConvertT 555 G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue); 750 const G4ViewParameters& defaultVP = 556 const G4ViewParameters& defaultVP = 751 currentViewer->GetDefaultViewParameters(); << 557 currentViewer->GetDefaultViewParameters(); 752 if (autoRefresh && !defaultVP.IsAutoRefres 558 if (autoRefresh && !defaultVP.IsAutoRefresh()) { 753 if (verbosity >= G4VisManager::warnings) 559 if (verbosity >= G4VisManager::warnings) { 754 G4warn << 560 G4cout 755 << "WARNING: " << 561 << "WARNING: " 756 << currentViewer->GetName() << " is NO << 562 << currentViewer->GetName() << " is NOT auto-refesh by default" 757 << "\n so cannot be set to auto-refre << 563 << "\n so cannot be set to auto-refresh." 758 << G4endl; << 564 << G4endl; >> 565 return; 759 } 566 } 760 return; << 761 } 567 } 762 vp.SetAutoRefresh(autoRefresh); 568 vp.SetAutoRefresh(autoRefresh); 763 if (verbosity >= G4VisManager::confirmatio 569 if (verbosity >= G4VisManager::confirmations) { 764 G4cout << "Views will "; 570 G4cout << "Views will "; 765 if (!vp.IsAutoRefresh()) G4cout << "not 571 if (!vp.IsAutoRefresh()) G4cout << "not "; 766 G4cout << "be automatically refreshed af 572 G4cout << "be automatically refreshed after a change of view parameters." 767 << G4endl; << 573 << G4endl; 768 } 574 } 769 if (!vp.IsAutoRefresh()) { 575 if (!vp.IsAutoRefresh()) { 770 currentViewer->SetViewParameters(vp); 576 currentViewer->SetViewParameters(vp); 771 return; // Avoid a refresh if auto-refr 577 return; // Avoid a refresh if auto-refresh has been set to off... 772 } // ...otherwise take normal action. 578 } // ...otherwise take normal action. 773 } 579 } 774 580 775 else if (command == fpCommandAuxEdge) { 581 else if (command == fpCommandAuxEdge) { 776 vp.SetAuxEdgeVisible(G4UIcommand::ConvertT 582 vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue)); 777 if (verbosity >= G4VisManager::confirmatio 583 if (verbosity >= G4VisManager::confirmations) { 778 G4cout << "Auxiliary edges will "; 584 G4cout << "Auxiliary edges will "; 779 if (!vp.IsAuxEdgeVisible()) G4cout << "n 585 if (!vp.IsAuxEdgeVisible()) G4cout << "not "; 780 G4cout << "be visible." << G4endl; 586 G4cout << "be visible." << G4endl; 781 } 587 } 782 } 588 } 783 589 784 else if (command == fpCommandBackground) { 590 else if (command == fpCommandBackground) { 785 G4String redOrString; 591 G4String redOrString; 786 G4double green, blue, opacity; 592 G4double green, blue, opacity; 787 std::istringstream iss(newValue); 593 std::istringstream iss(newValue); 788 iss >> redOrString >> green >> blue >> opa 594 iss >> redOrString >> green >> blue >> opacity; 789 G4Colour colour(0.,0.,0.); // Default bla 595 G4Colour colour(0.,0.,0.); // Default black and opaque. 790 ConvertToColour(colour, redOrString, green << 596 const size_t iPos0 = 0; >> 597 if (std::isalpha(redOrString[iPos0])) { >> 598 if (!G4Colour::GetColour(redOrString, colour)) { >> 599 if (verbosity >= G4VisManager::warnings) { >> 600 G4cout << "WARNING: Text colour \"" << redOrString >> 601 << "\" not found. Defaulting to black and opaque." >> 602 << G4endl; >> 603 } >> 604 } >> 605 } else { >> 606 colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue)); >> 607 } >> 608 // Add opacity >> 609 colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity); 791 vp.SetBackgroundColour(colour); 610 vp.SetBackgroundColour(colour); 792 if (verbosity >= G4VisManager::confirmatio 611 if (verbosity >= G4VisManager::confirmations) { 793 G4cout << "Background colour " 612 G4cout << "Background colour " 794 << vp.GetBackgroundColour() << 613 << vp.GetBackgroundColour() 795 << " requested." << 614 << " requested." 796 << G4endl; << 615 << G4endl; 797 } 616 } 798 } 617 } 799 618 800 else if (command == fpCommandCulling) { 619 else if (command == fpCommandCulling) { 801 G4String cullingOption, stringFlag, unit; 620 G4String cullingOption, stringFlag, unit; 802 G4double density; 621 G4double density; 803 std::istringstream is (newValue); 622 std::istringstream is (newValue); 804 is >> cullingOption >> stringFlag >> densi 623 is >> cullingOption >> stringFlag >> density >> unit; 805 G4bool boolFlag = G4UIcommand::ConvertToBo 624 G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag); 806 if (cullingOption == "global") { 625 if (cullingOption == "global") { 807 vp.SetCulling(boolFlag); 626 vp.SetCulling(boolFlag); 808 if (verbosity >= G4VisManager::confirmat 627 if (verbosity >= G4VisManager::confirmations) { 809 G4cout << << 628 G4cout << 810 "G4VisCommandsViewerSet::SetNewValue: << 629 "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag" 811 " set to " << G4UIcommand::ConvertToSt << 630 " set to " << G4UIcommand::ConvertToString(boolFlag) << 812 ".\n Does not change specific culling << 631 ".\n Does not change specific culling flags." 813 << G4endl; << 632 << G4endl; 814 } 633 } 815 } 634 } 816 else if (cullingOption == "coveredDaughter 635 else if (cullingOption == "coveredDaughters") { 817 vp.SetCullingCovered(boolFlag); 636 vp.SetCullingCovered(boolFlag); 818 if (verbosity >= G4VisManager::confirmat 637 if (verbosity >= G4VisManager::confirmations) { 819 G4cout << << 638 G4cout << 820 "G4VisCommandsViewerSet::SetNewValue: << 639 "G4VisCommandsViewerSet::SetNewValue: culling: culling covered" 821 "\n daughters flag set to " << 640 "\n daughters flag set to " 822 << G4UIcommand::ConvertToString(boolFl << 641 << G4UIcommand::ConvertToString(boolFlag) << 823 ". Daughters covered by opaque mother << 642 ". Daughters covered by opaque mothers" 824 "\n will be culled, i.e., not drawn, << 643 "\n will be culled, i.e., not drawn, if this flag is true." 825 "\n Note: this is only effective in s << 644 "\n Note: this is only effective in surface drawing style," 826 "\n and then only if the volumes are << 645 "\n and then only if the volumes are visible and opaque, and then" 827 "\n only if no sections or cutaways a << 646 "\n only if no sections or cutaways are in operation." 828 << G4endl; << 647 << G4endl; 829 } 648 } 830 } 649 } 831 else if (cullingOption == "invisible") { 650 else if (cullingOption == "invisible") { 832 vp.SetCullingInvisible(boolFlag); 651 vp.SetCullingInvisible(boolFlag); 833 if (verbosity >= G4VisManager::confirmat 652 if (verbosity >= G4VisManager::confirmations) { 834 G4cout << << 653 G4cout << 835 "G4VisCommandsViewerSet::SetNewValue: << 654 "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible" 836 "\n flag set to " << 655 "\n flag set to " 837 << boolFlag << G4UIcommand::ConvertToS << 656 << boolFlag << G4UIcommand::ConvertToString(boolFlag) << 838 ". Volumes marked invisible will be c << 657 ". Volumes marked invisible will be culled," 839 "\n i.e., not drawn, if this flag is << 658 "\n i.e., not drawn, if this flag is true." 840 << G4endl; << 659 << G4endl; 841 } 660 } 842 } 661 } 843 else if (cullingOption == "density") { 662 else if (cullingOption == "density") { 844 const G4String where = << 663 vp.SetDensityCulling(boolFlag); 845 "G4VisCommandsViewerSet::SetNewValue: cu << 846 if (boolFlag) { 664 if (boolFlag) { 847 G4double valueOfUnit; << 665 density *= G4UnitDefinition::GetValueOf(unit); 848 // "Volumic Mass" is Michel's phrase f << 666 vp.SetVisibleDensity(density); 849 if (ProvideValueOfUnit(where,unit,"Vol << 667 } 850 // Successful outcome of unit search << 668 else { 851 vp.SetDensityCulling(boolFlag); << 669 density = vp.GetVisibleDensity(); 852 density *= valueOfUnit; << 853 vp.SetVisibleDensity(density); << 854 } else { << 855 // Unsuccessful outcome of unit sear << 856 density = vp.GetVisibleDensity(); << 857 } << 858 } else { // Reset flag but density unch << 859 vp.SetDensityCulling(boolFlag); << 860 } 670 } 861 if (verbosity >= G4VisManager::confirmat 671 if (verbosity >= G4VisManager::confirmations) { 862 G4cout << 672 G4cout << 863 << where << 673 "G4VisCommandsViewerSet::SetNewValue: culling: culling by density" 864 << "\n flag set to " << 674 "\n flag set to " << G4UIcommand::ConvertToString(boolFlag) << 865 << std::boolalpha << vp.IsDensityCulli << 675 ". Volumes with density less than " << 866 << ". Volumes with density less than << 676 G4BestUnit(density,"Volumic Mass") << 867 << G4BestUnit(density,"Volumic Mass") << 677 "\n will be culled, i.e., not drawn, if this flag is true." 868 << "\n will be culled, i.e., not draw << 678 << G4endl; 869 << G4endl; << 870 } 679 } 871 } 680 } 872 else { 681 else { 873 if (verbosity >= G4VisManager::errors) { 682 if (verbosity >= G4VisManager::errors) { 874 G4warn << << 683 G4cout << 875 "ERROR: G4VisCommandsViewerSet::SetNew << 684 "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:" 876 "\n option not recognised." << 685 "\n option not recognised." 877 << G4endl; << 686 << G4endl; 878 } 687 } 879 } 688 } 880 } 689 } 881 690 882 else if (command == fpCommandCutawayMode) { 691 else if (command == fpCommandCutawayMode) { 883 if (newValue == "add" || newValue == "unio 692 if (newValue == "add" || newValue == "union") 884 vp.SetCutawayMode(G4ViewParameters::cuta 693 vp.SetCutawayMode(G4ViewParameters::cutawayUnion); 885 if (newValue == "multiply" || newValue == 694 if (newValue == "multiply" || newValue == "intersection") 886 vp.SetCutawayMode(G4ViewParameters::cuta 695 vp.SetCutawayMode(G4ViewParameters::cutawayIntersection); 887 << 696 888 if (verbosity >= G4VisManager::confirmatio 697 if (verbosity >= G4VisManager::confirmations) { 889 G4cout << "Cutaway mode set to "; 698 G4cout << "Cutaway mode set to "; 890 if (vp.GetCutawayMode() == G4ViewParamet 699 if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion) 891 G4cout << "cutawayUnion"; << 700 G4cout << "cutawayUnion"; 892 if (vp.GetCutawayMode() == G4ViewParamet 701 if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection) 893 G4cout << "cutawayIntersection"; << 702 G4cout << "cutawayIntersection"; 894 G4cout << G4endl; 703 G4cout << G4endl; 895 } 704 } 896 } 705 } 897 706 898 else if (command == fpCommandDefaultColour) 707 else if (command == fpCommandDefaultColour) { 899 G4String redOrString; 708 G4String redOrString; 900 G4double green, blue, opacity; 709 G4double green, blue, opacity; 901 std::istringstream iss(newValue); 710 std::istringstream iss(newValue); 902 iss >> redOrString >> green >> blue >> opa 711 iss >> redOrString >> green >> blue >> opacity; 903 G4Colour colour(1.,1.,1.); // Default whi 712 G4Colour colour(1.,1.,1.); // Default white and opaque. 904 ConvertToColour(colour, redOrString, green << 713 const size_t iPos0 = 0; >> 714 if (std::isalpha(redOrString[iPos0])) { >> 715 if (!G4Colour::GetColour(redOrString, colour)) { >> 716 if (verbosity >= G4VisManager::warnings) { >> 717 G4cout << "WARNING: Text colour \"" << redOrString >> 718 << "\" not found. Defaulting to white and opaque." >> 719 << G4endl; >> 720 } >> 721 } >> 722 } else { >> 723 colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue)); >> 724 } >> 725 // Add opacity >> 726 colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity); 905 G4VisAttributes va = vp.GetDefaultVisAttri 727 G4VisAttributes va = vp.GetDefaultVisAttributes(); 906 va.SetColour(colour); 728 va.SetColour(colour); 907 vp.SetDefaultVisAttributes(va); 729 vp.SetDefaultVisAttributes(va); 908 if (verbosity >= G4VisManager::confirmatio 730 if (verbosity >= G4VisManager::confirmations) { 909 G4cout << "Default colour " 731 G4cout << "Default colour " 910 << vp.GetDefaultVisAttributes()->GetColo << 732 << vp.GetDefaultVisAttributes()->GetColour() 911 << " requested." << 733 << " requested." 912 << G4endl; << 734 << G4endl; 913 } 735 } 914 } 736 } 915 737 916 else if (command == fpCommandDefaultTextColo 738 else if (command == fpCommandDefaultTextColour) { 917 G4String redOrString; 739 G4String redOrString; 918 G4double green, blue, opacity; 740 G4double green, blue, opacity; 919 std::istringstream iss(newValue); 741 std::istringstream iss(newValue); 920 iss >> redOrString >> green >> blue >> opa 742 iss >> redOrString >> green >> blue >> opacity; 921 G4Colour colour(1.,1.,1.); // Default whi 743 G4Colour colour(1.,1.,1.); // Default white and opaque. 922 ConvertToColour(colour, redOrString, green << 744 const size_t iPos0 = 0; >> 745 if (std::isalpha(redOrString[iPos0])) { >> 746 if (!G4Colour::GetColour(redOrString, colour)) { >> 747 if (verbosity >= G4VisManager::warnings) { >> 748 G4cout << "WARNING: Text colour \"" << redOrString >> 749 << "\" not found. Defaulting to white and opaque." >> 750 << G4endl; >> 751 } >> 752 } >> 753 } else { >> 754 colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue)); >> 755 } >> 756 // Add opacity >> 757 colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity); 923 G4VisAttributes va = vp.GetDefaultTextVisA 758 G4VisAttributes va = vp.GetDefaultTextVisAttributes(); 924 va.SetColour(colour); 759 va.SetColour(colour); 925 vp.SetDefaultTextVisAttributes(va); 760 vp.SetDefaultTextVisAttributes(va); 926 if (verbosity >= G4VisManager::confirmatio 761 if (verbosity >= G4VisManager::confirmations) { 927 G4cout << "Default colour " 762 G4cout << "Default colour " 928 << vp.GetDefaultTextVisAttributes()->Get << 763 << vp.GetDefaultTextVisAttributes()->GetColour() 929 << " requested." << 764 << " requested." 930 << G4endl; << 765 << G4endl; 931 } 766 } 932 } 767 } 933 768 934 else if (command == fpCommandEdge) { 769 else if (command == fpCommandEdge) { 935 G4ViewParameters::DrawingStyle existingSty 770 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle(); 936 if (G4UIcommand::ConvertToBool(newValue)) << 771 if (G4UIcommand::ConvertToBool(newValue)) { 937 switch (existingStyle) { 772 switch (existingStyle) { 938 case G4ViewParameters::wireframe: << 773 case G4ViewParameters::wireframe: 939 break; << 774 break; 940 case G4ViewParameters::hlr: << 775 case G4ViewParameters::hlr: 941 break; << 776 break; 942 case G4ViewParameters::hsr: << 777 case G4ViewParameters::hsr: 943 vp.SetDrawingStyle(G4ViewParameters: << 778 vp.SetDrawingStyle(G4ViewParameters::hlhsr); 944 break; << 779 break; 945 case G4ViewParameters::hlhsr: << 780 case G4ViewParameters::hlhsr: 946 break; << 781 break; 947 case G4ViewParameters::cloud: << 948 break; << 949 } 782 } 950 } 783 } 951 else { // false << 784 else { 952 switch (existingStyle) { 785 switch (existingStyle) { 953 case G4ViewParameters::wireframe: << 786 case G4ViewParameters::wireframe: 954 break; << 787 break; 955 case G4ViewParameters::hlr: << 788 case G4ViewParameters::hlr: 956 break; << 789 break; 957 case G4ViewParameters::hsr: << 790 case G4ViewParameters::hsr: 958 break; << 791 break; 959 case G4ViewParameters::hlhsr: << 792 case G4ViewParameters::hlhsr: 960 vp.SetDrawingStyle(G4ViewParameters: << 793 vp.SetDrawingStyle(G4ViewParameters::hsr); 961 break; << 794 break; 962 case G4ViewParameters::cloud: << 963 break; << 964 } 795 } 965 } 796 } 966 if (verbosity >= G4VisManager::confirmatio 797 if (verbosity >= G4VisManager::confirmations) { 967 G4cout << "Drawing style of viewer \"" < 798 G4cout << "Drawing style of viewer \"" << currentViewer->GetName() 968 << "\" set to " << vp.GetDrawingStyle() << 799 << "\" set to " << vp.GetDrawingStyle() 969 << G4endl; << 800 << G4endl; 970 } 801 } 971 } 802 } 972 803 973 else if (command == fpCommandExplodeFactor) 804 else if (command == fpCommandExplodeFactor) { 974 G4double explodeFactor, x, y, z; 805 G4double explodeFactor, x, y, z; 975 G4String unitString; 806 G4String unitString; 976 std::istringstream is (newValue); 807 std::istringstream is (newValue); 977 is >> explodeFactor >> x >> y >> z >> unit 808 is >> explodeFactor >> x >> y >> z >> unitString; 978 G4double unit = G4UIcommand::ValueOf(unitS 809 G4double unit = G4UIcommand::ValueOf(unitString); 979 vp.SetExplodeFactor(explodeFactor); 810 vp.SetExplodeFactor(explodeFactor); 980 vp.SetExplodeCentre(G4Point3D(x * unit, y 811 vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit)); 981 if (verbosity >= G4VisManager::confirmatio 812 if (verbosity >= G4VisManager::confirmations) { 982 G4cout << "Explode factor changed to " < 813 G4cout << "Explode factor changed to " << vp.GetExplodeFactor() 983 << " from centre " << vp.GetExplodeCentr << 814 << " from centre " << vp.GetExplodeCentre() 984 << G4endl; << 815 << G4endl; 985 } 816 } 986 } 817 } 987 818 988 else if (command == fpCommandGlobalLineWidth 819 else if (command == fpCommandGlobalLineWidthScale) { 989 G4double globalLineWidthScale 820 G4double globalLineWidthScale 990 = fpCommandGlobalLineWidthScale->GetNewDou << 821 = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue); 991 vp.SetGlobalLineWidthScale(globalLineWidth 822 vp.SetGlobalLineWidthScale(globalLineWidthScale); 992 if (verbosity >= G4VisManager::confirmatio 823 if (verbosity >= G4VisManager::confirmations) { 993 G4cout << "Global Line Width Scale chang 824 G4cout << "Global Line Width Scale changed to " 994 << vp.GetGlobalLineWidthScale() << G4end << 825 << vp.GetGlobalLineWidthScale() << G4endl; 995 } 826 } 996 } 827 } 997 828 998 else if (command == fpCommandGlobalMarkerSca 829 else if (command == fpCommandGlobalMarkerScale) { 999 G4double globalMarkerScale 830 G4double globalMarkerScale 1000 = fpCommandGlobalMarkerScale->GetNewDoubl << 831 = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue); 1001 vp.SetGlobalMarkerScale(globalMarkerScale 832 vp.SetGlobalMarkerScale(globalMarkerScale); 1002 if (verbosity >= G4VisManager::confirmati 833 if (verbosity >= G4VisManager::confirmations) { 1003 G4cout << "Global Marker Scale changed 834 G4cout << "Global Marker Scale changed to " 1004 << vp.GetGlobalMarkerScale() << G4endl; << 835 << vp.GetGlobalMarkerScale() << G4endl; 1005 } 836 } 1006 } 837 } 1007 838 1008 else if (command == fpCommandHiddenEdge) { 839 else if (command == fpCommandHiddenEdge) { 1009 G4ViewParameters::DrawingStyle existingSt 840 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle(); 1010 if (G4UIcommand::ConvertToBool(newValue)) 841 if (G4UIcommand::ConvertToBool(newValue)) { 1011 switch (existingStyle) { 842 switch (existingStyle) { 1012 case G4ViewParameters::wireframe: << 843 case G4ViewParameters::wireframe: 1013 vp.SetDrawingStyle(G4ViewParameters << 844 vp.SetDrawingStyle(G4ViewParameters::hlr); 1014 break; << 845 break; 1015 case G4ViewParameters::hlr: << 846 case G4ViewParameters::hlr: 1016 break; << 847 break; 1017 case G4ViewParameters::hsr: << 848 case G4ViewParameters::hsr: 1018 vp.SetDrawingStyle(G4ViewParameters << 849 vp.SetDrawingStyle(G4ViewParameters::hlhsr); 1019 break; << 850 break; 1020 case G4ViewParameters::hlhsr: << 851 case G4ViewParameters::hlhsr: 1021 break; << 852 break; 1022 case G4ViewParameters::cloud: << 1023 break; << 1024 } 853 } 1025 } 854 } 1026 else { 855 else { 1027 switch (existingStyle) { 856 switch (existingStyle) { 1028 case G4ViewParameters::wireframe: << 857 case G4ViewParameters::wireframe: 1029 break; << 858 break; 1030 case G4ViewParameters::hlr: << 859 case G4ViewParameters::hlr: 1031 vp.SetDrawingStyle(G4ViewParameters << 860 vp.SetDrawingStyle(G4ViewParameters::wireframe); 1032 break; << 861 break; 1033 case G4ViewParameters::hsr: << 862 case G4ViewParameters::hsr: 1034 break; << 863 break; 1035 case G4ViewParameters::hlhsr: << 864 case G4ViewParameters::hlhsr: 1036 vp.SetDrawingStyle(G4ViewParameters << 865 vp.SetDrawingStyle(G4ViewParameters::hsr); 1037 break; << 866 break; 1038 case G4ViewParameters::cloud: << 1039 break; << 1040 } 867 } 1041 } 868 } 1042 if (verbosity >= G4VisManager::confirmati 869 if (verbosity >= G4VisManager::confirmations) { 1043 G4cout << "Drawing style of viewer \"" 870 G4cout << "Drawing style of viewer \"" << currentViewer->GetName() 1044 << "\" set to " << vp.GetDrawingStyle() << 871 << "\" set to " << vp.GetDrawingStyle() 1045 << G4endl; << 872 << G4endl; 1046 } 873 } 1047 } 874 } 1048 875 1049 else if (command == fpCommandHiddenMarker) 876 else if (command == fpCommandHiddenMarker) { 1050 G4bool hidden = G4UIcommand::ConvertToBoo 877 G4bool hidden = G4UIcommand::ConvertToBool(newValue); 1051 if (hidden) vp.SetMarkerHidden(); 878 if (hidden) vp.SetMarkerHidden(); 1052 else vp.SetMarkerNotHidden(); 879 else vp.SetMarkerNotHidden(); 1053 if (verbosity >= G4VisManager::confirmati 880 if (verbosity >= G4VisManager::confirmations) { 1054 G4cout << "Markers will "; 881 G4cout << "Markers will "; 1055 if (vp.IsMarkerNotHidden()) G4cout << " 882 if (vp.IsMarkerNotHidden()) G4cout << "not "; 1056 G4cout << "be hidden under solid object 883 G4cout << "be hidden under solid objects." << G4endl; 1057 } 884 } 1058 } 885 } 1059 886 1060 else if (command == fpCommandLightsMove) { 887 else if (command == fpCommandLightsMove) { 1061 if (newValue.find("cam") != G4String::npo 888 if (newValue.find("cam") != G4String::npos) 1062 vp.SetLightsMoveWithCamera(true); 889 vp.SetLightsMoveWithCamera(true); 1063 else if(newValue.find("obj") != G4String: 890 else if(newValue.find("obj") != G4String::npos) 1064 vp.SetLightsMoveWithCamera(false); 891 vp.SetLightsMoveWithCamera(false); 1065 else { 892 else { 1066 if (verbosity >= G4VisManager::errors) 893 if (verbosity >= G4VisManager::errors) { 1067 G4warn << "ERROR: \"" << newValue << << 894 G4cout << "ERROR: \"" << newValue << "\" not recognised." 1068 " Looking for \"cam\" or \"obj\" in << 895 " Looking for \"cam\" or \"obj\" in string." << G4endl; 1069 } 896 } 1070 } 897 } 1071 if (verbosity >= G4VisManager::confirmati 898 if (verbosity >= G4VisManager::confirmations) { 1072 G4cout << "Lights move with "; 899 G4cout << "Lights move with "; 1073 if (vp.GetLightsMoveWithCamera()) 900 if (vp.GetLightsMoveWithCamera()) 1074 G4cout << "camera (object appears to << 901 G4cout << "camera (object appears to rotate)."; 1075 else G4cout << "object (the viewer appe 902 else G4cout << "object (the viewer appears to be moving)."; 1076 G4cout << G4endl; 903 G4cout << G4endl; 1077 } 904 } 1078 } 905 } 1079 906 1080 else if (command == fpCommandLightsThetaPhi 907 else if (command == fpCommandLightsThetaPhi) { 1081 G4double theta, phi; 908 G4double theta, phi; 1082 if (ConvertToDoublePair(newValue, theta, << 909 ConvertToDoublePair(newValue, theta, phi); 1083 G4double x = std::sin (theta) * std::co << 910 G4double x = std::sin (theta) * std::cos (phi); 1084 G4double y = std::sin (theta) * std::si << 911 G4double y = std::sin (theta) * std::sin (phi); 1085 G4double z = std::cos (theta); << 912 G4double z = std::cos (theta); 1086 fLightsVector = G4ThreeVector (x, y, z) << 913 fLightsVector = G4ThreeVector (x, y, z); 1087 vp.SetLightpointDirection(fLightsVector << 914 vp.SetLightpointDirection(fLightsVector); 1088 if (verbosity >= G4VisManager::confirma << 915 if (verbosity >= G4VisManager::confirmations) { 1089 G4cout << "Lights direction set to " << 916 G4cout << "Lights direction set to " 1090 << vp.GetLightpointDirection() << G4e << 917 << vp.GetLightpointDirection() << G4endl; 1091 } << 1092 } 918 } 1093 } 919 } 1094 920 1095 else if (command == fpCommandLightsVector) 921 else if (command == fpCommandLightsVector) { 1096 fLightsVector = G4UIcommand::ConvertTo3Ve 922 fLightsVector = G4UIcommand::ConvertTo3Vector(newValue); 1097 vp.SetLightpointDirection(fLightsVector); 923 vp.SetLightpointDirection(fLightsVector); 1098 if (verbosity >= G4VisManager::confirmati 924 if (verbosity >= G4VisManager::confirmations) { 1099 G4cout << "Lights direction set to " 925 G4cout << "Lights direction set to " 1100 << vp.GetLightpointDirection() << G4end << 926 << vp.GetLightpointDirection() << G4endl; 1101 } << 1102 } << 1103 << 1104 else if (command == fpCommandLineWidth) { << 1105 if (verbosity >= G4VisManager::errors) { << 1106 // A do-nothing command << 1107 G4warn << command->GetGuidanceLine(0) < << 1108 } 927 } 1109 } 928 } 1110 929 1111 else if (command == fpCommandLineSegments) 930 else if (command == fpCommandLineSegments) { 1112 G4int nSides = G4UIcommand::ConvertToInt( 931 G4int nSides = G4UIcommand::ConvertToInt(newValue); 1113 nSides = vp.SetNoOfSides(nSides); 932 nSides = vp.SetNoOfSides(nSides); 1114 if (verbosity >= G4VisManager::confirmati 933 if (verbosity >= G4VisManager::confirmations) { 1115 G4cout << 934 G4cout << 1116 "Number of line segments per circle in << 935 "Number of line segements per circle in polygon approximation is " 1117 << nSides << G4endl; << 936 << nSides << G4endl; 1118 } << 1119 } << 1120 << 1121 else if (command == fpCommandNumberOfCloudP << 1122 G4int nPoints = G4UIcommand::ConvertToInt << 1123 nPoints = vp.SetNumberOfCloudPoints(nPoin << 1124 if (verbosity >= G4VisManager::confirmati << 1125 G4cout << << 1126 "Number of points to be used in cloud r << 1127 << nPoints << G4endl; << 1128 } 937 } 1129 } 938 } 1130 939 1131 else if (command == fpCommandPicking) { 940 else if (command == fpCommandPicking) { 1132 vp.SetPicking(G4UIcommand::ConvertToBool( 941 vp.SetPicking(G4UIcommand::ConvertToBool(newValue)); 1133 if (verbosity >= G4VisManager::confirmati 942 if (verbosity >= G4VisManager::confirmations) { 1134 G4cout << "Picking "; 943 G4cout << "Picking "; 1135 if (vp.IsPicking()) G4cout << "requeste 944 if (vp.IsPicking()) G4cout << "requested."; 1136 else G4cout << "inhibited."; 945 else G4cout << "inhibited."; 1137 G4cout << G4endl; 946 G4cout << G4endl; 1138 } 947 } 1139 if (verbosity >= G4VisManager::warnings) 948 if (verbosity >= G4VisManager::warnings) { 1140 G4warn << "You may need to issue \"/vis << 949 G4cout << "You may need to issue \"/vis/viewer/update\"." 1141 << G4endl; << 950 << G4endl; 1142 } 951 } 1143 } 952 } 1144 953 1145 else if (command == fpCommandProjection) { 954 else if (command == fpCommandProjection) { 1146 G4double fieldHalfAngle; 955 G4double fieldHalfAngle; 1147 const size_t iPos0 = 0; 956 const size_t iPos0 = 0; 1148 if (newValue[iPos0] == 'o') { // "orthog 957 if (newValue[iPos0] == 'o') { // "orthogonal" 1149 fieldHalfAngle = 0.; 958 fieldHalfAngle = 0.; 1150 } 959 } 1151 else if (newValue[iPos0] == 'p') { // "p 960 else if (newValue[iPos0] == 'p') { // "perspective" 1152 G4String dummy; 961 G4String dummy; 1153 G4String unit; 962 G4String unit; 1154 std::istringstream is (newValue); 963 std::istringstream is (newValue); 1155 is >> dummy >> fieldHalfAngle >> unit; 964 is >> dummy >> fieldHalfAngle >> unit; 1156 fieldHalfAngle *= G4UIcommand::ValueOf( 965 fieldHalfAngle *= G4UIcommand::ValueOf(unit); 1157 if (fieldHalfAngle > 89.5 * deg || fiel 966 if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) { 1158 if (verbosity >= G4VisManager::errors << 967 if (verbosity >= G4VisManager::errors) { 1159 G4warn << << 968 G4cout << 1160 "ERROR: Field half angle should be << 969 "ERROR: Field half angle should be 0 < angle <= 89.5 degrees."; 1161 G4warn << G4endl; << 970 G4cout << G4endl; 1162 } << 971 } 1163 return; << 972 return; 1164 } 973 } 1165 } 974 } 1166 else { 975 else { 1167 if (verbosity >= G4VisManager::errors) 976 if (verbosity >= G4VisManager::errors) { 1168 G4warn << "ERROR: \"" << newValue << << 977 G4cout << "ERROR: \"" << newValue << "\" not recognised." 1169 " Looking for 'o' or 'p' first chara << 978 " Looking for 'o' or 'p' first character." << G4endl; 1170 } 979 } 1171 return; 980 return; 1172 } 981 } 1173 vp.SetFieldHalfAngle(fieldHalfAngle); 982 vp.SetFieldHalfAngle(fieldHalfAngle); 1174 if (verbosity >= G4VisManager::confirmati 983 if (verbosity >= G4VisManager::confirmations) { 1175 G4cout << "Projection style of viewer \ 984 G4cout << "Projection style of viewer \"" << currentViewer->GetName() 1176 << "\" set to "; << 985 << "\" set to "; 1177 if (fieldHalfAngle == 0.) { 986 if (fieldHalfAngle == 0.) { 1178 G4cout << "orthogonal."; << 987 G4cout << "orthogonal."; 1179 } 988 } 1180 else { 989 else { 1181 G4cout << "perspective\n with half a << 990 G4cout << "perspective\n with half angle " << fieldHalfAngle / deg 1182 << " degrees."; << 991 << " degrees."; 1183 } 992 } 1184 G4cout << G4endl; 993 G4cout << G4endl; 1185 } 994 } 1186 } 995 } 1187 996 1188 else if (command == fpCommandRotationStyle) << 1189 G4ViewParameters::RotationStyle style; << 1190 if (newValue == "constrainUpDirection") << 1191 style = G4ViewParameters::constrainUpDi << 1192 else if (newValue == "freeRotation") << 1193 style = G4ViewParameters::freeRotation; << 1194 else { << 1195 if (verbosity >= G4VisManager::errors) << 1196 G4warn << "ERROR: \"" << newValue << "\" no << 1197 } << 1198 return; << 1199 } << 1200 vp.SetRotationStyle(style); << 1201 if (verbosity >= G4VisManager::confirmati << 1202 G4cout << "Rotation style of viewer \"" << 1203 << "\" set to " << vp.GetRotationStyle( << 1204 << G4endl; << 1205 } << 1206 } << 1207 << 1208 else if (command == fpCommandSectionPlane) 997 else if (command == fpCommandSectionPlane) { 1209 G4String choice, unit; 998 G4String choice, unit; 1210 G4double x, y, z, nx, ny, nz, F = 1.; << 999 G4double x, y, z, nx, ny, nz; 1211 std::istringstream is (newValue); 1000 std::istringstream is (newValue); 1212 is >> choice >> x >> y >> z >> unit >> nx 1001 is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz; >> 1002 1213 G4int iSelector = -1; 1003 G4int iSelector = -1; 1214 if (G4StrUtil::icompare(choice, "off") == << 1004 if (choice.compareTo("off",G4String::ignoreCase) == 0 || 1215 !G4UIcommand::ConvertToBool(choice)) << 1005 !G4UIcommand::ConvertToBool(choice)) iSelector = 0; 1216 if (G4StrUtil::icompare(choice, "on") == << 1006 if (choice.compareTo("on",G4String::ignoreCase) == 0 || 1217 G4UIcommand::ConvertToBool(choice)) i << 1007 G4UIcommand::ConvertToBool(choice)) iSelector = 1; 1218 if (iSelector < 0) { 1008 if (iSelector < 0) { 1219 if (verbosity >= G4VisManager::errors) 1009 if (verbosity >= G4VisManager::errors) { 1220 G4warn << "Choice not recognised (on/ << 1010 G4cout << "Choice not recognised (on/true or off/false)." << G4endl; >> 1011 G4cout << "Section drawing is currently: "; >> 1012 if (vp.IsSection ()) G4cout << "on"; >> 1013 else G4cout << "off"; >> 1014 G4cout << ".\nSection plane is currently: " >> 1015 << vp.GetSectionPlane (); >> 1016 G4cout << G4endl; 1221 } 1017 } 1222 goto write_result; << 1018 return; 1223 } 1019 } >> 1020 >> 1021 G4double F = 1.; 1224 // iSelector can only be 0 or 1 1022 // iSelector can only be 0 or 1 1225 switch (iSelector) { 1023 switch (iSelector) { 1226 case 0: << 1024 case 0: 1227 vp.UnsetSectionPlane(); << 1025 vp.UnsetSectionPlane(); 1228 break; << 1026 break; 1229 case 1: << 1027 case 1: 1230 F = G4UIcommand::ValueOf(unit); << 1028 F = G4UIcommand::ValueOf(unit); 1231 x *= F; y *= F; z *= F; << 1029 x *= F; y *= F; z *= F; 1232 if (nx == 0. && ny == 0. && nz == 0.) << 1030 vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z))); 1233 if (verbosity >= G4VisManager::erro << 1031 vp.SetViewpointDirection(G4Normal3D(nx,ny,nz)); 1234 G4warn << "Null normal." << G4end << 1032 break; 1235 } << 1236 break;; << 1237 } << 1238 // Make sure normal is normalised << 1239 const G4Normal3D& normal = G4Normal3D << 1240 vp.SetSectionPlane(G4Plane3D(normal, << 1241 vp.SetViewpointDirection(normal); << 1242 break; << 1243 } 1033 } 1244 write_result: << 1034 1245 if (verbosity >= G4VisManager::confirmati 1035 if (verbosity >= G4VisManager::confirmations) { 1246 G4cout << "Section drawing is: "; << 1036 G4cout << "Section drawing is now: "; 1247 if (vp.IsSection ()) G4cout << "on"; 1037 if (vp.IsSection ()) G4cout << "on"; 1248 else G4cout << "off"; << 1038 else G4cout << "off"; 1249 G4cout << ".\nSection plane is now: " 1039 G4cout << ".\nSection plane is now: " 1250 << vp.GetSectionPlane (); << 1040 << vp.GetSectionPlane (); 1251 G4cout << G4endl; 1041 G4cout << G4endl; 1252 } 1042 } 1253 } 1043 } 1254 1044 1255 else if (command == fpCommandSpecialMeshRen << 1045 else if (command == fpCommandRotationStyle) { 1256 vp.SetSpecialMeshRendering(G4UIcommand::C << 1046 G4ViewParameters::RotationStyle style; 1257 if (verbosity >= G4VisManager::confirmati << 1047 if (newValue == "constrainUpDirection") 1258 G4cout << "Special mesh rendering"; << 1048 style = G4ViewParameters::constrainUpDirection; 1259 if (vp.IsSpecialMeshRendering()) { << 1049 else if (newValue == "freeRotation") 1260 G4cout << " requested. Current option << 1050 style = G4ViewParameters::freeRotation; 1261 << vp.GetSpecialMeshRenderingOption() << 1051 else { 1262 if (vp.GetSpecialMeshVolumes().empty( << 1052 if (verbosity >= G4VisManager::errors) { 1263 G4cout << "any mesh."; << 1053 G4cout << "ERROR: \"" << newValue << "\" not recognised." << G4endl; 1264 } else{ << 1265 G4cout << "selected volumes:"; << 1266 for (const auto& pvNameCopyNo: vp.G << 1267 G4cout << "\n " << pvNameCopyNo. << 1268 if (pvNameCopyNo.GetCopyNo() >= 0 << 1269 } << 1270 } << 1271 } << 1272 else G4cout << ": off."; << 1273 G4cout << G4endl; << 1274 } << 1275 } << 1276 << 1277 else if (command == fpCommandSpecialMeshRen << 1278 G4ViewParameters::SMROption option = G4Vi << 1279 if (newValue == "dots") { << 1280 option = G4ViewParameters::meshAsDots; << 1281 } << 1282 else if(newValue == "surfaces") { << 1283 option = G4ViewParameters::meshAsSurfac << 1284 } << 1285 vp.SetSpecialMeshRenderingOption(option); << 1286 if (verbosity >= G4VisManager::confirmati << 1287 G4cout << "Special mesh rendering optio << 1288 << vp.GetSpecialMeshRenderingOption() < << 1289 << G4endl; << 1290 } << 1291 } << 1292 << 1293 else if (command == fpCommandSpecialMeshVol << 1294 std::vector<G4ModelingParameters::PVNameC << 1295 if (newValue.empty()) { << 1296 vp.SetSpecialMeshVolumes(requestedMeshe << 1297 } else { << 1298 // Algorithm from Josuttis p.476. << 1299 G4String::size_type iBegin, iEnd; << 1300 iBegin = newValue.find_first_not_of(' ' << 1301 while (iBegin != G4String::npos) { << 1302 iEnd = newValue.find_first_of(' ',iBegin); << 1303 if (iEnd == G4String::npos) { << 1304 iEnd = newValue.length(); << 1305 } << 1306 const G4String& name(newValue.substr(iBegin << 1307 iBegin = newValue.find_first_not_of(' ',iEn << 1308 if (iBegin == G4String::npos) { << 1309 if (verbosity >= G4VisManager::warnings) << 1310 G4warn << << 1311 "WARNING: G4VisCommandsViewerSet::SetNe << 1312 "\n A pair not found. (There should b << 1313 "\n Command ignored." << 1314 << G4endl; << 1315 return; << 1316 } << 1317 } << 1318 iEnd = newValue.find_first_of(' ',iBegin); << 1319 if (iEnd == G4String::npos) { << 1320 iEnd = newValue.length(); << 1321 } << 1322 G4int copyNo; << 1323 std::istringstream iss(newValue.substr(iBeg << 1324 if (!(iss >> copyNo)) { << 1325 if (verbosity >= G4VisManager::warnings) << 1326 G4warn << << 1327 "WARNING: G4VisCommandsViewerSet::SetNe << 1328 "\n Error reading copy number - it was << 1329 "\n Command ignored." << 1330 << G4endl; << 1331 return; << 1332 } << 1333 } << 1334 requestedMeshes.push_back(G4ModelingParamet << 1335 iBegin = newValue.find_first_not_of(' ',iEn << 1336 } 1054 } 1337 vp.SetSpecialMeshVolumes(requestedMeshe << 1055 return; 1338 } 1056 } >> 1057 vp.SetRotationStyle(style); 1339 if (verbosity >= G4VisManager::confirmati 1058 if (verbosity >= G4VisManager::confirmations) { 1340 if (vp.GetSpecialMeshVolumes().empty()) << 1059 G4cout << "Rotation style of viewer \"" << currentViewer->GetName() 1341 G4cout << << 1060 << "\" set to " << vp.GetRotationStyle() 1342 "Special mesh list empty, which means \"all << 1061 << G4endl; 1343 << G4endl; << 1344 } else { << 1345 G4cout << "Selected special mesh volumes ar << 1346 for (const auto& pvNameCopyNo: vp.GetSpecia << 1347 G4cout << "\n " << pvNameCopyNo.GetName( << 1348 if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << 1349 } << 1350 G4cout << G4endl; << 1351 } << 1352 } 1062 } 1353 } 1063 } 1354 1064 1355 else if (command == fpCommandStyle) { 1065 else if (command == fpCommandStyle) { 1356 G4ViewParameters::DrawingStyle existingSt 1066 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle(); 1357 const size_t iPos0 = 0; 1067 const size_t iPos0 = 0; 1358 if (newValue[iPos0] == 'w') { // "wirefr 1068 if (newValue[iPos0] == 'w') { // "wireframe" 1359 switch (existingStyle) { 1069 switch (existingStyle) { 1360 case G4ViewParameters::wireframe: << 1070 case G4ViewParameters::wireframe: 1361 break; << 1071 break; 1362 case G4ViewParameters::hlr: << 1072 case G4ViewParameters::hlr: 1363 break; << 1073 break; 1364 case G4ViewParameters::hsr: << 1074 case G4ViewParameters::hsr: 1365 vp.SetDrawingStyle(G4ViewParameters << 1075 vp.SetDrawingStyle(G4ViewParameters::wireframe); 1366 break; << 1076 break; 1367 case G4ViewParameters::hlhsr: << 1077 case G4ViewParameters::hlhsr: 1368 vp.SetDrawingStyle(G4ViewParameters << 1078 vp.SetDrawingStyle(G4ViewParameters::hlr); 1369 break; << 1079 break; 1370 case G4ViewParameters::cloud: << 1371 vp.SetDrawingStyle(G4ViewParameters << 1372 break; << 1373 } 1080 } 1374 } 1081 } 1375 else if (newValue[iPos0] == 's') { // "s 1082 else if (newValue[iPos0] == 's') { // "surface" 1376 switch (existingStyle) { 1083 switch (existingStyle) { 1377 case G4ViewParameters::wireframe: << 1084 case G4ViewParameters::wireframe: 1378 vp.SetDrawingStyle(G4ViewParameters << 1085 vp.SetDrawingStyle(G4ViewParameters::hsr); 1379 break; << 1086 break; 1380 case G4ViewParameters::hlr: << 1087 case G4ViewParameters::hlr: 1381 vp.SetDrawingStyle(G4ViewParameters << 1088 vp.SetDrawingStyle(G4ViewParameters::hlhsr); 1382 break; << 1089 break; 1383 case G4ViewParameters::hsr: << 1090 case G4ViewParameters::hsr: 1384 break; << 1091 break; 1385 case G4ViewParameters::hlhsr: << 1092 case G4ViewParameters::hlhsr: 1386 break; << 1093 break; 1387 case G4ViewParameters::cloud: << 1388 vp.SetDrawingStyle(G4ViewParameters << 1389 break; << 1390 } << 1391 } << 1392 else if (newValue[iPos0] == 'c') { // "c << 1393 switch (existingStyle) { << 1394 case G4ViewParameters::wireframe: << 1395 vp.SetDrawingStyle(G4ViewParameters << 1396 break; << 1397 case G4ViewParameters::hlr: << 1398 vp.SetDrawingStyle(G4ViewParameters << 1399 break; << 1400 case G4ViewParameters::hsr: << 1401 vp.SetDrawingStyle(G4ViewParameters << 1402 break; << 1403 case G4ViewParameters::hlhsr: << 1404 vp.SetDrawingStyle(G4ViewParameters << 1405 break; << 1406 case G4ViewParameters::cloud: << 1407 break; << 1408 } 1094 } 1409 } 1095 } 1410 else { 1096 else { 1411 if (verbosity >= G4VisManager::errors) 1097 if (verbosity >= G4VisManager::errors) { 1412 G4warn << "ERROR: \"" << newValue << << 1098 G4cout << "ERROR: \"" << newValue << "\" not recognised." 1413 " Looking for 'w' or 's' or 'c' firs << 1099 " Looking for 'w' or 's' first character." << G4endl; 1414 } 1100 } 1415 return; 1101 return; 1416 } 1102 } 1417 if (verbosity >= G4VisManager::confirmati 1103 if (verbosity >= G4VisManager::confirmations) { 1418 G4cout << "Drawing style of viewer \"" 1104 G4cout << "Drawing style of viewer \"" << currentViewer->GetName() 1419 << "\" set to " << vp.GetDrawingStyle() << 1105 << "\" set to " << vp.GetDrawingStyle() 1420 << G4endl; << 1106 << G4endl; 1421 } 1107 } 1422 } 1108 } 1423 1109 1424 else if (command == fpCommandTargetPoint) { 1110 else if (command == fpCommandTargetPoint) { 1425 G4ThreeVector targetPoint = 1111 G4ThreeVector targetPoint = 1426 fpCommandTargetPoint->GetNew3VectorValue( << 1112 fpCommandTargetPoint->GetNew3VectorValue(newValue); 1427 const G4Point3D& standardTargetPoint = 1113 const G4Point3D& standardTargetPoint = 1428 currentViewer->GetSceneHandler()->GetScen << 1114 currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint(); 1429 vp.SetCurrentTargetPoint(targetPoint - st 1115 vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint); 1430 if (verbosity >= G4VisManager::confirmati 1116 if (verbosity >= G4VisManager::confirmations) { 1431 G4cout << "Target point set to " 1117 G4cout << "Target point set to " 1432 << fpCommandTargetPoint->ConvertToStrin << 1118 << fpCommandTargetPoint->ConvertToStringWithBestUnit 1433 (targetPoint) << 1119 (targetPoint) 1434 << "\n\"Current Target Point\" set to << 1120 << "\n\"Current Target Point\" set to " 1435 << fpCommandTargetPoint->ConvertToStrin << 1121 << fpCommandTargetPoint->ConvertToStringWithBestUnit 1436 (vp.GetCurrentTargetPoint()) << 1122 (vp.GetCurrentTargetPoint()) 1437 << "\n\"Standard Target Point\" is " << 1123 << "\n\"Standard Target Point\" is " 1438 << fpCommandTargetPoint->ConvertToStrin << 1124 << fpCommandTargetPoint->ConvertToStringWithBestUnit 1439 (standardTargetPoint) << 1125 (standardTargetPoint) 1440 << G4endl; << 1126 << G4endl; 1441 } 1127 } 1442 } 1128 } 1443 1129 1444 else if (command == fpCommandUpThetaPhi) { 1130 else if (command == fpCommandUpThetaPhi) { 1445 G4double theta, phi; 1131 G4double theta, phi; 1446 if (ConvertToDoublePair(newValue, theta, << 1132 ConvertToDoublePair(newValue, theta, phi); 1447 G4double x = std::sin (theta) * std::co << 1133 G4double x = std::sin (theta) * std::cos (phi); 1448 G4double y = std::sin (theta) * std::si << 1134 G4double y = std::sin (theta) * std::sin (phi); 1449 G4double z = std::cos (theta); << 1135 G4double z = std::cos (theta); 1450 fUpVector = G4ThreeVector (x, y, z); << 1136 fUpVector = G4ThreeVector (x, y, z); 1451 vp.SetUpVector(fUpVector); << 1137 vp.SetUpVector(fUpVector); 1452 if (verbosity >= G4VisManager::confirma << 1138 if (verbosity >= G4VisManager::confirmations) { 1453 G4cout << "Up direction set to " << v << 1139 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl; 1454 } << 1455 } 1140 } 1456 } 1141 } 1457 1142 1458 else if (command == fpCommandUpVector) { 1143 else if (command == fpCommandUpVector) { 1459 fUpVector = G4UIcommand::ConvertTo3Vector 1144 fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit(); 1460 vp.SetUpVector(fUpVector); 1145 vp.SetUpVector(fUpVector); 1461 if (verbosity >= G4VisManager::confirmati 1146 if (verbosity >= G4VisManager::confirmations) { 1462 G4cout << "Up direction set to " << vp. 1147 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl; 1463 } 1148 } 1464 } 1149 } 1465 1150 1466 else if (command == fpCommandViewpointTheta 1151 else if (command == fpCommandViewpointThetaPhi) { 1467 G4double theta, phi; 1152 G4double theta, phi; 1468 if (ConvertToDoublePair(newValue, theta, << 1153 ConvertToDoublePair(newValue, theta, phi); 1469 G4double x = std::sin (theta) * std::co << 1154 G4double x = std::sin (theta) * std::cos (phi); 1470 G4double y = std::sin (theta) * std::si << 1155 G4double y = std::sin (theta) * std::sin (phi); 1471 G4double z = std::cos (theta); << 1156 G4double z = std::cos (theta); 1472 fViewpointVector = G4ThreeVector (x, y, << 1157 fViewpointVector = G4ThreeVector (x, y, z); 1473 vp.SetViewAndLights(fViewpointVector); << 1158 vp.SetViewAndLights(fViewpointVector); 1474 if (verbosity >= G4VisManager::confirma << 1159 if (verbosity >= G4VisManager::confirmations) { 1475 G4cout << "Viewpoint direction set to << 1160 G4cout << "Viewpoint direction set to " 1476 << vp.GetViewpointDirection() << G4en << 1161 << vp.GetViewpointDirection() << G4endl; 1477 if (vp.GetLightsMoveWithCamera ()) { << 1162 if (vp.GetLightsMoveWithCamera ()) { 1478 G4cout << "Lightpoint direction set << 1163 G4cout << "Lightpoint direction set to " 1479 << vp.GetActualLightpointDirection << 1164 << vp.GetActualLightpointDirection () << G4endl; 1480 } << 1481 } 1165 } 1482 } 1166 } 1483 } 1167 } 1484 1168 1485 else if (command == fpCommandViewpointVecto 1169 else if (command == fpCommandViewpointVector) { 1486 G4ThreeVector viewpointVector = G4UIcomma << 1170 fViewpointVector = G4UIcommand::ConvertTo3Vector(newValue).unit(); 1487 if (viewpointVector.mag2() <= 0.) { << 1171 vp.SetViewAndLights(fViewpointVector); 1488 if (verbosity >= G4VisManager::errors) << 1489 G4warn << "ERROR: Null viewpoint vect << 1490 } << 1491 } else { << 1492 fViewpointVector = viewpointVector.unit << 1493 vp.SetViewAndLights(fViewpointVector); << 1494 if (verbosity >= G4VisManager::confirma << 1495 G4cout << "Viewpoint direction set to << 1496 << vp.GetViewpointDirection() << G4en << 1497 if (vp.GetLightsMoveWithCamera ()) { << 1498 G4cout << "Lightpoint direction set << 1499 << vp.GetActualLightpointDirection << 1500 } << 1501 } << 1502 } << 1503 } << 1504 << 1505 else if (command == fpCommandTimeWindowDisp << 1506 { << 1507 G4String display; << 1508 G4double screenX, screenY, screenSize, re << 1509 std::istringstream iss(newValue); << 1510 iss >> display >> screenX >> screenY << 1511 >> screenSize >> red >> green >> blue; << 1512 vp.SetDisplayHeadTime(command->ConvertToB << 1513 vp.SetDisplayHeadTimeX(screenX); << 1514 vp.SetDisplayHeadTimeY(screenY); << 1515 vp.SetDisplayHeadTimeSize(screenSize); << 1516 vp.SetDisplayHeadTimeRed(red); << 1517 vp.SetDisplayHeadTimeGreen(green); << 1518 vp.SetDisplayHeadTimeBlue(blue); << 1519 if (verbosity >= G4VisManager::confirmati << 1520 G4cout << "Display head time flag set: << 1521 << vp << 1522 << G4endl; << 1523 } << 1524 } << 1525 << 1526 else if (command == fpCommandTimeWindowDisp << 1527 { << 1528 G4String display, originX, originY, origi << 1529 G4double red, green, blue; << 1530 std::istringstream iss(newValue); << 1531 iss >> display << 1532 >> originX >> originY >> originZ >> unitS << 1533 >> originT >> unitT << 1534 >> red >> green >> blue; << 1535 vp.SetDisplayLightFront(command->ConvertT << 1536 vp.SetDisplayLightFrontX << 1537 (command->ConvertToDimensionedDouble(G4St << 1538 vp.SetDisplayLightFrontY << 1539 (command->ConvertToDimensionedDouble(G4St << 1540 vp.SetDisplayLightFrontZ << 1541 (command->ConvertToDimensionedDouble(G4St << 1542 vp.SetDisplayLightFrontT << 1543 (command->ConvertToDimensionedDouble(G4St << 1544 vp.SetDisplayLightFrontRed(red); << 1545 vp.SetDisplayLightFrontGreen(green); << 1546 vp.SetDisplayLightFrontBlue(blue); << 1547 if (verbosity >= G4VisManager::confirmati << 1548 G4cout << "Display light front flag set << 1549 << vp << 1550 << G4endl; << 1551 } << 1552 } << 1553 << 1554 else if (command == fpCommandTimeWindowEndT << 1555 { << 1556 G4String end_time_string, end_time_unit, << 1557 time_range_string, time_range_unit; << 1558 std::istringstream iss(newValue); << 1559 iss >> end_time_string >> end_time_unit << 1560 >> time_range_string >> time_range_unit; << 1561 vp.SetEndTime << 1562 (command->ConvertToDimensionedDouble << 1563 (G4String(end_time_string + ' ' + end_ti << 1564 G4double timeRange = command->ConvertToDi << 1565 (G4String(time_range_string + ' ' + time_ << 1566 if (timeRange > 0.) { << 1567 vp.SetStartTime << 1568 (vp.GetEndTime() - timeRange); << 1569 } << 1570 if (verbosity >= G4VisManager::confirmati << 1571 G4cout << 1572 << "Time window start time: " << vp.Get << 1573 << ", time window end time: " << vp.Get << 1574 if (timeRange > 0.) { << 1575 G4cout << "\n (time range: " << time << 1576 } << 1577 G4cout << G4endl; << 1578 } << 1579 } << 1580 << 1581 else if (command == fpCommandTimeWindowFade << 1582 vp.SetFadeFactor(command->ConvertToDouble << 1583 if (verbosity >= G4VisManager::confirmati 1172 if (verbosity >= G4VisManager::confirmations) { 1584 G4cout << "Time window fade factor chan << 1173 G4cout << "Viewpoint direction set to " 1585 << G4endl; << 1174 << vp.GetViewpointDirection() << G4endl; 1586 } << 1175 if (vp.GetLightsMoveWithCamera ()) { 1587 } << 1176 G4cout << "Lightpoint direction set to " 1588 << 1177 << vp.GetActualLightpointDirection () << G4endl; 1589 else if (command == fpCommandTimeWindowStar << 1590 { << 1591 G4String start_time_string, start_time_un << 1592 time_range_string, time_range_unit; << 1593 std::istringstream iss(newValue); << 1594 iss >> start_time_string >> start_time_un << 1595 >> time_range_string >> time_range_unit; << 1596 vp.SetStartTime << 1597 (command->ConvertToDimensionedDouble << 1598 (G4String(start_time_string + ' ' + star << 1599 G4double timeRange = command->ConvertToDi << 1600 (G4String(time_range_string + ' ' + time_ << 1601 if (timeRange > 0.) { << 1602 vp.SetEndTime << 1603 (vp.GetStartTime() + timeRange); << 1604 } << 1605 if (verbosity >= G4VisManager::confirmati << 1606 G4cout << 1607 << "Time window start time: " << vp.Get << 1608 << ", time window end time: " << vp.Get << 1609 if (timeRange > 0.) { << 1610 G4cout << "\n (time range: " << time << 1611 } 1178 } 1612 G4cout << G4endl; << 1613 } 1179 } 1614 } 1180 } 1615 1181 1616 else { 1182 else { 1617 if (verbosity >= G4VisManager::errors) { 1183 if (verbosity >= G4VisManager::errors) { 1618 G4warn << << 1184 G4cout << 1619 "ERROR: G4VisCommandsViewerSet::SetNewV << 1185 "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command." 1620 << G4endl; << 1186 << G4endl; 1621 } 1187 } 1622 return; 1188 return; 1623 } 1189 } 1624 1190 1625 SetViewParameters(currentViewer,vp); 1191 SetViewParameters(currentViewer,vp); 1626 } 1192 } 1627 1193