Changeset 593 for trunk/geant4/visualization/management/src/G4VSceneHandler.cc

Timestamp:

Nov 9, 2007, 3:32:25 PM (17 years ago)

Author:

garnier

Message:

r627@mac-90108: laurentgarnier | 2007-11-09 07:57:42 +0100
modif dans les includes directives

File:

• trunk/geant4/visualization/management/src/G4VSceneHandler.cc (modified) (12 diffs)

trunk/geant4/visualization/management/src/G4VSceneHandler.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4VSceneHandler.cc,v 1.77 2006/11/21 14:23:53 allison Exp $
-// GEANT4 tag $Name: geant4-08-02-patch-01 $
+// $Id: G4VSceneHandler.cc,v 1.82 2007/05/16 15:47:44 allison Exp $
+// GEANT4 tag $Name: geant4-09-00-ref-01 $
 //
 // 
@@ -71 +71 @@
 #include "G4ModelingParameters.hh"
 #include "G4VTrajectory.hh"
+#include "G4VTrajectoryPoint.hh"
+#include "G4HitsModel.hh"
 #include "G4VHit.hh"
 #include "Randomize.hh"
@@ -77 +79 @@
 #include "G4Run.hh"
 #include "G4Transform3D.hh"
+#include "G4AttHolder.hh"
+#include "G4AttDef.hh"
 
 G4VSceneHandler::G4VSceneHandler (G4VGraphicsSystem& system, G4int id, const G4String& name):
@@ -95 +99 @@
   fpObjectTransformation (0),
   fNestingDepth          (0),
