TridPageDetector.cxx

Go to the documentation of this file.

// Root stuff:
#include <TStyle.h>
#include <TColor.h>
#include <TROOT.h>
#include <TH1.h>
#include <TGeoManager.h>

// Trid Stuff:
#include "TridPageDetector.h"
#include "TridModelStrip.h"
#include "TridModelIntersect.h"
#include "TridGLFrame.h"
#include "TridFlatGLFrame.h"
#include "TridSketches.h"
#include "TridControl.h"
#include "TridModelTrack.h"
#include "TridModelShower.h"
#include "TridModelRecoStrip.h"
#include "TridModelMaker.h"

// Midad:
#include "Midad/Base/PageProxy.h"
#include "Midad/Gui/GuiBox.h"
#include "Midad/Gui/GuiCanvas.h"
#include "Midad/Gui/GuiMainWindow.h"
#include "Midad/Gui/GuiMenu.h"
#include "Midad/Base/Mint.h"
#include "Midad/Base/PageDisplay.h"
#include "Midad/Base/DigitText.h"

// SigC:
#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>

// Offline:
#include <DataUtil/GetCandidate.h>
#include <JobControl/JobC.h>
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexStripEndId.h"
#include "Plex/PlexVetoShieldHack.h"
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitHandle.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliStripHandle.h"

// Reco:
#include "RecoBase/CandTrackListHandle.h"
#include "RecoBase/CandShowerListHandle.h"
#include "RecoBase/CandStripHandle.h"

#include <cmath>

CVSID("$Id: TridPageDetector.cxx,v 1.34 2007/09/14 14:12:19 tagg Exp $");

using namespace SigC;

// We don't use this here because we are just a base class.  But, any
// subclass should have a version like it.
static PageProxy<TridPageDetector> gsTridPageProxy("TridDetector");


TridPageDetector::TridPageDetector()
  : TridPage(),
    fShowTracks(true),
    fShowShowerBlobs(true),
    fShowShowerStrips(true),
    fShowClusters(true),
    fShowStrips(false),
    fShowIntersections(false),
    fShowLoneStrips(false),
    fExaggerateWidth(false),
    fExaggerateThickness(true),
    fBestDemuxOnly(true),
    fEndOnOrthoView(false)
{
  // Default view mode.
  fViewModesSupported = kView3D | kView2D | kViewStereo | kViewCrossEyed | kViewRedBlue | kViewBlueRed;
  fViewMode = kView3D;
  fWindowName = "TridDetector";
}

TridPageDetector::~TridPageDetector()
{
  fModels.Clear();
  // This is now taken care of by the SigC::Ptr stuff.
  // if(fGLFrame) delete fGLFrame;
}

TObject* TridPageDetector::Init(Mint* mint, PageDisplay* pd, GuiBox& box)
{ 
  TridPage::Init(mint,pd,box);

  // Add custom things for this view.

  MSG("TriD",Msg::kDebug) << "TridPageDetector: Init()" << endl;
  
  GuiMenu::GuiMenuList::iterator mit;

  fShowTracks.AddToMenu(fOptionsMenu,"Show Tracks");
  fShowTracks.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  fShowShowerBlobs.AddToMenu(fOptionsMenu,"Show Shower Blobs");
  fShowShowerBlobs.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  fShowShowerStrips.AddToMenu(fOptionsMenu,"Show Shower Strips");
  fShowShowerStrips.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  // fShowClusters.AddToMenu(fOptionsMenu,"Show Clusters");
  // fShowClusters.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  fShowStrips.AddToMenu(fOptionsMenu,"Show Strips");
  fShowStrips.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  fShowIntersections.AddToMenu(fOptionsMenu,"Show Intersections");
  fShowIntersections.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  fShowLoneStrips.AddToMenu(fOptionsMenu,"Show Lone Strips");
  fShowLoneStrips.Connect(slot_class(*this,&TridPageDetector::ModifySketches));

  fExaggerateWidth.AddToMenu(fOptionsMenu,"Exaggerate Strip Width");
  fExaggerateWidth.Connect(slot_class(*this,&TridPageDetector::ChangeSketches));

  fExaggerateThickness.AddToMenu(fOptionsMenu,"Exaggerate Strip Thickness");
  fExaggerateThickness.Connect(slot_class(*this,&TridPageDetector::ChangeSketches));

  //fBestDemuxOnly.AddToMenu(fOptionsMenu,"Best Demux Only");
  //fBestDemuxOnly.Connect(slot_class(*(TridPage*)this,&TridPage::Update));

  fEndOnOrthoView.AddToMenu(fOptionsMenu,"End-on Orthographic View");
  fEndOnOrthoView.Connect(slot_class(*this,&TridPageDetector::SnapToEndOnOrthoView));
  
  mit = fOptionsMenu->Add("Print Flyby Animation");
  (*mit)->Connect(slot_class(*this,&TridPageDetector::PrintAnimation));


  return NULL;
}


void TridPageDetector::CreateModels()
{
  // Set the suggested time range.
  double tmin = fContext.GetTimeStamp().GetNanoSec()*1e9;
  double tmax = tmin + 10*Munits::microsecond;

  if(fContext.GetDetector()==Detector::kFar) {
    tmin -= 50*Munits::microsecond;
    tmax += 50*Munits::microsecond;
  }
  fTridControl->GetAnimator().SetTimeRange(tmin,tmax);


  fModels.Clear();
  fTridControl->ClearPicked();
  fTridControl->ClearSelected();

  TridModelMaker maker;
  maker.Prepare(&(fMint->GetJobC().Mom));
  maker.CreateTrackModels(&(fMint->GetJobC().Mom),fModels);
  maker.CreateShowerModels(&(fMint->GetJobC().Mom),fModels);
  maker.CreateStripModels(&(fMint->GetJobC().Mom),fModels);
  maker.CreateIntersectionModels(&(fMint->GetJobC().Mom),fModels);
}



void TridPageDetector::CreateSketches()
{
  fModels.ClearAssociations();
  double meanz = 0;
  double meann = 1e-9;

  // Get an Ugli handle.
  UgliGeomHandle myUgli(fContext);

  TridModel*   basemodel;
  TridModelItr itr = fModels.GetIterator();
  while( (basemodel = itr.Next()) ) {    
    // Make a new sketch for this model.
    
    // Track models.
    if(TridModelTrack* trackmodel = dynamic_cast<TridModelTrack*>(basemodel)) {
      //cout << "Track:-------------" << endl;
      bool firstplane = true;
      TVector3 lastpos;
      for(int plane = 0; plane<500; plane++) {
        if(trackmodel->IsValid(plane)) {
          // find 3d position here.
          float z = myUgli.GetScintPlnHandle(PlexPlaneId(fContext.GetDetector(),plane)).GetZ0();
          TVector3 pos = 
              kv_u * trackmodel->GetU(plane)
            + kv_v * trackmodel->GetV(plane)
            + kv_z * z;
          
          if(!firstplane) {
            // Make new segment:
            TridSketch* sk = 
              //new TridSketchLine( lastpos,pos );
              new TridSketchTube(lastpos,pos,0.02,6,false);
            sk->SetTime(trackmodel->GetT(plane));
            
            sk->SetColor(1,0,0);
            fGLFrame->AddSketch(sk);
            fModels.AssociateModel(trackmodel,sk->GetId());

          } else {
            firstplane = false;
          }
          lastpos = pos;
        }
      }
    } 

    // Shower models.
    else if(    TridModelShower*  showermodel = dynamic_cast<TridModelShower*>(basemodel)) {
      //cout << "Shower:-------------" << endl;

      for(int plane = showermodel->GetFirstPlane(); plane<= showermodel->GetLastPlane(); plane++) {
        if((showermodel->IsValid(plane)) && (showermodel->IsValid(plane+1)) ) {
          // find 3d position here.
          PlexPlaneId planeId1(fContext.GetDetector(),plane);
          PlexPlaneId planeId2(fContext.GetDetector(),plane+1);
          double z = 0.5* ( myUgli.GetScintPlnHandle(planeId1).GetZ0()
                           +myUgli.GetScintPlnHandle(planeId2).GetZ0()
                           );

          double u,v;
          double u_size, v_size;
          if(planeId1.GetPlaneView()==PlaneView::kU) {
            u      = showermodel->GetU(plane);
            u_size = showermodel->GetWidth(plane);
            v      = showermodel->GetV(plane+1);
            v_size = showermodel->GetWidth(plane+1);        
          } else {      
            u      = showermodel->GetU(plane+1);
            u_size = showermodel->GetWidth(plane+1);
            v      = showermodel->GetV(plane);
            v_size = showermodel->GetWidth(plane);          
          }
          TVector3 pos = 
              kv_u * u
            + kv_v * v
            + kv_z * z;
          TVector3 axis1 = kv_u * u_size;
          TVector3 axis2 = kv_v * v_size;
                 
          //cout << "Showering: " << plane << " " << pos.X() << " " << pos.Y() << " " << pos.Z() 
          //    << " usize: " << u_size << "  vsize" << v_size << endl;
          
          // Make new segment:    
          TridSketch* sk = 
            new TridSketchEllipse(pos,axis1,axis2,16);

          sk->SetTime(showermodel->GetT(plane));
          sk->SetColor(0.1,0,1);
          sk->SetTransparency(0.5);
           
          fGLFrame->AddSketch(sk);
          fModels.AssociateModel(showermodel,sk->GetId());
        }
      }
    }
    
    // RecoStrip models.
    else if(TridModelRecoStrip* recostrip = dynamic_cast<TridModelRecoStrip*>(basemodel)) {
      TVector3 x0,x1;
      float halfwidth, halfthick;
      
      PlexStripEndId seid = recostrip->fStrip;

      x0 = recostrip->fPos;
      halfthick  = 0.01; // Hard-code 1cm.
      halfwidth  = 0.02; // Hard-code 2cm.
          
      if(fExaggerateThickness()) halfthick*=5.0;
      if(fExaggerateWidth())     halfwidth*=2.0;
      
      TridSketch* sk = 
        new TridSketchBox( recostrip->fPos,
                           recostrip->fLongitude, recostrip->fHalfLength,
                           recostrip->fTransverse, halfwidth,
                           kv_z, halfthick );
      sk->SetTime(recostrip->GetMeanTime());
   
      fGLFrame->AddSketch(sk);
      fModels.AssociateModel(recostrip,sk->GetId());
      MSG("TriD",Msg::kDebug) << "Created sketch - "
                              << " ModelAdd:"     << recostrip 
                              << " Model ID:"     << ((recostrip) ? (recostrip->GetId()) : 0)
                              << " ModelKey:"     << ((recostrip) ? (recostrip->GetSortKey()) : 0)
                              << " SketchNumber:" << sk->GetId()
                              << " SketchAddr: " << sk << endl;
    }

    // Strip models.
    else if(TridModelStrip* model = dynamic_cast<TridModelStrip*>(basemodel)) {
      TVector3 x0,x1;
      float halflength, halfwidth, halfthick;
      
      PlexStripEndId seid = model->fStrip;

      UgliStripHandle ustrip = myUgli.GetStripHandle(seid);
      x0 = ustrip.GlobalPos(0);
      halflength = ustrip.GetHalfLength();
      halfwidth  = ustrip.GetHalfWidth();
      halfthick  = ustrip.GetHalfThickness();
          
      PlaneView::PlaneView_t view = seid.GetPlaneView();
      
      TVector3 v1;
      TVector3 v2;
      TVector3 v3 = kv_z;      
      
      switch(view) {
      case PlaneView::kU:
        v1 = kv_v;
        v2 = kv_u;
        break;
      case PlaneView::kV:
        v1 = kv_u;
        v2 = kv_v;
        break;
      default:
        if(seid.IsVetoShield()) {
          v1 = kv_z;
          v2 = kv_y;
          v3 = kv_x;
        } else {
          MSG("TriD",Msg::kError) << "TridPageDetector::CreateSketches() -> Unknown plane view!" << endl;
        }
      }
      
      if(fContext.GetDetector()==Detector::kCalDet) {
        switch(view) {
        case PlaneView::kU:
          v1 = kv_y;
          v2 = kv_x;
          break;        
        case PlaneView::kV:
          v1 = kv_x;
          v2 = kv_y;
          break;
          
        default:
          MSG("TriD",Msg::kError) << "TridPageDetector::CreateSketches() -> Unknown plane view!" << endl;
        }
      } 
      
      if(fExaggerateThickness()) halfthick*=5.0;
      if(fExaggerateWidth())     halfwidth*=2.0;
    
      TridSketch* sk = 
        new TridSketchBox( x0,
                           v1, halflength,
                           v2, halfwidth,
                           v3, halfthick );
      
      sk->SetTime(model->GetMeanTime());
      meanz += x0.z();
      meann += 1;
   
      fGLFrame->AddSketch(sk);
      fModels.AssociateModel(model,sk->GetId());
      MSG("TriD",Msg::kDebug) << "Created sketch - "
                              << " ModelAdd:"     << model 
                              << " Model ID:"     << ((model) ? (model->GetId()) : 0)
                              << " ModelKey:"     << ((model) ? (model->GetSortKey()) : 0)
                              << " SketchNumber:" << sk->GetId()
                              << " SketchAddr: " << sk << endl;
    }
    
    // Intersection models.
    else if(TridModelIntersect* intersect = dynamic_cast<TridModelIntersect*>(basemodel) ){
      
      TVector3 x1,x2;
      TVector3 v1,v2;
      TVector3 p; // Point of intersection.

      float halflength, halfwidth, halfthick;
      UgliStripHandle ustrip1 = myUgli.GetStripHandle(intersect->fStrip2);
      UgliStripHandle ustrip2 = myUgli.GetStripHandle(intersect->fStrip1);
      x1 = ustrip1.GlobalPos(0);
      x2 = ustrip2.GlobalPos(0);
      halflength = ustrip1.GetHalfWidth();
      halfwidth  = ustrip2.GetHalfWidth();
      halfthick  = fabs(x2.z() - x1.z())*0.5 + ustrip1.GetHalfThickness();
     
      v1 = kv_v;
      v2 = kv_u;
      switch(intersect->fStrip1.GetPlaneView()) {
      case PlaneView::kU:
        v1 = kv_u; v2 = kv_v;
        break;
      case PlaneView::kV:
        v1 = kv_v; v2 = kv_u;
        break;
      default:
        MSG("TriD",Msg::kError) << "TridPageDetector::CreateSketches() -> Unknown plane view!" << endl;
        continue; // will throw another error about unfound sketch.
      }
        
      // Finds point of intersection in the uv plane
      // assuming v1 and v2 to be orthoganal:
      p = x1 + ((x2-x1)*v1)*v1;      
      
      // Add in the z-component. Do it 'right':
      //p+= v1.Cross(v2) * (x2-x1); 
      // Do it 'easy':
      p.SetZ(x1.z()*0.5 + x2.z()*0.5);
      
      if(fExaggerateThickness()) halfthick*=5.0; 
      if(fExaggerateWidth())     halfwidth*=2.0;
    
      TridSketch* ski = 
        new TridSketchBox( p,
                           v1, halflength,
                           v2, halfwidth,
                           kv_z, halfthick );
      
      ski->SetTime(intersect->GetMeanTime());
      meanz += p.z();
      meann += 1;
   
      fGLFrame->AddSketch(ski);
      fModels.AssociateModel(intersect,ski->GetId());
      MSG("TriD",Msg::kDebug) << "Created sketch - "
                              << " ModelAdd:"     << model 
                              << " Model ID:"     << ((model) ? (model->GetId()) : 0)
                              << " ModelKey:"     << ((model) ? (model->GetSortKey()) : 0)
                              << " SketchNumber:" << ski->GetId()
                              << " SketchAddr: " << ski << endl;
    } else {

      MSG("TriD",Msg::kError) << "Unrecognized model type! " << std::endl;
    }
   
  }

  ModifySketches(); // Set colors and transparencies.

  meanz /= meann;

  // Set up automatic and default viewing coordinates.
  double phi = fGLFrame->fPOV.fPhi;
  fAutoPOV.Set(0,0,meanz,25,25,phi);
  fFullPOV.Set(0,0,16,25,25,phi);

  if(fContext.GetDetector()==Detector::kCalDet) {
    fAutoPOV.Set(0,0,meanz,6,25,phi);
    fFullPOV.Set(0,0,1.7,6,25,phi);
  }
}


