TridPage.cxx

Go to the documentation of this file.

#include <cassert>
#include <sstream>

// Root stuff:
#include <TStyle.h>
#include <TColor.h>
#include <TROOT.h>
#include <TH1F.h>
#include <TEnv.h>
#include <TVirtualX.h>
#include <TGeoManager.h>

#include "TridPageDisplay.h"
#include "TridPage.h"
#include "TridGLFrame.h"
#include "TridFlatGLFrame.h"
#include "TridStereoGLFrame.h"
#include "TridAnaglyphGLFrame.h"
#include "TridSketches.h"
#include "TridControl.h"
#include "SelectionInfoPage.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 "DataUtil/GetVldContext.h"

CVSID("$Id: TridPage.cxx,v 1.48 2007/08/27 20:31:25 tagg Exp $");

using namespace SigC;

//ClassImp(TridPage)

TridPage::TridPage()
  : fWindowName("Unnamed"),
    fGLFrame(0),
    fGuiBox(0),
    fMainWindow(0),
    fFileMenu(0),
    fOptionsMenu(0),
    fTridControl(0),
    fAutoPOV(0,0,0,10,45,25),
    fFullPOV(0,0,0,10,45,25),
    fMint(0),
    fPageDisplay(0),
    fModels(),
    fColorHistogram(0),
    fTransHistogram(0),
    fViewMode(kViewNone),
    fCreateHistograms(true),
    fViewModesSupported( kView2D | kView3D | kViewStereo  | kViewCrossEyed | kViewRedBlue | kViewBlueRed )
{
  // Set default view mode here.
  fViewMode = kView3D;
}

TridPage::TridPage(TridPage& otherPage) 
  : PageABC( otherPage ),    
    TObject( otherPage ),
    fWindowName("Unnamed"),
    fGLFrame(0),
    fGuiBox(0),
    fMainWindow(0),
    fFileMenu(0),
    fOptionsMenu(0),
    fTridControl(0),
    fAutoPOV(0,0,0,10,45,25),
    fFullPOV(0,0,0,10,45,25),
    fMint(0),
    fPageDisplay(0),
    fModels(),
    fColorHistogram(0),
    fTransHistogram(0),
    fViewMode(kViewNone),
    fCreateHistograms(true),
    fViewModesSupported( kView2D | kView3D  | kViewStereo  | kViewCrossEyed )
{
  MSG("TriD",Msg::kFatal) << "Trid Copy Constructor used.. please don't." << endl;
}

TridPage::~TridPage()
{
  MSG("TriD",Msg::kDebug) << "Destructor called" << endl;

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

  //Unregister all the slot stuff.
  fTridControl->DisconnectTridPage(this);
}

