EventDisplay/GfxDigit.cxx

Go to the documentation of this file.

#include "GfxDigit.h"
#include "GfxDigitList.h"
#include "GfxDigitListCfg.h"
#include "ViewState.h"
#include <Midad/Base/Mint.h>
#include <Midad/Util/Util.h>

#include <UgliGeometry/UgliGeomHandle.h>
#include <UgliGeometry/UgliStripHandle.h>


#include <CandDigit/CandDigitHandle.h>
#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandSliceHandle.h>

#include <Plex/PlexSEIdAltL.h>
#include <Plex/PlexVetoShieldHack.h>
#include <Midad/Base/ZoomPad.h>
#include <Midad/Util/Range.h>

#include <MessageService/MsgService.h>
CVSID("$Id: GfxDigit.cxx,v 1.14 2005/11/10 17:01:05 musser Exp $");

#include <TEllipse.h>
#include <TBox.h>
#include <TPolyLine.h>
#include <TPad.h>

#include <iostream>
using namespace std;

ClassImp(GfxDigit)

#if 0
GfxDigit::GfxDigit()
    : fDigit(0)
      ,fParent(0)
      ,fImp(0)
{
}
#endif
GfxDigit::GfxDigit(const CandDigitHandle& csh, GfxDigitList& parent)
    : fDigit(&csh)
      ,fItem(0)
      ,fParent(&parent)
      ,fImp(0)
{
}
GfxDigit::GfxDigit(const CandDigitHandle& csh, 
                   const PlexSEIdAltLItem& itm, GfxDigitList& parent)
    : fDigit(&csh)
      ,fItem(&itm)
      ,fParent(&parent)
      ,fImp(0)
{
//   if (fItem) {
//     PlexStripEndId seid = fItem->GetSEId(); 
//     MSG("Midad",Msg::kInfo) << "fItem on " << seid.AsString() << endl;
//  }
}
GfxDigit::GfxDigit(const GfxDigit& rhs)
  : TObject()
    ,fDigit(rhs.fDigit), fItem(rhs.fItem), fParent(rhs.fParent), fImp(0)
{
}
GfxDigit& GfxDigit::operator=(const GfxDigit& rhs)
{
    if (this == &rhs) return *this;
    fDigit = rhs.fDigit;
    fItem = rhs.fItem;
    fParent = rhs.fParent;
    fImp = 0;
    return *this;
}

GfxDigit::~GfxDigit()
{
  this->Clear();
}

void GfxDigit::Clear(const Option_t*)
{
  if (fImp) delete fImp; fImp=0;
}

bool GfxDigit::GetRealCoords(double& cx, double& cy, double& dx, double& dy)
{
    UgliGeomHandle ugh(*fDigit->GetVldContext());
    UgliStripHandle ush;
    if (!fItem) {
      ush = ugh.GetStripHandle(fDigit->GetPlexSEIdAltL().GetBestItem().GetSEId());
    }
    else {
      ush = ugh.GetStripHandle(fItem->GetSEId());
    }
    
    if(!fDigit->GetPlexSEIdAltL().IsVetoShield()){      
      
      if (!ush.IsValid()) return false;
      cx = ush.GlobalPos(0).Z();
      cy = ush.GetTPos();
      dx = 1.5*ush.GetHalfThickness();
      dy = 1.5*ush.GetHalfWidth();
      return true;
    }
    else{
      if (!ush.IsValid())return false;
      TVector3 stripxyz0(ush.GlobalPos(-ush.GetHalfLength()));
      TVector3 stripxyz1(ush.GlobalPos(ush.GetHalfLength()));
     
      cx = 0.5*(stripxyz0[0]+stripxyz1[0]);
      cy = 0.5*(stripxyz0[1]+stripxyz1[1]);     
      dy = 1.5*ush.GetHalfThickness();
      dx = 1.5*ush.GetHalfWidth();
      return true;
    }
}


bool GfxDigit::GetDiscreteCoords(double& cx, double& cy, double& dx, double& dy)
{
    PlexStripEndId seid;

    if (!fItem) {
        seid = fDigit->GetPlexSEIdAltL().GetBestItem().GetSEId();
    }
    else {
        seid = fItem->GetSEId();
    }
    cx = seid.GetPlane();
    cy = seid.GetStrip();
    dx = 0.15;
    dy = 0.75;
    if (fItem) 
        MSG("Midad",Msg::kVerbose) << seid.AsString() 
                                   << " cx = " << cx  
                                   << " cy = " << cy << endl;
    return true;
}

float GfxDigit::GetRelativeValue(GfxDigitListCfg::MeasureScale_t ms)
{

  const PlexSEIdAltL& altl = fDigit->GetPlexSEIdAltL();
  if (ms == GfxDigitListCfg::kCharge) {
    RangeDouble& qrange = fParent->GetMint().GetChargeRange();
    double den = qrange.Min() - qrange.Max();
    if (den > 0)
      return (altl.GetBestItem().GetPE() - qrange.Min()) / den;
  }
  else {                      // time
    RangeDouble& trange = fParent->GetMint().GetTimeRange();
    double den = trange.Max() - trange.Min();
    if (den > 0)
      
      return (altl.GetBestItem().GetTime() - trange.Min()) / den;
  }
  return 1.0;
}