void TridPageDetector::CreateScenery()
{
  TridSketch::StartScenery();
  TridSketch::SetDefaultColor(fTridControl->GetForegroundColor());
  //cout << "Color: ";  fTridControl->GetForegroundColor().Print();

  TridSketchLine* l;
  
  // Add basic shape of fardet.
  if(fContext.GetDetector()==Detector::kCalDet) {
    // Arrow.
    l = new TridSketchLine(   0, 0, -1,  0, 0, -0.2);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(   0.3, 0, -0.5,  0, 0, -0.2);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(  -0.3, 0, -0.5,  0, 0, -0.2);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(     0, 0.3, -0.5,  0, 0, -0.2);  fGLFrame->AddSketch(l);


    l = new TridSketchLine(   -0.5, -0.5, 0,   -0.5,  0.5, 0);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(   -0.5,  0.5, 0,    0.5,  0.5, 0);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(    0.5,  0.5, 0,    0.5, -0.5, 0);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(    0.5, -0.5, 0,   -0.5, -0.5, 0);  fGLFrame->AddSketch(l);

    l = new TridSketchLine(   -0.5, -0.5, 3.6,   -0.5,  0.5, 3.6);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(   -0.5,  0.5, 3.6,    0.5,  0.5, 3.6);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(    0.5,  0.5, 3.6,    0.5, -0.5, 3.6);  fGLFrame->AddSketch(l);
    l = new TridSketchLine(    0.5, -0.5, 3.6,   -0.5, -0.5, 3.6);  fGLFrame->AddSketch(l);
  }

  if(fContext.GetDetector()==Detector::kFar) {
    // Draw an octagon at start and ends of supermodules.
    float modz[4] = {0, 14.696, 16.3445, 30.2441};
    
    // Draw text.
    TridSketchText* txt;
    txt = new TridSketchText( TVector3(0,-4.2,modz[0]), kv_y, -kv_z, "Plane 0");
    txt->SetThickness(0.001);
    txt->SetScale(0.3);
    txt->SetTransparency(0.5);
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(0,-4.2,modz[1]), kv_y, -kv_z, "Plane 248");
    txt->SetThickness(0.001);
    txt->SetScale(0.3);
    txt->SetTransparency(0.5); 
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(0,-4.2,modz[2]), kv_y, kv_z, "Plane 250");
    txt->SetThickness(0.001);
    txt->SetScale(0.3);
    txt->SetTransparency(0.5);
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(0,-4.2,modz[3]), kv_y, kv_z, "Plane 480");
    txt->SetThickness(0.001);
    txt->SetScale(0.3);
    txt->SetTransparency(0.5); 
    fGLFrame->AddSketch(txt);

    // horizontal lines
    for(int iz=0; iz<4; iz+=2) {
      l = new TridSketchLine(   -4,-1.66, modz[iz],    -4,-1.66, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine(   -4, 1.66, modz[iz],    -4, 1.66, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine(    4,-1.66, modz[iz],     4,-1.66, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine(    4, 1.66, modz[iz],     4, 1.66, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine(-1.66,    4, modz[iz],  -1.66,    4, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine(-1.66,   -4, modz[iz],  -1.66,   -4, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine( 1.66,    4, modz[iz],   1.66,    4, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine( 1.66,   -4, modz[iz],   1.66,   -4, modz[iz+1]);
      l->SetWidth(0.3);
      fGLFrame->AddSketch(l);
    }
    
    for(int iz = 0; iz<4; iz++) {
      // W
      l = new TridSketchLine(   -4,-1.66, modz[iz],    -4, 1.66, modz[iz]);
      fGLFrame->AddSketch(l);
      
       // E
      l = new TridSketchLine(    4, 1.66, modz[iz],     4,-1.66, modz[iz]);
      fGLFrame->AddSketch(l);  

      // NW and NW ear
      l = new TridSketchLine( -1.66,    4, modz[iz],     -4.707, 0.953, modz[iz]);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine( -4.,    0.953, modz[iz],     -4.707, 0.953, modz[iz]);
      fGLFrame->AddSketch(l);
 
      // NE and NE Ear
      l = new TridSketchLine( 1.66,    4, modz[iz],       4.707, 0.953, modz[iz]);
      fGLFrame->AddSketch(l);

      l = new TridSketchLine(  4.,    0.953, modz[iz],     4.707, 0.953, modz[iz]);
      fGLFrame->AddSketch(l);

      // N
      l = new TridSketchLine(-1.66,    4, modz[iz],  1.66,    4, modz[iz]);
      fGLFrame->AddSketch(l);

      // S
      l = new TridSketchLine( 1.66,   -4, modz[iz], -1.66,   -4, modz[iz]);
      fGLFrame->AddSketch(l);

      // SE
      l = new TridSketchLine(    4,-1.66, modz[iz],  1.66,   -4, modz[iz]);
      fGLFrame->AddSketch(l);

      // SW
      l = new TridSketchLine(-1.66,   -4, modz[iz],    -4,-1.66, modz[iz]);
      fGLFrame->AddSketch(l);
    }
  }
  
  if(fContext.GetDetector()==Detector::kNear) {

    // Draw the plane profile:
    TridSketch* l;
    float zeds[] = {0,         // Detector start
                    //0.06*20,   // End of veto region
                    //0.06*60,   // End of target region
                    0.06*120,  // End of hadron shower region
                    0.06*281}; // end of detector.

    const char* znames[] = { 
      "Plane 0",
      "Plane 120",
      "Plane 281"};

    for(int iz=0;iz<3;iz++) {
      double z = zeds[iz];
      // Loop over lhs, rhs of detector
      for(double side=-1.; side<3. ; side+=2. ) {
        l = new TridSketchLine(        0, 1.9,  z,  side*1.7, 1.9,  z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*1.7, 1.9,  z,  side*1.7, 1.53, z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*1.7, 1.53, z,  side*3.1, 0,    z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*3.1, 0,    z,  side*3.1, -0.2, z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*3.1, -0.2, z,  side*2.4, -0.2, z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*2.4, -0.2, z,  side*2.4,-1.02, z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*2.4,-1.02, z,  side*1.7,-1.53, z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*1.7,-1.53, z,  side*1.7,-1.9,  z );  fGLFrame->AddSketch(l);
        l = new TridSketchLine( side*1.7,-1.9,  z,  0       ,-1.9,  z );  fGLFrame->AddSketch(l);
        //cout << "Actual: ";  l->GetColor().Print();
      }
      TridSketchText* txt;
      txt = new TridSketchText( TVector3(0,-2.2,z), kv_y, -kv_z, znames[iz]);
      txt->SetThickness(0.001);
      txt->SetScale(0.3);
      txt->SetTransparency(0.5);
      fGLFrame->AddSketch(txt);
    }
  }
  TridSketch::StopScenery();
}

void TridPageDetector::ModifySketches()
{
  // Go through all models. Modify their sketches to match the current
  // transparency and color maps.

  fColorHistogram->Reset();
  fTransHistogram->Reset();

  int nsketches =0;

  TridSketchListItr itr = fGLFrame->GetIterator();
  while( TridSketch* sketch = itr.Next() ) {
    int sketchnum = sketch->GetId();
    TridModel* model = fModels.GetModelFromSketch(sketchnum);

    if((sketch)&&(model)) {
      nsketches++;
      // Get color and trans as number between 0 and 1,
      // interpolated in our current scale.
      Double_t color_x = fTridControl->GetRangedModelColor(model);
      Double_t trans_x = fTridControl->GetRangedModelTrans(model);

      // Modify the sketch.
      sketch->SetColor(fTridControl->GetColor(color_x));
      sketch->SetTransparency(trans_x);

      // Turn on/off the sketch.
      sketch->SetDrawn(true);
      if(color_x<0)
        if(!fTridControl->ShowColorUnderScale())
           sketch->SetDrawn(false);

      if(color_x>1)
        if(!fTridControl->ShowColorOverScale())
           sketch->SetDrawn(false);

      // Turn on/off based on menu toggles.

      bool isToggled = false;
      if( /*TridModelIntersect* intersectModel = */ dynamic_cast<TridModelIntersect*>(model) ) {
        if(fShowIntersections()) isToggled = true;
      }
      else if( TridModelStrip* stripModel = dynamic_cast<TridModelStrip*>(model) )  {
        if(fShowStrips()) isToggled = true;
        if((fShowLoneStrips()&&stripModel->fIntersections==0)) isToggled = true;
      }
      else if( /*TridModelTrack* trackmodel =*/ dynamic_cast<TridModelTrack*>(model)  ) {
        if(fShowTracks()) isToggled = true;
        sketch->SetColor(1,0.3,0.3);
        sketch->SetTransparency(1.0);
      }
      else if( /*TridModelShower* showermodel =*/ dynamic_cast<TridModelShower*>(model) )  {
        if(fShowShowerBlobs()) isToggled = true;
        sketch->SetColor(0.3,0.3,1);
        sketch->SetTransparency(0.5);
      }
      else if( TridModelRecoStrip* rstrip = dynamic_cast<TridModelRecoStrip*>(model) )  {
        switch(rstrip->fType) {
        case TridModelRecoStrip::kShower: 
            if(fShowShowerStrips()){ isToggled = true; }break;
        }
        sketch->SetTransparency(trans_x*0.5);
      }

      if(!isToggled) sketch->SetDrawn(false);
     
     // If picked, shine as white.
     if(fTridControl->IsPicked(model))
       sketch->SetColor(1,1,1);
     
     // Ditto selected.
     if(fTridControl->IsSelected(model))
       sketch->SetColor(1,1,1);
         
     if(isToggled) {
       // Fill our histograms.
       fColorHistogram->Fill(color_x);
       fTransHistogram->Fill(trans_x);
     }


    } else {
      if(!(sketch->IsScenery())) {
        MSG("TriD",Msg::kError) << "Cannot find sketch or model "
                                << " ModelAdd:"     << model 
                                << " Model ID:"     << ((model) ? (model->GetId()) : 0)
                                << " ModelKey:"     << ((model) ? (model->GetSortKey()) : 0)
                                << " SketchNumber:" << sketchnum
                                << " SketchAddr: " << sketch << endl;
        //if(model) model->Print();
      }
    }
  }
}



void TridPageDetector::PrintAnimation()
{
  char filename[100];
  const int nsnaps = 180;
  fGLFrame->fPOV.fPhi = 0;
  fGLFrame->Update();  
  for(int i=0;i<nsnaps; i++) {
    sprintf(filename,"anim%03d.gif",i);
    fGLFrame->fPOV.fPhi += 360.0 /(double)(nsnaps);
    fGLFrame->Print(filename);
    fGLFrame->Update();
  }
}


void TridPageDetector::ChangeSketches(void)
{
  // Update display.
  fGLFrame->DeleteSketches();
  CreateSketches();
  CreateScenery();
  fGLFrame->Update();

}


/*
void TridPageDetector::AnimationRedraw() 
{
  // Animate view and objects in the view.
  // View animation takes the form of rotation in phi.
  fGLFrame->SetAnimTime(fTridControl->CurrentAnimTimeMin(), 
                        fTridControl->CurrentAnimTimeMax());
  if(fTridControl->AnimatingViews()) {
    MSG("TriD",Msg::kDebug) << "Rotating from " << fGLFrame->fPOV.GetPhi() 
                            << "to " << fGLFrame->fPOV.GetPhi() + fTridControl->GetAnimViewIncrement()*360.
                            << endl;
    //if(fViewMode!=kView2D) {
      fGLFrame->fPOV.fPhi = (fGLFrame->fPOV.fPhi+ fTridControl->GetAnimViewIncrement()*360.);
      fGLFrame->fPOV.Push();    
      // }
  }
  fGLFrame->Update();
}
*/

void TridPageDetector::SnapToEndOnOrthoView()
{
  if(fEndOnOrthoView()) {
    SetupFrame(kView2D);
    TridPOV end_on(0,0,0,3,0,180);
    SetPOV(end_on);
  } else {
    SetupFrame(kView3D);
    FullZoom();
  }
}

---