TObject* TridPage::Init(Mint* mint, PageDisplay* pd, GuiBox& box)
{
  //MsgService::Instance()->GetStream("TriD")->SetLogLevel(Msg::kDebug);
  MSG("TriD",Msg::kDebug) << "TridPage: Init()" << endl;

  fMint = mint;
  fPageDisplay = pd;
 
  fMenuBar = manage(new GuiMenuBar(box));
  box.Add(*fMenuBar);

  fFileMenu = manage(new GuiMenu);
  fMenuBar->AddMenu(*fFileMenu,"File");

  fOptionsMenu = manage(new GuiMenu);
  fMenuBar->AddMenu(*fOptionsMenu,"Options");
  
  fGuiBox = manage(new GuiBox(box,kVerticalFrame,100,100));
  box.Add(*fGuiBox);
  box.Show(*fGuiBox);
  fMainWindow = dynamic_cast<TGWindow*>(&box);
  assert(fMainWindow);


  // Get the master Control object. Register with it.
  fTridControl = TridControl::Instance(pd);
  assert(fTridControl);
  fTridControl->ConnectTridPage(this);

  // Create and register histograms.
  if(fCreateHistograms) {
    char buff[100];
    sprintf(buff,"%s_Color",fWindowName.Data());
    fColorHistogram = new TH1F(buff,buff,50,0,1);
    sprintf(buff,"%s_Trans",fWindowName.Data());
    fTransHistogram = new TH1F(buff,buff,50,0,1);
    fTridControl->AddHistograms(fWindowName.Data(),fColorHistogram,fTransHistogram);
  }

  // Add stuff to File menu.

  GuiMenu::GuiMenuList::iterator mit;
  mit = fFileMenu->Add("Print");
  (*mit)->Connect(slot_class(*this,&TridPage::Print));
  

  // Views submenu in the Options menu
  MSG("TriD",Msg::kDebug)<< "Supported modes: " << fViewModesSupported << endl;
  if(fViewModesSupported >0) {
    GuiMenu* viewmenu = manage(new GuiMenu);
    fOptionsMenu->Add("View",*viewmenu);
    
    if(fViewModesSupported & kView2D) {
      mit = viewmenu->Add("2D View (Orthographic)");
      (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridPage::ViewMenuHandler),
                                     kView2D) ,mit) ,viewmenu));
      if(fViewMode == kView2D) viewmenu->CheckEntry(mit);
    }

    if(fViewModesSupported & kView3D) {
      mit = viewmenu->Add("3D View");
      (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridPage::ViewMenuHandler),
                                     kView3D) ,mit) ,viewmenu));
      if(fViewMode == kView3D) viewmenu->CheckEntry(mit);
    }

    if(fViewModesSupported & kViewStereo) {
      mit = viewmenu->Add("Stereoscopic");
      (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridPage::ViewMenuHandler),
                                     kViewStereo) ,mit) ,viewmenu));
      if(fViewMode == kViewStereo) viewmenu->CheckEntry(mit);
    }
    
    if(fViewModesSupported & kViewCrossEyed) {
      mit = viewmenu->Add("Cross-Eyed");
      (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridPage::ViewMenuHandler),
                                     kViewCrossEyed) ,mit) ,viewmenu));
      if(fViewMode == kViewCrossEyed) viewmenu->CheckEntry(mit);
    }
  
    if(fViewModesSupported & kViewRedBlue) {
      mit = viewmenu->Add("Red-Blue Glasses");
      (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridPage::ViewMenuHandler),
                                     kViewRedBlue) ,mit) ,viewmenu));
      if(fViewMode == kViewRedBlue) viewmenu->CheckEntry(mit);
    }

    if(fViewModesSupported & kViewBlueRed) {
      mit = viewmenu->Add("Blue-Red Glasses");
      (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridPage::ViewMenuHandler),
                                     kViewBlueRed) ,mit) ,viewmenu));
      if(fViewMode == kViewBlueRed) viewmenu->CheckEntry(mit);
    }
  }

  SetupFrame( fViewMode );  
  return this;
}

void TridPage::ViewMenuHandler(GuiMenu* menu, GuiMenu::GuiMenuList::iterator mit,
                               TridPage::ViewMode_t mode)
{
  GuiMenu::GuiMenuList& mlist = menu->GetMenuList();
  GuiMenu::GuiMenuList::iterator it, done = mlist.end();
  for (it = mlist.begin(); it != done; ++it)
    menu->CheckEntry(it,false);
  menu->CheckEntry(mit,true);
  if(fViewMode!=mode)
    SetupFrame(mode);
}


