Context Navigation

source: trunk/source/visualization/modeling/src/G4TrajectoryDrawerUtils.cc @ 1337

Last change on this file since 1337 was 1337, checked in by garnier, 14 years ago
tag geant4.9.4 beta 1 + modifs locales
File size: 17.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.14 2010/05/11 11:58:18 allison Exp $
27	// GEANT4 tag $Name: geant4-09-04-beta-01 $
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
44	namespace G4TrajectoryDrawerUtils {
45
46
47	void GetPoints(const G4VTrajectory& traj, G4Polyline& trajectoryLine,
48	G4Polymarker& auxiliaryPoints, G4Polymarker& stepPoints)
49	{
50	for (G4int i=0; i<traj.GetPointEntries(); i++) {
51	G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
52
53	const std::vector<G4ThreeVector>* auxiliaries
54	= aTrajectoryPoint->GetAuxiliaryPoints();
55
56	if (0 != auxiliaries) {
57	for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
58	const G4ThreeVector pos((*auxiliaries)[iAux]);
59	if (trajectoryLine.size() >0) {
60	if (pos != trajectoryLine[trajectoryLine.size()-1]) {
61	trajectoryLine.push_back(pos);
62	auxiliaryPoints.push_back(pos);
63	}
64	} else {
65	trajectoryLine.push_back(pos);
66	auxiliaryPoints.push_back(pos);
67	}
68	}
69	}
70	const G4ThreeVector pos(aTrajectoryPoint->GetPosition());
71	if (trajectoryLine.size() >0) {
72	if (pos != trajectoryLine[trajectoryLine.size()-1]) {
73	trajectoryLine.push_back(pos);
74	stepPoints.push_back(pos);
75	}
76	} else {
77	trajectoryLine.push_back(pos);
78	stepPoints.push_back(pos);
79	}
80	}
81	}
82
83	/***
84	void DrawLineAndPoints(const G4VTrajectory& traj, const G4int& i_mode, const G4Colour& colour, const G4bool& visible) {
85	// If i_mode>=0, draws a trajectory as a polyline (default is blue for
86	// positive, red for negative, green for neutral) and, if i_mode!=0,
87	// adds markers - yellow circles for step points and magenta squares
88	// for auxiliary points, if any - whose screen size in pixels is
89	// given by std::abs(i_mode)/1000. E.g: i_mode = 5000 gives easily
90	// visible markers.
91
92	static G4bool warnedAboutIMode = false;
93	std::ostringstream oss;
94	oss << "WARNING: DEPRECATED use of i_mode (i_mode: " << i_mode
95	<< "). Feature will be removed at a future major release.";
96	if (!warnedAboutIMode) {
97	G4Exception
98	("G4TrajectoryDrawerUtils::DrawLineAndPoints(traj, i_mode, colour, visible)",
99	"",
100	JustWarning,
101	oss.str().c_str());
102	warnedAboutIMode = true;
103	}
104
105	G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
106	if (0 == pVVisManager) return;
107
108	const G4double markerSize = std::abs(i_mode)/1000;
109	G4bool lineRequired (i_mode >= 0);
110	G4bool markersRequired (markerSize > 0.);
111
112	// Return if don't need to do anything
113	if (!lineRequired && !markersRequired) return;
114
115	// Get points to draw
116	G4Polyline trajectoryLine;
117	G4Polymarker stepPoints;
118	G4Polymarker auxiliaryPoints;
119
120	GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
121
122	if (lineRequired) {
123	G4VisAttributes trajectoryLineAttribs(colour);
124	trajectoryLineAttribs.SetVisibility(visible);
125	trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
126	pVVisManager->Draw(trajectoryLine);
127	}
128
129	if (markersRequired) {
130	auxiliaryPoints.SetMarkerType(G4Polymarker::squares);
131	auxiliaryPoints.SetScreenSize(markerSize);
132	auxiliaryPoints.SetFillStyle(G4VMarker::filled);
133	G4VisAttributes auxiliaryPointsAttribs(G4Colour(0.,1.,1.)); // Magenta
134	auxiliaryPointsAttribs.SetVisibility(visible);
135	auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
136	pVVisManager->Draw(auxiliaryPoints);
137
138	stepPoints.SetMarkerType(G4Polymarker::circles);
139	stepPoints.SetScreenSize(markerSize);
140	stepPoints.SetFillStyle(G4VMarker::filled);
141	G4VisAttributes stepPointsAttribs(G4Colour(1.,1.,0.)); // Yellow.
142	stepPoints.SetVisAttributes(&stepPointsAttribs);
143	pVVisManager->Draw(stepPoints);
144	}
145
146	}
147	***/
148
149	static void GetTimes(const G4VTrajectory& traj,
150	std::vector<G4double>& trajectoryLineTimes,
151	std::vector<G4double>& auxiliaryPointTimes,
152	std::vector<G4double>& stepPointTimes)
153	{
154	// It is important check that the sizes of times vectors produced
155	// by this function matches those of points vectors from
156	// GetPoints. If not, assume that the time information is
157	// invalid.
158
159	G4ThreeVector lastTrajectoryPointPosition;
160	for (G4int i=0; i<traj.GetPointEntries(); i++) {
161	G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
162
163	// Pre- and Post-Point times from the trajectory point...
164	G4double trajectoryPointPreTime = -std::numeric_limits<double>::max();
165	G4double trajectoryPointPostTime = std::numeric_limits<double>::max();
166	std::vector<G4AttValue>* trajectoryPointAttValues =
167	aTrajectoryPoint->CreateAttValues();
168	if (!trajectoryPointAttValues) {
169	G4cout << "G4TrajectoryDrawerUtils::GetTimes: no att values."
170	<< G4endl;
171	return;
172	} else {
173	G4bool foundPreTime = false, foundPostTime = false;
174	for (std::vector<G4AttValue>::iterator i =
175	trajectoryPointAttValues->begin();
176	i != trajectoryPointAttValues->end(); ++i) {
177	if (i->GetName() == "PreT") {
178	trajectoryPointPreTime =
179	G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
180	foundPreTime = true;
181	}
182	if (i->GetName() == "PostT") {
183	trajectoryPointPostTime =
184	G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
185	foundPostTime = true;
186	}
187	}
188	if (!foundPreTime \|\| !foundPostTime) {
189	static G4bool warnedTimesNotFound = false;
190	if (!warnedTimesNotFound) {
191	G4cout <<
192	"WARNING: G4TrajectoryDrawerUtils::GetTimes: times not found."
193	<< G4endl;
194	warnedTimesNotFound = true;
195	}
196	return;
197	}
198	}
199
200	const G4ThreeVector& trajectoryPointPosition =
201	aTrajectoryPoint->GetPosition();
202
203	const std::vector<G4ThreeVector>* auxiliaries
204	= aTrajectoryPoint->GetAuxiliaryPoints();
205
206	if (0 != auxiliaries) {
207	for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
208	// Interpolate time for auxiliary points...
209	const G4ThreeVector pos((*auxiliaries)[iAux]);
210	G4double s1 = (pos - lastTrajectoryPointPosition).mag();
211	G4double s2 = (trajectoryPointPosition - pos).mag();
212	G4double t = trajectoryPointPreTime +
213	(trajectoryPointPostTime - trajectoryPointPreTime) *
214	(s1 / (s1 + s2));
215	trajectoryLineTimes.push_back(t);
216	auxiliaryPointTimes.push_back(t);
217	}
218	}
219
220	trajectoryLineTimes.push_back(trajectoryPointPostTime);
221	stepPointTimes.push_back(trajectoryPointPostTime);
222
223	lastTrajectoryPointPosition = trajectoryPointPosition;
224	}
225	}
226
227	static void SliceLine(G4double timeIncrement,
228	G4Polyline& trajectoryLine,
229	std::vector<G4double>& trajectoryLineTimes)
230	{
231	// Assumes valid arguments from GetPoints and GetTimes.
232
233	G4Polyline newTrajectoryLine;
234	std::vector<G4double> newTrajectoryLineTimes;
235
236	newTrajectoryLine.push_back(trajectoryLine[0]);
237	newTrajectoryLineTimes.push_back(trajectoryLineTimes[0]);
238	size_t lineSize = trajectoryLine.size();
239	if (lineSize > 1) {
240	for (size_t i = 1; i < trajectoryLine.size(); ++i) {
241	G4double deltaT = trajectoryLineTimes[i] - trajectoryLineTimes[i - 1];
242	if (deltaT > 0.) {
243	G4double practicalTimeIncrement =
244	std::max(timeIncrement, deltaT / 100.);
245	for (G4double t =
246	(int(trajectoryLineTimes[i - 1]/practicalTimeIncrement) + 1) *
247	practicalTimeIncrement;
248	t <= trajectoryLineTimes[i];
249	t += practicalTimeIncrement) {
250	G4ThreeVector pos = trajectoryLine[i - 1] +
251	(trajectoryLine[i] - trajectoryLine[i - 1]) *
252	((t - trajectoryLineTimes[i - 1]) / deltaT);
253	newTrajectoryLine.push_back(pos);
254	newTrajectoryLineTimes.push_back(t);
255	}
256	}
257	newTrajectoryLine.push_back(trajectoryLine[i]);
258	newTrajectoryLineTimes.push_back(trajectoryLineTimes[i]);
259	}
260	}
261
262	trajectoryLine = newTrajectoryLine;
263	trajectoryLineTimes = newTrajectoryLineTimes;
264	}
265
266	static void DrawWithoutTime(const G4VisTrajContext& myContext,
267	G4Polyline& trajectoryLine,
268	G4Polymarker& auxiliaryPoints,
269	G4Polymarker& stepPoints)
270	{
271	// Draw without time slice information
272
273	G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
274	if (0 == pVVisManager) return;
275
276	if (myContext.GetDrawLine()) {
277	G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
278	trajectoryLineAttribs.SetVisibility(myContext.GetLineVisible());
279	trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
280
281	pVVisManager->Draw(trajectoryLine);
282	}
283
284	if (myContext.GetDrawAuxPts() && (auxiliaryPoints.size() > 0)) {
285	auxiliaryPoints.SetMarkerType(myContext.GetAuxPtsType());
286	auxiliaryPoints.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
287	auxiliaryPoints.SetFillStyle(myContext.GetAuxPtsFillStyle());
288
289	G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour());
290	auxiliaryPointsAttribs.SetVisibility(myContext.GetAuxPtsVisible());
291	auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
292
293	pVVisManager->Draw(auxiliaryPoints);
294	}
295
296	if (myContext.GetDrawStepPts() && (stepPoints.size() > 0)) {
297	stepPoints.SetMarkerType(myContext.GetStepPtsType());
298	stepPoints.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
299	stepPoints.SetFillStyle(myContext.GetStepPtsFillStyle());
300
301	G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour());
302	stepPointsAttribs.SetVisibility(myContext.GetStepPtsVisible());
303	stepPoints.SetVisAttributes(&stepPointsAttribs);
304
305	pVVisManager->Draw(stepPoints);
306	}
307	}
308
309	static void DrawWithTime(const G4VisTrajContext& myContext,
310	G4Polyline& trajectoryLine,
311	G4Polymarker& auxiliaryPoints,
312	G4Polymarker& stepPoints,
313	std::vector<G4double>& trajectoryLineTimes,
314	std::vector<G4double>& auxiliaryPointTimes,
315	std::vector<G4double>& stepPointTimes)
316	{
317	// Draw with time slice information
318
319	G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
320	if (0 == pVVisManager) return;
321
322	if (myContext.GetDrawLine()) {
323	G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
324	trajectoryLineAttribs.SetVisibility(myContext.GetLineVisible());
325
326	for (size_t i = 1; i < trajectoryLine.size(); ++i ) {
327	G4Polyline slice;
328	slice.push_back(trajectoryLine[i -1]);
329	slice.push_back(trajectoryLine[i]);
330	trajectoryLineAttribs.SetStartTime(trajectoryLineTimes[i - 1]);
331	trajectoryLineAttribs.SetEndTime(trajectoryLineTimes[i]);
332	slice.SetVisAttributes(&trajectoryLineAttribs);
333	pVVisManager->Draw(slice);
334	}
335	}
336
337	if (myContext.GetDrawAuxPts() && (auxiliaryPoints.size() > 0)) {
338	G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour());
339	auxiliaryPointsAttribs.SetVisibility(myContext.GetAuxPtsVisible());
340
341	for (size_t i = 0; i < auxiliaryPoints.size(); ++i ) {
342	G4Polymarker point;
343	point.push_back(auxiliaryPoints[i]);
344	point.SetMarkerType(myContext.GetAuxPtsType());
345	point.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
346	point.SetFillStyle(myContext.GetAuxPtsFillStyle());
347	auxiliaryPointsAttribs.SetStartTime(auxiliaryPointTimes[i]);
348	auxiliaryPointsAttribs.SetEndTime(auxiliaryPointTimes[i]);
349	point.SetVisAttributes(&auxiliaryPointsAttribs);
350	pVVisManager->Draw(point);
351	}
352	}
353
354	if (myContext.GetDrawStepPts() && (stepPoints.size() > 0)) {
355	G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour());
356	stepPointsAttribs.SetVisibility(myContext.GetStepPtsVisible());
357
358	for (size_t i = 0; i < stepPoints.size(); ++i ) {
359	G4Polymarker point;
360	point.push_back(stepPoints[i]);
361	point.SetMarkerType(myContext.GetStepPtsType());
362	point.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
363	point.SetFillStyle(myContext.GetStepPtsFillStyle());
364	stepPointsAttribs.SetStartTime(stepPointTimes[i]);
365	stepPointsAttribs.SetEndTime(stepPointTimes[i]);
366	point.SetVisAttributes(&stepPointsAttribs);
367	pVVisManager->Draw(point);
368	}
369	}
370	}
371
372	void DrawLineAndPoints(const G4VTrajectory& traj, const G4VisTrajContext& context, const G4int& i_mode)
373	{
374	static G4bool warnedAboutIMode = false;
375	std::ostringstream oss;
376	oss << "WARNING: DEPRECATED use of i_mode (i_mode: " << i_mode
377	<< "). Feature will be removed at a future major release.";
378	if (!warnedAboutIMode) {
379	G4Exception
380	("G4TrajectoryDrawerUtils::DrawLineAndPoints(traj, context, i_mode)",
381	"",
382	JustWarning,
383	oss.str().c_str());
384	warnedAboutIMode = true;
385	}
386
387	// Extra copy while i_mode is still around
388	G4VisTrajContext myContext(context);
389
390	if (i_mode != 0) {
391	const G4double markerSize = std::abs(i_mode)/1000;
392	G4bool lineRequired (i_mode >= 0);
393	G4bool markersRequired (markerSize > 0.);
394
395	myContext.SetDrawLine(lineRequired);
396	myContext.SetDrawAuxPts(markersRequired);
397	myContext.SetDrawStepPts(markersRequired);
398
399	myContext.SetAuxPtsSize(markerSize);
400	myContext.SetStepPtsSize(markerSize);
401	}
402
403	// Return if don't need to do anything
404	if (!myContext.GetDrawLine() && !myContext.GetDrawAuxPts() && !myContext.GetDrawStepPts()) return;
405
406	// Get points to draw
407	G4Polyline trajectoryLine;
408	G4Polymarker stepPoints;
409	G4Polymarker auxiliaryPoints;
410
411	GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
412
413	if (myContext.GetTimeSliceInterval()) {
414
415	// Get corresponding track time information, if any
416	std::vector<G4double> trajectoryLineTimes;
417	std::vector<G4double> stepPointTimes;
418	std::vector<G4double> auxiliaryPointTimes;
419
420	GetTimes(traj, trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
421
422	// Check validity
423	if (trajectoryLineTimes.size() != trajectoryLine.size() \|\|
424	stepPointTimes.size() != stepPoints.size() \|\|
425	auxiliaryPointTimes.size() != auxiliaryPoints.size()) {
426
427	// Revert to drawing without time information...
428	DrawWithoutTime(myContext, trajectoryLine, auxiliaryPoints, stepPoints);
429	} else {
430
431	SliceLine(myContext.GetTimeSliceInterval(),
432	trajectoryLine, trajectoryLineTimes);
433
434	DrawWithTime(myContext,
435	trajectoryLine, auxiliaryPoints, stepPoints,
436	trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
437	}
438
439	} else {
440
441	DrawWithoutTime(myContext, trajectoryLine, auxiliaryPoints, stepPoints);
442
443	}
444	}
445
446	void DrawLineAndPoints(const G4VTrajectory& traj, const G4VisTrajContext& context)
447	{
448	// Return if don't need to do anything
449	if (!context.GetDrawLine() && !context.GetDrawAuxPts() && !context.GetDrawStepPts()) return;
450
451	// Get points to draw
452	G4Polyline trajectoryLine;
453	G4Polymarker stepPoints;
454	G4Polymarker auxiliaryPoints;
455
456	GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
457
458	if (context.GetTimeSliceInterval()) {
459
460	// Get corresponding track time information, if any
461	std::vector<G4double> trajectoryLineTimes;
462	std::vector<G4double> stepPointTimes;
463	std::vector<G4double> auxiliaryPointTimes;
464
465	GetTimes(traj, trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
466
467	// Check validity
468	if (trajectoryLineTimes.size() != trajectoryLine.size() \|\|
469	stepPointTimes.size() != stepPoints.size() \|\|
470	auxiliaryPointTimes.size() != auxiliaryPoints.size()) {
471
472	// Revert to drawing without time information...
473	DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
474	} else {
475
476	SliceLine(context.GetTimeSliceInterval(),
477	trajectoryLine, trajectoryLineTimes);
478
479	DrawWithTime(context,
480	trajectoryLine, auxiliaryPoints, stepPoints,
481	trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
482	}
483
484	} else {
485
486	DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
487
488	}
489	}
490	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: