source: trunk/source/visualization/modeling/src/G4TrajectoryDrawerUtils.cc~ @ 1350

Last change on this file since 1350 was 1350, checked in by garnier, 13 years ago

update to last version 4.9.4
File size: 18.6 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26// $Id: G4TrajectoryDrawerUtils.cc,v 1.15 2010/11/14 22:13:55 allison Exp $
27// GEANT4 tag $Name:  $
28//
29// Jane Tinslay, John Allison, Joseph Perl November 2005
30//
31#include "G4TrajectoryDrawerUtils.hh"
32#include "G4Colour.hh"
33#include "G4Polyline.hh"
34#include "G4Polymarker.hh"
35#include "G4VTrajectory.hh"
36#include "G4VTrajectoryPoint.hh"
37#include "G4VisAttributes.hh"
38#include "G4VisTrajContext.hh"
39#include "G4VVisManager.hh"
40#include "G4UIcommand.hh"
41#include "G4AttValue.hh"
42#include <sstream>
43
44namespace G4TrajectoryDrawerUtils {
45
46
47  void GetPoints(const G4VTrajectory& traj,
48                 G4Polyline& trajectoryLine,
49                 G4Polymarker& auxiliaryPoints,
50                 G4Polymarker& stepPoints)
51  {
52    // Keep positions.  Don't store unless first or different.
53    std::vector<G4ThreeVector> positions;
54
55    for (G4int i=0; i<traj.GetPointEntries(); i++) {
56
57      G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
58      const G4ThreeVector& trajectoryPointPosition =
59        aTrajectoryPoint->GetPosition();
60
61      // Only store if first or if different
62      if (positions.size() == 0 ||
63          trajectoryPointPosition != positions[positions.size()-1]) {
64
65        const std::vector<G4ThreeVector>* auxiliaries
66          = aTrajectoryPoint->GetAuxiliaryPoints();
67        if (0 != auxiliaries) {
68          for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
69            const G4ThreeVector& auxPointPosition = (*auxiliaries)[iAux];
70            if (positions.size() == 0 ||
71                auxPointPosition != positions[positions.size()-1]) {
72              // Only store if first or if different
73              positions.push_back(trajectoryPointPosition);
74              trajectoryLine.push_back(auxPointPosition);
75              auxiliaryPoints.push_back(auxPointPosition);
76            }
77          }
78        }
79
80        positions.push_back(trajectoryPointPosition);
81        trajectoryLine.push_back(trajectoryPointPosition);
82        stepPoints.push_back(trajectoryPointPosition);
83      }
84    }   
85  }
86
87  /***
88  void DrawLineAndPoints(const G4VTrajectory& traj, const G4int& i_mode, const G4Colour& colour, const G4bool& visible) {
89    // If i_mode>=0, draws a trajectory as a polyline (default is blue for
90    // positive, red for negative, green for neutral) and, if i_mode!=0,
91    // adds markers - yellow circles for step points and magenta squares
92    // for auxiliary points, if any - whose screen size in pixels is     
93    // given by std::abs(i_mode)/1000.  E.g: i_mode = 5000 gives easily
94    // visible markers.
95
96    static G4bool warnedAboutIMode = false;
97    std::ostringstream oss;
98    oss << "WARNING: DEPRECATED use of i_mode (i_mode: " << i_mode
99        << ").  Feature will be removed at a future major release.";
100    if (!warnedAboutIMode) {
101      G4Exception
102        ("G4TrajectoryDrawerUtils::DrawLineAndPoints(traj, i_mode, colour, visible)",
103         "",
104         JustWarning,
105         oss.str().c_str());
106      warnedAboutIMode = true;
107    }
108   
109    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
110    if (0 == pVVisManager) return;
111   
112    const G4double markerSize = std::abs(i_mode)/1000;
113    G4bool lineRequired (i_mode >= 0);
114    G4bool markersRequired (markerSize > 0.);   
115   
116    // Return if don't need to do anything
117    if (!lineRequired && !markersRequired) return;
118   
119    // Get points to draw
120    G4Polyline trajectoryLine;
121    G4Polymarker stepPoints;
122    G4Polymarker auxiliaryPoints;
123   
124    GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
125   
126    if (lineRequired) {
127      G4VisAttributes trajectoryLineAttribs(colour);
128      trajectoryLineAttribs.SetVisibility(visible);
129      trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
130      pVVisManager->Draw(trajectoryLine);
131    }
132   
133    if (markersRequired) {
134      auxiliaryPoints.SetMarkerType(G4Polymarker::squares);
135      auxiliaryPoints.SetScreenSize(markerSize);
136      auxiliaryPoints.SetFillStyle(G4VMarker::filled);
137      G4VisAttributes auxiliaryPointsAttribs(G4Colour(0.,1.,1.));  // Magenta
138      auxiliaryPointsAttribs.SetVisibility(visible);
139      auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
140      pVVisManager->Draw(auxiliaryPoints);
141     
142      stepPoints.SetMarkerType(G4Polymarker::circles);
143      stepPoints.SetScreenSize(markerSize);
144      stepPoints.SetFillStyle(G4VMarker::filled); 
145      G4VisAttributes stepPointsAttribs(G4Colour(1.,1.,0.));  // Yellow.
146      stepPoints.SetVisAttributes(&stepPointsAttribs);
147      pVVisManager->Draw(stepPoints);
148    }
149   
150  }
151  ***/
152 
153  static void GetTimes(const G4VTrajectory& traj,
154                       std::vector<G4double>& trajectoryLineTimes,
155                       std::vector<G4double>& auxiliaryPointTimes,
156                       std::vector<G4double>& stepPointTimes)
157  {
158    // It is important check that the sizes of times vectors produced
159    // by this function matches those of points vectors from
160    // GetPoints.  If not, assume that the time information is
161    // invalid.
162
163    // Memory for last trajectory point position for auxiliary point
164    // algorithm.  There are no auxiliary points for the first
165    // trajectory point, so its initial value is immaterial.
166    G4ThreeVector lastTrajectoryPointPosition;
167
168    // Keep positions.  Don't store unless first or different.
169    std::vector<G4ThreeVector> positions;
170
171    for (G4int i=0; i<traj.GetPointEntries(); i++) {
172
173      G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
174      const G4ThreeVector& trajectoryPointPosition =
175        aTrajectoryPoint->GetPosition();
176
177      // Only store if first or if different
178      if (positions.size() == 0 ||
179          trajectoryPointPosition != positions[positions.size()-1]) {
180
181        // Pre- and Post-Point times from the trajectory point...
182        G4double trajectoryPointPreTime = -std::numeric_limits<double>::max();
183        G4double trajectoryPointPostTime = std::numeric_limits<double>::max();
184        std::vector<G4AttValue>* trajectoryPointAttValues =
185          aTrajectoryPoint->CreateAttValues();
186        if (!trajectoryPointAttValues) {
187          G4cout << "G4TrajectoryDrawerUtils::GetTimes: no att values."
188                 << G4endl;
189          return;
190        } else {
191          G4bool foundPreTime = false, foundPostTime = false;
192          for (std::vector<G4AttValue>::iterator i =
193                 trajectoryPointAttValues->begin();
194               i != trajectoryPointAttValues->end(); ++i) {
195            if (i->GetName() == "PreT") {
196              trajectoryPointPreTime =
197                G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
198              foundPreTime = true;
199            }
200            if (i->GetName() == "PostT") {
201              trajectoryPointPostTime =
202                G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
203              foundPostTime = true;
204            }
205          }
206          if (!foundPreTime || !foundPostTime) {
207            static G4bool warnedTimesNotFound = false;
208            if (!warnedTimesNotFound) {
209              G4cout <<
210                "WARNING: G4TrajectoryDrawerUtils::GetTimes: times not found."
211                     << G4endl;
212              warnedTimesNotFound = true;
213            }
214            return;
215          }
216        }
217
218        const std::vector<G4ThreeVector>* auxiliaries
219          = aTrajectoryPoint->GetAuxiliaryPoints();
220        if (0 != auxiliaries) {
221          for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
222            // Interpolate time for auxiliary points...
223            const G4ThreeVector& auxPointPosition = (*auxiliaries)[iAux];
224            G4double s1 = (auxPointPosition - lastTrajectoryPointPosition).mag();
225            G4double s2 = (trajectoryPointPosition - auxPointPosition).mag();
226            G4double t = trajectoryPointPreTime +
227              (trajectoryPointPostTime - trajectoryPointPreTime) *
228              (s1 / (s1 + s2));
229            // Only store if first or if different
230            if (positions.size() == 0 ||
231                auxPointPosition != positions[positions.size()-1]) {
232              positions.push_back(trajectoryPointPosition);
233              trajectoryLineTimes.push_back(t);
234              auxiliaryPointTimes.push_back(t);
235            }
236          }
237        }
238
239        positions.push_back(trajectoryPointPosition);
240        trajectoryLineTimes.push_back(trajectoryPointPostTime);
241        stepPointTimes.push_back(trajectoryPointPostTime);
242
243        lastTrajectoryPointPosition = trajectoryPointPosition;
244      }
245    }   
246  }
247
248  static void SliceLine(G4double timeIncrement,
249                        G4Polyline& trajectoryLine,
250                        std::vector<G4double>& trajectoryLineTimes)
251  {
252    // Assumes valid arguments from GetPoints and GetTimes.
253
254    G4Polyline newTrajectoryLine;
255    std::vector<G4double> newTrajectoryLineTimes;
256
257    newTrajectoryLine.push_back(trajectoryLine[0]);
258    newTrajectoryLineTimes.push_back(trajectoryLineTimes[0]);
259    size_t lineSize = trajectoryLine.size();
260    if (lineSize > 1) {
261      for (size_t i = 1; i < trajectoryLine.size(); ++i) {
262        G4double deltaT = trajectoryLineTimes[i] - trajectoryLineTimes[i - 1];
263        if (deltaT > 0.) {
264          G4double practicalTimeIncrement =
265            std::max(timeIncrement, deltaT / 100.);
266          for (G4double t =
267                 (int(trajectoryLineTimes[i - 1]/practicalTimeIncrement) + 1) *
268                 practicalTimeIncrement;
269               t <= trajectoryLineTimes[i];
270               t += practicalTimeIncrement) {
271            G4ThreeVector pos = trajectoryLine[i - 1] +
272              (trajectoryLine[i] - trajectoryLine[i - 1]) *
273              ((t - trajectoryLineTimes[i - 1]) / deltaT);
274            newTrajectoryLine.push_back(pos);
275            newTrajectoryLineTimes.push_back(t);
276          }
277        }
278        newTrajectoryLine.push_back(trajectoryLine[i]);
279        newTrajectoryLineTimes.push_back(trajectoryLineTimes[i]);
280      }
281    }
282
283    trajectoryLine = newTrajectoryLine;
284    trajectoryLineTimes = newTrajectoryLineTimes;
285  }
286
287  static void DrawWithoutTime(const G4VisTrajContext& myContext,
288                              G4Polyline& trajectoryLine,
289                              G4Polymarker& auxiliaryPoints,
290                              G4Polymarker& stepPoints)
291  {
292    // Draw without time slice information
293#ifdef G4DEBUG_VIS_MODELING
294    printf("G4TrajetoryDrawerUtils::DrawWithoutTime   vvvvv\n");
295#endif
296
297    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
298    if (0 == pVVisManager) return;
299   
300    if (myContext.GetDrawLine()) {
301      G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
302      trajectoryLineAttribs.SetVisibility(myContext.GetLineVisible());
303      trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
304
305      pVVisManager->Draw(trajectoryLine);
306    }
307 
308    if (myContext.GetDrawAuxPts() && (auxiliaryPoints.size() > 0)) {
309      auxiliaryPoints.SetMarkerType(myContext.GetAuxPtsType());
310      auxiliaryPoints.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
311      auxiliaryPoints.SetFillStyle(myContext.GetAuxPtsFillStyle());
312
313      G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour()); 
314      auxiliaryPointsAttribs.SetVisibility(myContext.GetAuxPtsVisible());
315      auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
316
317      pVVisManager->Draw(auxiliaryPoints);
318    }
319 
320    if (myContext.GetDrawStepPts() && (stepPoints.size() > 0)) {
321      stepPoints.SetMarkerType(myContext.GetStepPtsType());
322      stepPoints.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
323      stepPoints.SetFillStyle(myContext.GetStepPtsFillStyle());
324
325      G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour());
326      stepPointsAttribs.SetVisibility(myContext.GetStepPtsVisible());
327      stepPoints.SetVisAttributes(&stepPointsAttribs);
328
329      pVVisManager->Draw(stepPoints);
330    }
331#ifdef G4DEBUG_VIS_MODELING
332    printf("G4TrajetoryDrawerUtils::DrawWithoutTime   ^^^^^\n");
333#endif
334  }
335
336  static void DrawWithTime(const G4VisTrajContext& myContext,
337                           G4Polyline& trajectoryLine,
338                           G4Polymarker& auxiliaryPoints,
339                           G4Polymarker& stepPoints,
340                           std::vector<G4double>& trajectoryLineTimes,
341                           std::vector<G4double>& auxiliaryPointTimes,
342                           std::vector<G4double>& stepPointTimes)
343  {
344    // Draw with time slice information
345
346    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
347    if (0 == pVVisManager) return;
348
349    if (myContext.GetDrawLine()) {
350      G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
351      trajectoryLineAttribs.SetVisibility(myContext.GetLineVisible());
352
353      for (size_t i = 1; i < trajectoryLine.size(); ++i ) {
354        G4Polyline slice;
355        slice.push_back(trajectoryLine[i -1]);
356        slice.push_back(trajectoryLine[i]);
357        trajectoryLineAttribs.SetStartTime(trajectoryLineTimes[i - 1]);
358        trajectoryLineAttribs.SetEndTime(trajectoryLineTimes[i]);
359        slice.SetVisAttributes(&trajectoryLineAttribs);
360        pVVisManager->Draw(slice);
361      }
362    }
363
364    if (myContext.GetDrawAuxPts() && (auxiliaryPoints.size() > 0)) {
365      G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour()); 
366      auxiliaryPointsAttribs.SetVisibility(myContext.GetAuxPtsVisible());
367
368      for (size_t i = 0; i < auxiliaryPoints.size(); ++i ) {
369        G4Polymarker point;
370        point.push_back(auxiliaryPoints[i]);
371        point.SetMarkerType(myContext.GetAuxPtsType());
372        point.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
373        point.SetFillStyle(myContext.GetAuxPtsFillStyle());
374        auxiliaryPointsAttribs.SetStartTime(auxiliaryPointTimes[i]);
375        auxiliaryPointsAttribs.SetEndTime(auxiliaryPointTimes[i]);
376        point.SetVisAttributes(&auxiliaryPointsAttribs);
377        pVVisManager->Draw(point);
378      }
379    }
380
381    if (myContext.GetDrawStepPts() && (stepPoints.size() > 0)) {
382      G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour());
383      stepPointsAttribs.SetVisibility(myContext.GetStepPtsVisible());
384
385      for (size_t i = 0; i < stepPoints.size(); ++i ) {
386        G4Polymarker point;
387        point.push_back(stepPoints[i]);
388        point.SetMarkerType(myContext.GetStepPtsType());
389        point.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
390        point.SetFillStyle(myContext.GetStepPtsFillStyle());
391        stepPointsAttribs.SetStartTime(stepPointTimes[i]);
392        stepPointsAttribs.SetEndTime(stepPointTimes[i]);
393        point.SetVisAttributes(&stepPointsAttribs);
394        pVVisManager->Draw(point);
395      }
396    }
397  }
398
399  void DrawLineAndPoints(const G4VTrajectory& traj, const G4VisTrajContext& context, const G4int& i_mode)
400  {
401    static G4bool warnedAboutIMode = false;
402    std::ostringstream oss;
403    oss << "WARNING: DEPRECATED use of i_mode (i_mode: " << i_mode
404        << ").  Feature will be removed at a future major release.";
405    if (!warnedAboutIMode) {
406      G4Exception
407        ("G4TrajectoryDrawerUtils::DrawLineAndPoints(traj, context, i_mode)",
408         "",
409         JustWarning,
410         oss.str().c_str());
411      warnedAboutIMode = true;
412    }
413
414    // Extra copy while i_mode is still around
415    G4VisTrajContext myContext(context);
416   
417    if (i_mode != 0) {
418      const G4double markerSize = std::abs(i_mode)/1000;
419      G4bool lineRequired (i_mode >= 0);
420      G4bool markersRequired (markerSize > 0.);       
421     
422      myContext.SetDrawLine(lineRequired);
423      myContext.SetDrawAuxPts(markersRequired);
424      myContext.SetDrawStepPts(markersRequired);
425
426      myContext.SetAuxPtsSize(markerSize);
427      myContext.SetStepPtsSize(markerSize);
428    }
429
430    // Return if don't need to do anything
431    if (!myContext.GetDrawLine() && !myContext.GetDrawAuxPts() && !myContext.GetDrawStepPts()) return;
432   
433    // Get points to draw
434    G4Polyline trajectoryLine;
435    G4Polymarker stepPoints;
436    G4Polymarker auxiliaryPoints;
437   
438    GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
439   
440    if (myContext.GetTimeSliceInterval()) {
441
442      // Get corresponding track time information, if any
443      std::vector<G4double> trajectoryLineTimes;
444      std::vector<G4double> stepPointTimes;
445      std::vector<G4double> auxiliaryPointTimes;
446 
447      GetTimes(traj, trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
448
449      // Check validity
450      if (trajectoryLineTimes.size() != trajectoryLine.size() ||
451          stepPointTimes.size() != stepPoints.size() ||
452          auxiliaryPointTimes.size() != auxiliaryPoints.size()) {
453
454        // Revert to drawing without time information...
455        DrawWithoutTime(myContext, trajectoryLine, auxiliaryPoints, stepPoints);
456      } else {
457
458        SliceLine(myContext.GetTimeSliceInterval(),
459                  trajectoryLine, trajectoryLineTimes);
460
461        DrawWithTime(myContext,
462                     trajectoryLine, auxiliaryPoints, stepPoints,
463                     trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
464      }
465
466    } else {
467
468      DrawWithoutTime(myContext, trajectoryLine, auxiliaryPoints, stepPoints);
469
470    }
471  }
472
473  void DrawLineAndPoints(const G4VTrajectory& traj, const G4VisTrajContext& context)
474  {
475    // Return if don't need to do anything
476    if (!context.GetDrawLine() && !context.GetDrawAuxPts() && !context.GetDrawStepPts()) return;
477   
478    // Get points to draw
479    G4Polyline trajectoryLine;
480    G4Polymarker stepPoints;
481    G4Polymarker auxiliaryPoints;
482   
483    GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
484   
485    if (context.GetTimeSliceInterval()) {
486
487      // Get corresponding track time information, if any
488      std::vector<G4double> trajectoryLineTimes;
489      std::vector<G4double> stepPointTimes;
490      std::vector<G4double> auxiliaryPointTimes;
491 
492      GetTimes(traj, trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
493
494      // Check validity
495      if (trajectoryLineTimes.size() != trajectoryLine.size() ||
496          stepPointTimes.size() != stepPoints.size() ||
497          auxiliaryPointTimes.size() != auxiliaryPoints.size()) {
498
499        // Revert to drawing without time information...
500        DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
501      } else {
502
503        SliceLine(context.GetTimeSliceInterval(),
504                  trajectoryLine, trajectoryLineTimes);
505
506        DrawWithTime(context,
507                     trajectoryLine, auxiliaryPoints, stepPoints,
508                     trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
509      }
510
511    } else {
512
513      DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
514
515    }
516  }
517}
Note: See TracBrowser for help on using the repository browser.