EventDisplay/GfxStripList.cxx

Go to the documentation of this file.

#include "GfxStripList.h"
#include "GfxStripListCfg.h"
#include "GfxProxy.h"
#include "GfxStripListMenu.h"
#include "EVD.h"
#include "ViewState.h"
#include <TClonesArray.h>
#include <Record/RecArrayAllocator.h>
#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/Mint.h>
#include <Midad/Base/Rainbow.h>
#include <Midad/Base/DigitText.h>
#include <Midad/Util/Range.h>
#include <Midad/Gui/GuiSlider.h>
#include <JobControl/JobC.h>
#include <DataUtil/TruthHelper.h>
#include <Record/SimSnarlRecord.h>
#include <Record/SimSnarlHeader.h>
//#include <Midad/Util/Util.h>

#include <Conventions/Munits.h>

#include <DataUtil/CDL2STL.h>
using namespace DataUtil;

#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandStripListHandle.h>

#include <MessageService/MsgService.h>
CVSID("$Id: GfxStripList.cxx,v 1.10 2007/03/01 17:18:35 rhatcher Exp $");

#include <Buttons.h> // part of ROOT

#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>
using namespace SigC;

#include <iostream>
#include <string>
using namespace std;


GfxProxy<GfxStripList> 
gsGfxStripListProxy("StripList", new GfxStripListMenu());


GfxStripList::GfxStripList()
    : fCfg(0)
    , fColorRange(0)
    , fEVD(0)
    , fMint(0)
    , fHideStrips(false)
{
    fCfg = new GfxStripListCfg();
    fCfg->modified_signal.connect
        (slot_class(*this,&GfxStripList::ReConfigure));
        RecArrayAllocator& a = RecArrayAllocator::Instance();
      fStripsCA = a.GetArray("GfxStrip");
}

GfxStripList::~GfxStripList()
{
   RecArrayAllocator& a = RecArrayAllocator::Instance();
   if (fStripsCA) { a.ReleaseArray(fStripsCA); fStripsCA = 0; }
}

void GfxStripList::Init(PageDisplay& pd, EVD& mp)
{
    fColorRange = &mp.GetColorRangeControl(this->GetPlaneView()).GetRange();
    ViewState* vs = this->GetViewState();
    vs->color_semantic.connect(slot_class(*this,&GfxStripList::ReConfigure));
    vs->spatial_metric.connect(slot_class(*this,&GfxStripList::ReConfigure));
    fPageDisplay = &pd;
    fEVD = &mp;
}

static bool select_strip(const CandStripHandle* csh, 
                         PlaneView::PlaneView_t view,
                         RangeDouble* time_range)
{
  bool retval=false;
  if (!csh) return retval;
 
  if((csh->GetPlaneView() == view) && time_range->InRange(csh->GetTime()))retval=true;
  /* 
 if(cs){
    if(!cs->FindDaughter(csh))retval=false;
  }
  */
  return retval;
}

void GfxStripList::Configure(Mint& mint)
{
    fMint = &mint;
    this->ClearStripList();
    if (fHideStrips) return;
    const CandStripListHandle* cslh = mint.GetStrips();
    if (!cslh) { 
      MSG("EVD",Msg::kVerbose) << "No CandStripList\n";
        return;
    }

    RangeDouble& time_range = 
        fPageDisplay->GetTimeSlider().GetRangeCtrl().GetRange();
 
    Mint::StripVector_t sv = CDL2STLvector<CandStripHandle>(*cslh);

    Mint::StripVector_t::iterator it, first = sv.begin(), middle, last = sv.end();
    Slot1<bool,const CandStripHandle*> s =
        bind(slot(select_strip),this->GetPlaneView(), &time_range);
    middle = std::partition(first,last,s);   

    for (it = first; it != middle; ++it) {
    
      bool addstrip=true;
      if(addstrip){
        int last = fStripsCA->GetLast()+1;
        new ((*fStripsCA)[last]) GfxStrip(**it,*this);     
        GfxStrip* gs = dynamic_cast<GfxStrip*>(fStripsCA->UncheckedAt(last));
        fStrips.push_back( gs);
      }
    }
    this->ReConfigure();
}