void GfxDigit::ModifyCoords(double& cx, double& cy, double& dx, double& dy)
{
    int strip_sign = 0;
    if( fDigit->GetPlexSEIdAltL().IsVetoShield()) return;
    StripEnd::StripEnd_t end; 
    if (!fItem) {
        end = fDigit->GetPlexSEIdAltL().GetBestItem().GetSEId().GetEnd();
    }
    else {
        end = fItem->GetSEId().GetEnd();
    }
    if (end == StripEnd::kNegative) strip_sign = -1;
    if (end == StripEnd::kPositive) strip_sign = +1;

    GfxDigitListCfg& cfg = fParent->GetCfg();
    
    // Scale down size of strip
    GfxDigitListCfg::SizeBy_t sb = cfg.GetSizeBy();
    double size_scale = this->GetRelativeValue(cfg.GetSizeIs());

    size_scale *= cfg.GetSizeFactor();

    switch (sb) {
    case GfxDigitListCfg::kFixed:
        // nothing
        break;
    case GfxDigitListCfg::kLinear:
        dx *= size_scale;
        dy *= size_scale;
        break;
    case GfxDigitListCfg::kLogLinear:
        dx *= logify_relative(size_scale);
        dy *= logify_relative(size_scale);
        break;
    case GfxDigitListCfg::kLogArea:
        dx *= logify_relative(sqrt(size_scale));
        dy *= logify_relative(sqrt(size_scale));
        break;
    case GfxDigitListCfg::kArea: default:
        dx *= sqrt(size_scale);
        dy *= sqrt(size_scale);
        break;
    }

    // modify for any odd shape
    GfxDigitListCfg::DigitEnd_t si = cfg.GetStripEnd();
    switch (si) {
    case GfxDigitListCfg::kHalf:
        dy *= strip_sign * 0.5;
        cy += dy;
        break;
    case GfxDigitListCfg::kBowTie:
        dx *= strip_sign * 0.5;
        dy *= strip_sign * 0.5;
        cx += dx;
        cy += dy;
        break;
    case GfxDigitListCfg::kFull: 
        // fall through
    case GfxDigitListCfg::kBit:
        // fall through
    default:
        // do nothing
        break;
    }    
}

bool GfxDigit::SetColor(){

  fColor = fParent->GetDigitColor(*fDigit); 
  if(fItem)  {fColor = fParent->GetDigitColor(*fDigit, *fItem);}
  Bool_t found=true;
  CandSliceHandle * slice = fParent->GetEVD()->GetCandSlice();
  if(slice){
    found=false;
    TIter stripItr(slice->GetDaughterIterator());
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())){
      TIter digitItr(strip->GetDaughterIterator());
      while (CandDigitHandle *dig=dynamic_cast<CandDigitHandle*>(digitItr())) {
        if(dig->GetChannelId()==fDigit->GetChannelId() && dig->GetRawDigitIndex()==fDigit->GetRawDigitIndex()){    
          found=true;
          break;
        }
      }
    }
  }
  CandEventHandle * ev = fParent->GetEVD()->GetCandEvent();
  if(ev){
    found=false;
    TIter stripItr(ev->GetDaughterIterator());
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())){
      TIter digitItr(strip->GetDaughterIterator());
      while (CandDigitHandle *dig=dynamic_cast<CandDigitHandle*>(digitItr())) {
        if(dig->GetChannelId()==fDigit->GetChannelId() && dig->GetRawDigitIndex()==fDigit->GetRawDigitIndex()){    
          found=true;
          break;
        }
      }
    }
  }
  if(fDigit->GetCharge(CalDigitType::kPE)<5)fColor=10;
  if(fDigit->GetCharge(CalDigitType::kPE)<2)fColor=20;
  if(!found && !fDigit->GetPlexSEIdAltL().IsVetoShield() )fColor=fParent->GetEVD()->GetGhostColor();
  if (!fColor){
    return false;
  }
  
  TAttFill* att_fill = dynamic_cast<TAttFill*>(fImp);
  if (!att_fill) return false;
  att_fill->SetFillColor(fColor);
  if (!fItem) {
    att_fill->SetFillStyle(1001);
  }
  else {
    att_fill->SetFillStyle(0);
    const PlexSEIdAltLItem& best = fDigit->GetPlexSEIdAltL().GetBestItem();
    if ( fItem == &best ) att_fill->SetFillStyle(1001); 
  }
  if(fDigit->GetPlexSEIdAltL().IsVetoShield()) att_fill->SetFillStyle(1001);
  TAttLine* att_line = dynamic_cast<TAttLine*>(fImp);
  if (!att_line) return false;
  att_line->SetLineColor(fColor);
  att_line->SetLineWidth(1);
  
  return true;
}