void TridPage::SetupFrame( TridPage::ViewMode_t mode )
{
  // Make a copy of the sketch list to save.
  TridSketchList oldList;
  TridPOV oldPOV;

  if(fGLFrame) {
    oldList.AddSketchList(*fGLFrame);
    TridSketchListItr itr = oldList.GetIterator();
    TridSketch* sketch;
    while( (sketch = itr.Next()) ){
      sketch->SetDirty();
    }

    oldPOV.Copy(fGLFrame->fPOV);
    fGLFrame->ClearSketches();
    fGuiBox->Remove(*fGLFrame);  
    fGLFrame = 0;              // This should delete it.
 
    // Ensure the list is now drawn correctly.
  }

  fViewMode = mode;  
  fGLFrame = SigC::manage(CreateNewGLFrame(fViewMode));    
  fGuiBox->Add(*fGLFrame); 
  fGuiBox->Show(*fGLFrame); 
  fPageDisplay->UpdateGui();

  fGLFrame->AddSketchList(oldList);
  fGLFrame->fPOV.Copy(oldPOV);

  
  fGLFrame->SetupProjection();
  fGLFrame->SetPOV(fFullPOV);
  fGLFrame->Update();      
  
}

TridGLFrame* TridPage::CreateNewGLFrame( TridPage::ViewMode_t mode )
{
  if(mode==kView2D) {
    MSG("TriD",Msg::kDebug) << "Changing to 2D" << endl;
    return new TridFlatGLFrame(this,*fGuiBox,fTridControl);
  } 
  if ( mode == kViewStereo) {
    MSG("TriD",Msg::kDebug)  << "Changing to Stereoscopic" << endl;
    return new TridStereoGLFrame(this,*fGuiBox,fTridControl,-1);   
  }
  if ( mode == kViewCrossEyed) {
    MSG("TriD",Msg::kDebug) << "Changing to Crosseyed" << endl;
    return new TridStereoGLFrame(this,*fGuiBox,fTridControl,1);   
  }
  if ( mode == kViewRedBlue) {
    MSG("TriD",Msg::kDebug) << "Changing to Red/Blue glasses mode" << endl;
    return new TridAnaglyphGLFrame(this,*fGuiBox,fTridControl,-1);   
  }
  if ( mode == kViewBlueRed) {
    MSG("TriD",Msg::kDebug) << "Changing to Blue/Red glasses mode" << endl;
    return new TridAnaglyphGLFrame(this,*fGuiBox,fTridControl,1);   
  }

  
  MSG("TriD",Msg::kDebug)  << "Changing to 3D" << endl;
  return new TridGLFrame(this,*fGuiBox,fTridControl);
}


// color mapping
TVector3 TridPage::GetColor( Float_t x ) 
{
  // Map a fractional number x to a place in the current pallete.
  int n = gStyle->GetNumberOfColors();
  int index = (int)(x*(float)n);
  if(index>=n) index = n-1;
  if(index<0) index = 0;
  int colNum = gStyle->GetColorPalette(index);
  TColor* colref = gROOT->GetColor(colNum);
  TVector3 rgb(colref->GetRed(),colref->GetGreen(),colref->GetBlue());
  return rgb;
}


void TridPage::Update()
{
  MSG("TriD",Msg::kDebug) << "TridPage::Update()" << endl;
  assert(fMint);
  
   // Get detector type.
  std::vector<VldContext> contexts =  DataUtil::GetVldContext(&(fMint->GetJobC().Mom));
  if(contexts.size() ==0 ) {
    MSG("TriD",Msg::kError) << "No VldContext of any kind in Mom. Have you loaded a valid data file?" << std:: endl;
    return;
  }
  fContext = contexts[0];

  fTridControl->ClearPicked(); // Make sure it's all clear before rebuilding.
  fTridControl->ClearSelected();

  // Set the suggested time range.
  double tmin = -2*Munits::microsecond; //fContext.GetTimeStamp().GetNanoSec()*Munits::ns;
  double tmax = tmin + 15*Munits::microsecond;

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

  fModels.Clear();
  CreateModels();

  fGLFrame->DeleteSketches();
  CreateSketches();
  CreateScenery();
  
  fGLFrame->Update();
}

void TridPage::Clear() 
{
  MSG("TriD",Msg::kDebug) << "TridPage::Clear()" << endl;
  fModels.Clear();
  if(fGLFrame) fGLFrame->DeleteSketches();
}

void TridPage::CreateModels()
{
}

void TridPage::CreateSketches()
{
}


void TridPage::CreateScenery()
{
}