-  fpVisAttribs           (0),
-  fRequestedEvent        (0)
+  fpVisAttribs           (0)
 {
   G4VisManager* pVMan = G4VisManager::GetInstance ();
@@ -421 +424 @@
   G4NURBS* pNURBS = 0;
   G4Polyhedron* pPolyhedron = 0;
-  const G4VisAttributes* pVisAttribs =
-    fpViewer -> GetApplicableVisAttributes (fpVisAttribs);
   switch (fpViewer -> GetViewParameters () . GetRepStyle ()) {
   case G4ViewParameters::nurbs:
     pNURBS = solid.CreateNURBS ();
     if (pNURBS) {
-      pNURBS -> SetVisAttributes
-        (fpViewer -> GetApplicableVisAttributes (pVisAttribs));
+      pNURBS -> SetVisAttributes (fpVisAttribs);
       AddPrimitive (*pNURBS);
       delete pNURBS;
@@ -447 +447 @@
   case G4ViewParameters::polyhedron:
   default:
-    G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (pVisAttribs));
+    G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (fpVisAttribs));
     pPolyhedron = solid.GetPolyhedron ();
     G4Polyhedron::ResetNumberOfRotationSteps ();
     if (pPolyhedron) {
-      pPolyhedron -> SetVisAttributes (pVisAttribs);
+      pPolyhedron -> SetVisAttributes (fpVisAttribs);
       AddPrimitive (*pPolyhedron);
     }
@@ -471 +471 @@
 
 void G4VSceneHandler::ProcessScene (G4VViewer&) {
-  printf("G4VSceneHandler::ProcessScene\n");
+
   if (!fpScene) return;
 
@@ -545 +545 @@
   G4StateManager* stateManager = G4StateManager::GetStateManager();
   G4ApplicationState state = stateManager->GetCurrentState();
-
-  printf("G4VSceneHandler::ProcessScene 1\n");
   if (state == G4State_Idle) {
-  printf("G4VSceneHandler::ProcessScene 2 : idle\n");
 
     visManager->SetEventRefreshing(true);
 
-    if (fRequestedEvent) {
-      DrawEvent(fRequestedEvent);
-      printf("G4VSceneHandler::ProcessScene 3 : fRequestedEvent\n");
+    if (visManager->GetRequestedEvent()) {
+      DrawEvent(visManager->GetRequestedEvent());
 
     } else {
-      printf("G4VSceneHandler::ProcessScene 3 : not fRequestedEvent\n");
 
       G4RunManager* runManager = G4RunManager::GetRunManager();
-      const G4Run* run = runManager->GetCurrentRun();
-      const std::vector<const G4Event*>* events =
-        run? run->GetEventVector(): 0;
-      size_t nKeptEvents = 0;
-      if (events) nKeptEvents = events->size();
       if (runManager) {
-          printf("G4VSceneHandler::ProcessScene 4 : run manager OK\n");
-        if (fpScene->GetRefreshAtEndOfEvent()) {
-          printf("G4VSceneHandler::ProcessScene 5 : fpScene->GetRefreshAtEndOfEvent()\n");
-
-          if (verbosity >= G4VisManager::confirmations) {
-            G4cout << "Refreshing event..." << G4endl;
-          }
-          const G4Event* event = 0;
-          if (events && events->size()) event = events->back();
-          if (event) DrawEvent(event);
-
-        } else {  // Accumulating events.
-  printf("G4VSceneHandler::ProcessScene 7\n");
-
-          if (verbosity >= G4VisManager::confirmations) {
-            G4cout << "Refreshing events in run..." << G4endl;
-          }
-          for (size_t i = 0; i < nKeptEvents; ++i) {
-            const G4Event* event = (*events)[i];
+        const G4Run* run = runManager->GetCurrentRun();
+        const std::vector<const G4Event*>* events =
+          run? run->GetEventVector(): 0;
+        size_t nKeptEvents = 0;
+        if (events) nKeptEvents = events->size();
+        if (nKeptEvents) {
+
+          if (fpScene->GetRefreshAtEndOfEvent()) {
+
+            if (verbosity >= G4VisManager::confirmations) {
+              G4cout << "Refreshing event..." << G4endl;
+            }
+            const G4Event* event = 0;
+            if (events && events->size()) event = events->back();
             if (event) DrawEvent(event);
-          }
-
-          if (!fpScene->GetRefreshAtEndOfRun()) {
-            if (verbosity >= G4VisManager::warnings) {
-              G4cout <<
-                "WARNING: Cannot refresh events accumulated over more"
-                "\n  than one runs.  Refreshed just the last run..."
-                     << G4endl;
+
+          } else {  // Accumulating events.
+
+            if (verbosity >= G4VisManager::confirmations) {
+              G4cout << "Refreshing events in run..." << G4endl;
+            }
+            for (size_t i = 0; i < nKeptEvents; ++i) {
+              const G4Event* event = (*events)[i];
+              if (event) DrawEvent(event);
+            }
+
+            if (!fpScene->GetRefreshAtEndOfRun()) {
+              if (verbosity >= G4VisManager::warnings) {
+                G4cout <<
+                  "WARNING: Cannot refresh events accumulated over more"
+                  "\n  than one runs.  Refreshed just the last run."
+                       << G4endl;
+              }
             }
           }
         }
       }
-   }
-   visManager->SetEventRefreshing(false);
- }
+    }
+    visManager->SetEventRefreshing(false);
+  }
 
   fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
-  printf("G4VSceneHandler::ProcessScene terminé \n");
 }
 
 void G4VSceneHandler::DrawEvent(const G4Event* event)
 {
-  printf("G4VSceneHandler::DrawEvent \n");
   const std::vector<G4VModel*>& EOEModelList =
     fpScene -> GetEndOfEventModelList ();
@@ -718 +711 @@
 }
 
+void G4VSceneHandler::LoadAtts(const G4Visible& visible, G4AttHolder* holder)
+{
+  // Load G4Atts from G4VisAttributes, if any...
+  const G4VisAttributes* va = visible.GetVisAttributes();
+  if (va) {
+    const std::map<G4String,G4AttDef>* vaDefs =
+      va->GetAttDefs();
+    if (vaDefs) {
+      holder->AddAtts(visible.GetVisAttributes()->CreateAttValues(), vaDefs);
+    }
+  }
+
+  G4PhysicalVolumeModel* pPVModel =
+    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
+  if (pPVModel) {
+    // Load G4Atts from G4PhysicalVolumeModel...
+    const std::map<G4String,G4AttDef>* defs = pPVModel->GetAttDefs();
+    if (defs) {
+      holder->AddAtts(pPVModel->CreateCurrentAttValues(), defs);
+    }
+  }
+
+  G4TrajectoriesModel* trajModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
+  if (trajModel) {
+    // Load G4Atts from trajectory...
+    const G4VTrajectory* traj = trajModel->GetCurrentTrajectory();
+    const std::map<G4String,G4AttDef>* defs = traj->GetAttDefs();
+    if (defs) {
+      holder->AddAtts(traj->CreateAttValues(), defs);
+    }
+    G4int nPoints = traj->GetPointEntries();
+    for (G4int i = 0; i < nPoints; ++i) {
+      G4VTrajectoryPoint* trajPoint = traj->GetPoint(i);
+      const std::map<G4String,G4AttDef>* defs = trajPoint->GetAttDefs();
+      if (defs) {
+        holder->AddAtts(trajPoint->CreateAttValues(), defs);
+      }
+    }
+  }
+
+  G4HitsModel* hitsModel = dynamic_cast<G4HitsModel*>(fpModel);
+  if (hitsModel) {
+    // Load G4Atts from hit...
+    const G4VHit* hit = hitsModel->GetCurrentHit();
+    const std::map<G4String,G4AttDef>* defs = hit->GetAttDefs();
+    if (defs) {
+      holder->AddAtts(hit->CreateAttValues(), defs);
+    }
+  }
+}
+
 const G4Colour& G4VSceneHandler::GetColour (const G4Visible& visible) {
   // Colour is determined by the applicable vis attributes.
@@ -734 +778 @@
 }
 
-G4double G4VSceneHandler::GetLineWidth(const G4Visible& visible)
-{
-  G4double lineWidth = fpViewer->
-    GetApplicableVisAttributes(visible.GetVisAttributes())->GetLineWidth();
+G4double G4VSceneHandler::GetLineWidth(const G4VisAttributes* pVisAttribs)
+{
+  G4double lineWidth = pVisAttribs->GetLineWidth();
   if (lineWidth < 1.) lineWidth = 1.;
   lineWidth *= fpViewer -> GetViewParameters().GetGlobalLineWidthScale();
@@ -749 +792 @@
   // it can be overriddden by the ForceDrawingStyle flag in the vis
   // attributes.
-  G4ViewParameters::DrawingStyle style =
+  G4ViewParameters::DrawingStyle style = 
     fpViewer->GetViewParameters().GetDrawingStyle();
   if (pVisAttribs -> IsForceDrawingStyle ()) {
@@ -821 +864 @@
   // ForceLineSegmentsPerCircle in the vis attributes.
   G4int lineSegmentsPerCircle = fpViewer->GetViewParameters().GetNoOfSides();
-  if (pVisAttribs->GetForcedLineSegmentsPerCircle() > 0)
-    lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
-  const G4int nSegmentsMin = 12;
-  if (lineSegmentsPerCircle < nSegmentsMin) {
-    lineSegmentsPerCircle = nSegmentsMin;
-    G4cout <<
-      "G4VSceneHandler::GetNoOfSides: attempt to set the"
-      "\nnumber of line segements per circle < " << nSegmentsMin
-         << "; forced to " << lineSegmentsPerCircle << G4endl;
+  if (pVisAttribs) {
+    if (pVisAttribs->IsForceLineSegmentsPerCircle())
+      lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
+    const G4int nSegmentsMin = 12;
+    if (lineSegmentsPerCircle < nSegmentsMin) {
+      lineSegmentsPerCircle = nSegmentsMin;
+      G4cout <<
+        "G4VSceneHandler::GetNoOfSides: attempt to set the"
+        "\nnumber of line segements per circle < " << nSegmentsMin
+             << "; forced to " << lineSegmentsPerCircle << G4endl;
+    }
   }
   return lineSegmentsPerCircle;