void GfxDigit::Configure()
{
    // here we make our imp.
    if (fImp) { delete fImp; fImp = 0; }

    GfxDigitListCfg& cfg = fParent->GetCfg();

    fCx = fCy = fDx = fDy = 0.0;
    if((fParent->GetGraphicsView() == GraphicsView::kXY || 
       fParent->GetGraphicsView() == GraphicsView::kUV) &&  (!fDigit->GetPlexSEIdAltL().IsVetoShield()))return;
    
    switch (fParent->GetViewState()->GetSpatialMetric()) {
    case ViewState::metric_is_continuous:
        this->GetRealCoords(fCx,fCy,fDx,fDy);
        break;
    case ViewState::metric_is_discreet: default:
        this->GetDiscreteCoords(fCx,fCy,fDx,fDy);
        break;
    }


    double dx = fDx, dy = fDy;
    if (cfg.GetScaleIs() == GfxDigitListCfg::kAbsolute) {
        fDx = 1.0;
        fDy = 4.0;
        this->ModifyCoords(fCx,fCy,fDx,fDy);
        this->RelToAbs(dx,dy);
    }
    else {
        this->ModifyCoords(fCx,fCy,fDx,fDy);
    }

    switch (cfg.GetShapeIs()) {
    case GfxDigitListCfg::kEllipse: 
        fImp = new TEllipse(fCx,fCy,dx,dy);
        break;
    default:
      if(!fDigit->GetPlexSEIdAltL().IsVetoShield()){
        fImp = new TBox(fCx+dx,fCy+dy,fCx-dx,fCy-dy);
      }
      else {
        Double_t dylist[5] = {-dy,-dy,dy,dy,-dy};
        Double_t dxlist[5] = {-dx,dx,dx,-dx,-dx};
        Double_t rot=0.9;
        if(fDigit->GetPlexSEIdAltL().GetPlaneView()==PlaneView::kVSWallOnEdge){
          for (int id=0;id<6;id++){
            double tmp=dylist[id];
            dylist[id]=dxlist[id];
            dxlist[id]=tmp;
          }
        }
        if(fDigit->GetPlexSEIdAltL().GetPlaneView()==PlaneView::kVSTopEastSlant){
          double newdx;
          double newdy;
          for (int id=0;id<6;id++){
            newdx=dxlist[id]*cos(-rot)+dylist[id]*sin(-rot);
            newdy=-dxlist[id]*sin(-rot)+dylist[id]*cos(-rot);
            dxlist[id]=newdx;
            dylist[id]=newdy;
          }
        }
        if(fDigit->GetPlexSEIdAltL().GetPlaneView()==PlaneView::kVSTopWestSlant){
          double newdx;
          double newdy;
          for (int id=0;id<6;id++){
            newdx=dxlist[id]*cos(rot)+dylist[id]*sin(rot);
            newdy=-dxlist[id]*sin(rot)+dylist[id]*cos(rot);
            dxlist[id]=newdx;
            dylist[id]=newdy;
          }       
        }
        Double_t xbox[5]={fCx+dxlist[0],fCx+dxlist[1],fCx+dxlist[2],fCx+dxlist[3],fCx+dxlist[0]};
        Double_t ybox[5]={fCy+dylist[0],fCy+dylist[1],fCy+dylist[2],fCy+dylist[3],fCy+dylist[0]};
        fImp = new TPolyLine(5,xbox,ybox);
      }
      break;
    }
}


void GfxDigit::ExecuteEvent(int event, int px, int py)
{
    fParent->ExecuteEvent(event,px,py,this);
}
void GfxDigit::Paint(Option_t* option)
{
    if (!fImp) return;
    if (fParent->DigitsHidden()) return;
    if (!this->SetColor()) return;

    GfxDigitListCfg& cfg = fParent->GetCfg();
    if (cfg.GetScaleIs() == GfxDigitListCfg::kAbsolute) {
        double dx, dy;
        this->RelToAbs(dx,dy);
        switch (cfg.GetShapeIs()) {
        case GfxDigitListCfg::kEllipse: {
            TEllipse* el= dynamic_cast<TEllipse*>(fImp);
            el->SetR1(dx);
            el->SetR2(dy);
            el->Paint(option);
           break;
        }
        default:
            TBox* box = dynamic_cast<TBox*>(fImp);
            box->SetX1(fCx+dx);
            box->SetY1(fCy+dy);
            box->SetX2(fCx-dx);
            box->SetY2(fCy-dy);
            box->Paint();
            break;
        }
    }
    else {
        fImp->Paint(option);
    }
}

int GfxDigit::DistancetoPrimitive(int px, int py)
{
    if (fImp) return fImp->DistancetoPrimitive(px,py);
    return 0xdead;
}

void GfxDigit::RelToAbs(double& dx, double& dy)
{
    dx = gPad->AbsPixeltoX((int)fDx) - gPad->AbsPixeltoX(0);
    dy = gPad->AbsPixeltoY((int)fDy) - gPad->AbsPixeltoY(0);
//    cerr << Form("dx=%f(%f)  dy=%f(%f)",fDx,dx,fDy,dy) << endl;
}

void GfxDigit::ConfigGui(void)
{
    if (!fParent) return;
    GfxDigitListCfg& cfg = fParent->GetCfg();
    cfg.GuiConfig();
}

---