void TridPage::ModifySketches()
{
  // Go through all models. Modify they 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);

      // 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);

      // Fill our histograms.
      fColorHistogram->Fill(color_x);
      fTransHistogram->Fill(trans_x);
    } else {
      MSG("TriD",Msg::kError) << "Cannot find sketch or model, model number " << model
                              << "  ModelAdd: "     << model 
                              << "  SketchNumber: " << sketchnum
                              << "  SketchAddr:   " << sketch << endl;
    }
  }
}

void TridPage::MouseOver(int sketchname)
{
  static int lastmouseover;
  if(sketchname!=lastmouseover) {
    //DigitText* dt = fPageDisplay->GetDigitText();
    SelectionInfoPage* selInfo = fTridControl->GetSelectionInfoPage();
    TridModel* model = fModels.GetModelFromSketch(sketchname);
    
    fTridControl->ClearPicked();
    if(model) {
      //if(dt) model->PrintToDigitText(dt);
      fTridControl->SetPicked(model);
      stringstream oss;
      model->Print(oss);
      std::string s = oss.str();
      if(selInfo) selInfo->SetText(s);
    }
    fTridControl->ChangePicked();
  }
  lastmouseover = sketchname;
}

void TridPage::MouseClick(int sketchname)
{
  TridModel* model = fModels.GetModelFromSketch(sketchname);
  if(model) {
    fTridControl->ToggleSelected(model);
    fTridControl->ChangeSelected();
  }
}

void TridPage::Print()
{
  this->PrintToFile(Form("snapshot_%s.png",fWindowName.Data()));
}

void TridPage::PrintToFile(const char* filename, const char* text)
{
  fGLFrame->Print(filename, text);
}

void TridPage::Unzoom()
{
  fGLFrame->fPOV.Undo();
  fGLFrame->Update();
}

void TridPage::Rezoom()
{
  fGLFrame->fPOV.Redo();
  fGLFrame->Update();
}

void TridPage::FullZoom()
{
  SetPOV(fFullPOV);
}

void TridPage::AutoZoom()
{
  SetPOV(fAutoPOV);
}


void TridPage::SetPOV(TridPOV& pov)
{
  fGLFrame->SetPOV(pov);
  fGLFrame->Update();
}

double TridPage::PlaceInBox( double boxwidth, double width, int i, int n )
{
  // Utility function for placing things.
  // Find the left most edge of a box of width
  // placed in a larger box of boxwidth
  // if there are n such boxes to go in evenly
  // and this is the ith such box.

  double d = (boxwidth - (double)(n)*width)/(double)(n+1);
  return d+ (double)(i)*(d+width);
}

// Hooks for changing view parameters.
void TridPage::ChangeColor()
{
  ModifySketches();
  fGLFrame->Update();
}

void TridPage::ChangeTrans()
{
  ModifySketches();
  fGLFrame->Update();
}

void TridPage::ChangePicked()
{
  ModifySketches();
  fGLFrame->Update();
}

void TridPage::ChangeSelected()
{
  ModifySketches();
  fGLFrame->Update();
}

void TridPage::ChangeHistograms()
{
}

