EventDisplay/GfxStrip.cxx

Go to the documentation of this file.

#include "GfxStrip.h"
#include "GfxStripList.h"
#include "GfxStripListCfg.h"
#include "ViewState.h"
#include <Midad/Base/Mint.h>
#include <Midad/Util/Util.h>
#include "EVD.h"
#include <UgliGeometry/UgliGeomHandle.h>
#include <UgliGeometry/UgliStripHandle.h>

#include <RecoBase/CandStripHandle.h>

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

#include <iostream>
using namespace std;

ClassImp(GfxStrip)

#if 0
GfxStrip::GfxStrip()
    : fStrip(0)
      ,fParent(0)
      ,fImp(0)
{
}
#endif
GfxStrip::GfxStrip(const CandStripHandle& csh, GfxStripList& parent)
    : fStrip(&csh)
      ,fParent(&parent)
      ,fImp(0)
{
}
GfxStrip::GfxStrip(const GfxStrip& rhs)
    : TObject(),
      fStrip(rhs.fStrip), fParent(rhs.fParent), fImp(0)
{
}
GfxStrip& GfxStrip::operator=(const GfxStrip& rhs)
{
    if (this == &rhs) return *this;
    fStrip = rhs.fStrip;
    fParent = rhs.fParent;
    fImp = 0;
    return *this;
}

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

void GfxStrip::Clear(const Option_t*)
{
  if (fImp) delete fImp; fImp=0;
}
bool GfxStrip::GetRealCoords(double& cx, double& cy, double& dx, double& dy)
{
    UgliGeomHandle ugh(*fStrip->GetVldContext());
    UgliStripHandle ush = ugh.GetStripHandle(fStrip->GetStripEndId());
    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;
}
bool GfxStrip::GetDiscreteCoords(double& cx, double& cy, double& dx, double& dy)
{
    PlexStripEndId seid = fStrip->GetStripEndId();
    cx = seid.GetPlane();
    cy = seid.GetStrip();
    dx = 1.5;
    dy = 1.5;
    return true;
}

float GfxStrip::GetRelativeValue(GfxStripListCfg::MeasureScale_t ms)
{
    if (ms == GfxStripListCfg::kCharge) {
        RangeDouble& qrange = fParent->GetMint().GetChargeRange();
        double den = qrange.Min() - qrange.Max();
        if (den > 0)
            return (fStrip->GetCharge() - qrange.Min()) / den;
    }
    else {                      // time
        RangeDouble& trange = fParent->GetMint().GetTimeRange();
        double den = trange.Max() - trange.Min();
        if (den > 0)
            return (fStrip->GetTime() - trange.Min()) / den;
    }
    return 1.0;
}

void GfxStrip::ModifyCoords(double& cx, double& cy, double& dx, double& dy)
{
    int strip_sign = 0;
    StripEnd::StripEnd_t end = fStrip->GetStripEndId().GetEnd();
    if (end == StripEnd::kNegative) strip_sign = -1;
    if (end == StripEnd::kPositive) strip_sign = +1;

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

    size_scale *= cfg.GetSizeFactor();

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

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

bool GfxStrip::SetColor()
{
  int fColor=fParent->GetStripColor(*fStrip);
  Bool_t ghost=false;

  if(fParent->GetEVD()->GetCandSlice()){
    TIter stripItr(fParent->GetEVD()->GetCandSlice()->GetDaughterIterator());
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())){
      if(strip){
        CandStripHandle csh1 = *strip;
        CandStripHandle csh2 = *fStrip;
        if(csh1==csh2 ||  csh1.IsCloneOf(csh2)){
          ghost=true;
          break;
        }
      }
      
    } 
  }
  else if (fParent->GetEVD()->GetCandEvent()){
 
    ghost=true;
    TIter stripItr(fParent->GetEVD()->GetCandEvent()->GetDaughterIterator());
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())){
      if(strip){
        CandStripHandle csh = *strip;
        if(*strip==*fStrip ||  fStrip->IsCloneOf(csh)){
          ghost=true;
          break;
        }
      }
    }
  }
  if(!ghost){
    fColor = fParent->GetStripColor(*fStrip);
    if(fStrip->GetCharge(CalDigitType::kPE)<5)fColor=10;
    if(fStrip->GetCharge(CalDigitType::kPE)<2)fColor=20;

  }
  else{
    fColor=fParent->GetEVD()->GetGhostColor();
  }
  if (!fColor) {
    return false;
  }


    TAttFill* att_fill = dynamic_cast<TAttFill*>(fImp);
    if (!att_fill) return false;
    att_fill->SetFillColor(fColor);
    TAttLine* att_line = dynamic_cast<TAttLine*>(fImp);
    if (!att_line) return false;
    att_line->SetLineColor(fColor);
    att_line->SetLineWidth(1);
    return true;
}

void GfxStrip::Configure()
{

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

    GfxStripListCfg& cfg = fParent->GetCfg();

    fCx = fCy = fDx = fDy = 0.0;


    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() == GfxStripListCfg::kAbsolute) {
        fDx = 1.5;
        fDy = 6.0;
        this->ModifyCoords(fCx,fCy,fDx,fDy);
        this->RelToAbs(dx,dy);
    }
    else {
        this->ModifyCoords(fCx,fCy,fDx,fDy);
    }
    switch (cfg.GetShapeIs()) {
    case GfxStripListCfg::kEllipse: 
        fImp = new TEllipse(fCx,fCy,dx,dy);
        break;
    default:
        fImp = new TBox(fCx+dx,fCy+dy,fCx-dx,fCy-dy);
        break;
    }

    TAttFill* att_fill = dynamic_cast<TAttFill*>(fImp);
    if (att_fill) {
      att_fill->SetFillStyle(1001);
    } 

//    cerr << "GfxStrip::Configure (" << cx << "," << cy << ")\n";

}


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

    if (!this->SetColor()) return;


    GfxStripListCfg& cfg = fParent->GetCfg();
    if (cfg.GetScaleIs() == GfxStripListCfg::kAbsolute) {
        double dx, dy;
        this->RelToAbs(dx,dy);

        switch (cfg.GetShapeIs()) {
        case GfxStripListCfg::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 GfxStrip::DistancetoPrimitive(int px, int py)
{
    if (fImp) return fImp->DistancetoPrimitive(px,py);
    return 0xdead;
}

void GfxStrip::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 GfxStrip::ConfigGui(void)
{
    if (!fParent) return;
    GfxStripListCfg& cfg = fParent->GetCfg();
    cfg.GuiConfig();

}

---