void GfxStripList::ReConfigure(void)
{
    if (!fMint) return;

    if (fHideStrips) return;

    // configure all GfxStrips
    GfxStripVector_t::iterator it, done = fStrips.end();
    for (it = fStrips.begin(); it != done; ++it) (*it)->Configure();
}

void GfxStripList::Draw(Option_t *option)
{
    GfxStripVector_t::iterator it, done = fStrips.end();
    for (it = fStrips.begin(); it != done; ++it) {
      if(GetEVD()->GetDrawAll() || GetEVD()->GetDrawGhosts()  || (*it)->GetColor()!=GetEVD()->GetGhostColor() ){
        (*it)->Draw(option);
      }
    }
}


// Private methods:
void GfxStripList::ClearStripList()
{
    fStrips.clear();
    fStripsCA->Clear("C");
}

void GfxStripList::ExecuteEvent(int event, int /*px */, int /*py*/, GfxStrip* gfx_strip)
{
    switch (event) {
    case kMouseEnter: {
        const CandStripHandle& csh = gfx_strip->GetStrip();
        PlexStripEndId seid = csh.GetStripEndId();
        const char* s;
        SimSnarlRecord *ssr = 
          dynamic_cast<SimSnarlRecord*>(fMint->GetJobC().Mom.GetFragment("SimSnarlRecord"));
        if (ssr){
          TruthHelper truthHelp(&(fMint->GetJobC().Mom));
          s = Form("Strip:   (%s)  %d digit%s, plane=%d, demux charge=%.1f, t0=%.1f ns, <t>=%.1f ns,  Best NeuKin index match:%d", 
                               seid.AsString(),
                               csh.GetNDigit(), 
                               csh.GetNDigit() == 1 ? "" : "s",
                               csh.GetPlane(),
                               csh.GetCharge(), 
                               csh.GetBegTime()/Munits::ns, 
                               csh.GetTime()/Munits::ns,
                               truthHelp.GetBestNeuMatch(csh));

        }
        else{
          s = Form("Strip: %d digit%s, plane=%d, demux charge=%.1f, t0=%.1f ns, <t>=%.1f ns (%s)",
                               csh.GetNDigit(), csh.GetNDigit() == 1 ? "" : "s",
                               csh.GetPlane(),
                               csh.GetCharge(), csh.GetBegTime()/Munits::ns, 
                               csh.GetTime()/Munits::ns, seid.AsString());
        }
        text_info.emit(s);

        vector<const CandDigitHandle*> dv = CDL2STLvector<CandDigitHandle>(csh);
        int siz = dv.size();
        if (!siz) break;

        DigitText* dt = fPageDisplay->GetDigitText();
        if (dt) {
            dt->Clear();
            for (int ind=0; ind < siz; ++ind)
                dt->AddCandDigitText(*dv[ind]);
        }
         DigitText* JAMdt = fEVD->GetDigitText();
        if (JAMdt) {
            JAMdt->Clear();
            for (int ind=0; ind < siz; ++ind)
                JAMdt->AddCandDigitText(*dv[ind]);
        }
      if (fMint) {
            fMint->SetPickedStrip(csh);
            fMint->SetSelectedDigits(dv);
        }
        
        break;
    }
    default: // nothing
        break;
    }
}

bool GfxStripList::StripMasked(const CandStripHandle& csh) const
{
    if (!fColorRange) return false;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = csh.GetTime();
        break;
    case ViewState::color_is_charge:
        val = csh.GetCharge();
        break;
    default:
        return false;
        break;
    }

    bool ret = fColorRange->InRange(val);
    return !ret;
}

int GfxStripList::GetStripColor(const CandStripHandle& csh) const
{
    if (!fColorRange) return false;

    static Rainbow rainbow;

    if (this->StripMasked(csh)) return 0;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = csh.GetTime();
        break;
    case ViewState::color_is_charge:
        val = csh.GetCharge();
        break;
    default:
        return 0;
        break;
    }
    return rainbow.GetRelativeColor(fColorRange->Relative(val));
}
void GfxStripList::HideStrips(bool hide)
{
    fHideStrips = hide;
    this->ReConfigure();
    if(GetGraphicsView()==GraphicsView::kVZ)fEVD->UpdateCanvas();
}

---