void TridPage::AnimationRedraw() 
{
  MSG("TriD",Msg::kDebug) << "TridPage::AnimationRedraw()" << endl;

  TridAnimator& ani = fTridControl->GetAnimator();

  // Animate view and objects in the view.
  // View animation takes the form of rotation in phi.
  fGLFrame->SetAnimTime(ani.GetAnimTimeMin(), 
                        ani.GetAnimTimeMax());

  if(ani.AnimatingViews()) {
    MSG("TriD",Msg::kDebug) << "Rotating from " << fGLFrame->fPOV.GetPhi() 
                            << "to " << fGLFrame->fPOV.GetPhi() + ani.GetViewIncrement()*360.
                            << endl;
    if(fViewMode != kView2D) {
      fGLFrame->fPOV.fPhi = (180. + ani.GetFrame()*ani.GetViewIncrement()*360.);
      fGLFrame->fPOV.Push();    
    }
  }

  if(ani.AnimatingModels()) {
    fGLFrame->SetHUDText(Form("Time: %.1f ns to %.1f ns",
                            1e9*(ani.GetAnimTimeMin()-ani.GetRangeMin()),
                            1e9*(ani.GetAnimTimeMax()-ani.GetRangeMin())));
  }
  
  fGLFrame->Update();

  if(ani.Printing()) {
    PrintToFile(Form("anim_%s_%04d.png",fWindowName.Data(),ani.GetFrame()),
                Form("Time: %.1f ns to %.1f ns",
                     1e9*(ani.GetAnimTimeMin()-ani.GetRangeMin()),
                     1e9*(ani.GetAnimTimeMax()-ani.GetRangeMin()))
                );
  }
}

void TridPage::SaveWindowGeometry(TEnv& env)
{
  // Save the window geometry info into the given TEnv.

  TString newname(fWindowName);
  newname.ReplaceAll(" ","_");

  // First, just save the fact that the window exists.
  // That is, prepend it to the DefaultWindows variable.
  env.SetValue("Trid.DefaultWindows",
               Form("%s %s",newname.Data(),env.GetValue("Trid.DefaultWindows",""))
               ,kEnvChange); // Set up null string.
 
  
  Int_t x,y;
  UInt_t w,h;
  if(fGuiBox!=0) {
    Window_t wind = (Window_t)(gVirtualX->GetParent(fGuiBox->GetId()));
    Window_t root = (Window_t)gClient->GetRoot()->GetId();
    Window_t frame = wind;
    Window_t parent = wind;
    while( (parent != root) && (parent) ) {
      frame = parent;
      parent = gVirtualX->GetParent(parent);
     }
    WindowAttributes_t attr;
    gVirtualX->GetWindowAttributes(frame,attr);
    x = attr.fX;
    y = attr.fY;
    w = attr.fWidth;
    h = attr.fHeight;
    //cout << "XWinAttributes (frame)" << attr.fX << " " << attr.fY << endl;
    
    env.SetValue(
                 Form("Trid.WindowGeom.%s",newname.Data()),
                 Form("%dx%d+%d+%d",w,h,x,y),
                 kEnvChange);
    MSG("TriD",Msg::kDebug)
      << "Setting env variable: " 
      << Form("Trid.WindowGeom.%s",newname.Data())
      << "\t=\t" 
      << Form("%dx%d+%d+%d",w,h,x,y) 
      << endl;
  }
}

void TridPage::RestoreWindowGeometry(TEnv& env)
{
  if(fGuiBox!=0) {
    Window_t wind = (Window_t)(gVirtualX->GetParent(fGuiBox->GetId()));
    Window_t root = (Window_t)gClient->GetRoot()->GetId();
    Window_t frame = wind;
    Window_t parent = wind;
    while( (parent != root) && (parent) ) {
      frame = parent;
      parent = gVirtualX->GetParent(parent);
    }

    Int_t x,y;
    UInt_t w,h;
    WindowAttributes_t attr;
    gVirtualX->GetWindowAttributes(frame,attr);
    x = attr.fX;
    y = attr.fY;
    w = attr.fWidth;
    h = attr.fHeight;
    
    TString newname(fWindowName);
    newname.ReplaceAll(" ","_");
    const char* value = env.GetValue(Form("Trid.WindowGeom.%s",newname.Data()),
                                       "");
    
    MSG("TriD",Msg::kDebug) << "Restoring geometry " << Form("Trid.WindowGeom.%s",newname.Data())
                            << endl;

    if(strlen(value)>0) {
      sscanf(value,"%ux%u+%d+%d",&w,&h,&x,&y);      
      MSG("TriD",Msg::kDebug) << "----> Got Value " << value << endl;
      
      gVirtualX->MoveResizeWindow(frame,x,y,w,h);
    }
  }
}

---