QGScatterPlot.cc

Go to the documentation of this file.

#include "QGScatterPlot.hh"
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
#include "QChain.hh"
#include "QGCanvasWindow.hh"
#include "QGFileHandler.hh"
#include "QGPlotEditWindow.hh"
#include "QGScatterPlotEditWindow.hh"
#include "QGScatterPlotParametersFrame.hh"
#include "QGPlotFrame.hh"
#include "QGPlotStyleFrame.hh"
#include "QGTextFileKeys.hh"
#include "TAxis.h"
#include "TCanvas.h"
#include "TH1F.h"
#include "TRootEmbeddedCanvas.h"
#include "TString.h"
#include "TStyle.h"
 
ClassImp(QGScatterPlot)
 
using std::cout;
using std::endl;
using std::list;
using std::map;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
 
list<QGScatterPlot*> QGScatterPlot::fScatterPlots;
 
QGScatterPlot::QGScatterPlot() :
QGGraph(), fStyleScatterPlot(new TGraph())
{
    fScatterPlots.push_back(this);
    SetName();
    SetBit(kCanDelete, kFALSE);
    SetEditable(kFALSE);
    MakeStylePlot();
}
 
QGScatterPlot::QGScatterPlot(const QGScatterPlot &scatterPlot) :
QGGraph(scatterPlot), fStyleScatterPlot(new TGraph())
{
    fScatterPlots.push_back(this);
    SetName();
    SetBit(kCanDelete, kFALSE);
    SetEditable(kFALSE);
    MakeStylePlot();
}
 
QGScatterPlot::~QGScatterPlot()
{
    if (fPlotEditWindow) {
        fPlotEditWindow->CloseWindow();
        fPlotEditWindow = 0;
    }
    if (find(fScatterPlots.begin(), fScatterPlots.end(), this) != fScatterPlots.end()) {
        fScatterPlots.erase(find(fScatterPlots.begin(), fScatterPlots.end(), this));
    }
    delete fStyleScatterPlot;
}
 
void QGScatterPlot::AutoSetStyle()
{
    SetMarkerStyle(20); // point
    SetMarkerSize(0.4); 
 
    // set standard plot color
    vector<Color_t> standardColors;
    standardColors.push_back(kRed - 3);
    standardColors.push_back(kBlue + 1);
    standardColors.push_back(kGreen + 2);
    standardColors.push_back(kMagenta + 2);
    standardColors.push_back(kCyan + 3);
    
    // count how many existing scatter plots are using each standard color
    map<Color_t, int> colorCount;
        // map index works like colorCount[color] = number of plots with color
    for ( list<QGScatterPlot*>::const_iterator plotIter
              =  fScatterPlots.begin();
          plotIter != fScatterPlots.end();
          ++plotIter ) {
        Color_t otherColor = (*plotIter)->GetMarkerColor();
        vector<Color_t>::iterator colorIter
            = find( standardColors.begin(), standardColors.end(), otherColor );
        if ( colorIter != standardColors.end() ) {
            ++colorCount[*colorIter];
        }
    }
    
    // find the least used color among the existing scatter plots
    Color_t leastUsedColor = standardColors.front();
    int leastUsedNumber = colorCount[leastUsedColor];
    for ( vector<Color_t>::const_iterator colorIter = standardColors.begin();
          colorIter != standardColors.end();
          ++colorIter ) {
        if (colorCount[*colorIter] < leastUsedNumber) {
            leastUsedColor = *colorIter;
            leastUsedNumber = colorCount[*colorIter];
        }
    }
    
    // assign the least used color to this plot
    SetMarkerColor(leastUsedColor);
    
    MakeStylePlot();
}
 
void QGScatterPlot::Display()
{
    delete fHistogram;
    fHistogram = 0;
    if (fStyleScatterPlot) {
        fStyleScatterPlot->TAttFill::Copy(*this);
        fStyleScatterPlot->TAttLine::Copy(*this);
        fStyleScatterPlot->TAttMarker::Copy(*this);
    }
    string xAxisLabel = GetXVariable();
    string yAxisLabel = GetYVariable();
    if (GetXUnits() != "") {
        xAxisLabel += " (" + GetXUnits() + ")";
    }
    if (GetYUnits() != "") {
        yAxisLabel += " (" + GetYUnits() + ")";
    }
    GetXaxis()->SetTitle(xAxisLabel.c_str());
    GetYaxis()->SetTitle(yAxisLabel.c_str());
    GetYaxis()->SetTitleOffset(1.35);
    if (fCanvasWindow) {
        bool drawSuperimpose = false;
        if (fSuperimpose) {
            if (fCanvasWindow->GetDrawnPlots().size() != 0) {
                if (typeid(*fCanvasWindow->GetDrawnPlots().back()) == typeid(*this)) {
                    drawSuperimpose = true;
                }
            }
        }
        if (drawSuperimpose) {
            fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(this);
            if (GetN() > 0) {
                Draw("P"); //Draw("P same");
            }
            fCanvasWindow->RemoveFromDrawnPlots(this);
            fCanvasWindow->AddToDrawnPlots(this);
        } else {
            fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->Clear();
            if (GetN() > 0) {
                Draw("AP");
            }
            fCanvasWindow->ClearDrawnPlots();
            fCanvasWindow->AddToDrawnPlots(this);
        }
        if (gPad) {
            gPad->Update();
        }
    }
}
 
void QGScatterPlot::DisplayEditWindow()
{
    if (!fPlotEditWindow) {
        fPlotEditWindow = new QGScatterPlotEditWindow();
        fPlotEditWindow->SetPlot(this);
        
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->SetEditable(kTRUE);
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
        DrawStyleScatterPlot();
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->SetEditable(kFALSE);
    }
}
 
void QGScatterPlot::DrawStyleScatterPlot()
{
    MakeStylePlot();
    TH1F *supportHistogram = new TH1F();
    supportHistogram->SetBit(kCanDelete, kTRUE);
    supportHistogram->SetStats(kFALSE);
    supportHistogram->SetBins(1, 0, 5);
    supportHistogram->GetYaxis()->SetRangeUser(0, 20);
    supportHistogram->Draw("AH");
    fStyleScatterPlot->Draw("P");
    if (gPad) {
        gPad->Update();
    }
}
 
void QGScatterPlot::Duplicate()
{
    QGScatterPlot *scatterPlot = new QGScatterPlot(*this);
    scatterPlot->AutoSetStyle();
    scatterPlot->DisplayEditWindow();
}
 
void QGScatterPlot::Erase()
{
    if (fCanvasWindow) {
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(this);
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->Update();
        fCanvasWindow->RemoveFromDrawnPlots(this);
        // to do:  check whether this was the first drawn plot and if so redraw remaining plots in order to have axes
    }
}
 
void QGScatterPlot::Generate(QChain *chain)
{
    Reset();
    if (chain == 0) {
        if (fCanvasWindow && fCanvasWindow->GetFileHandler()) {
            if (fCanvasWindow->GetFileHandler()->IsFileOpen()) {
                chain = fCanvasWindow->GetFileHandler()->GetQChain();
            } else {
                cout << "Cannot generate the scatter plot because there is no file open" << endl;
            }
        }
    }
    if (chain) {
        if (fXVariable == "") {
            cout << "Enter an x-axis variable for the scatter plot" << endl;
        } else if (fYVariable == "") {
            cout << "Enter a y-axis variable for the scatter plot" << endl;
        } else {
            chain->SetEstimate(chain->GetEntries());
            string drawArgument = fXVariable + " : " + fYVariable;
            chain->Draw(drawArgument.c_str(), fCutsString.c_str(), "goff");
            Long64_t N = chain->GetSelectedRows();
            if (N > 0) {
                SetPoints(N, chain->GetV1(), chain->GetV2());
            }
        }
    }
}
 
void QGScatterPlot::GetParametersFromEditWindow()
{
    if (fPlotEditWindow) {
        if (QGScatterPlotEditWindow *scatterPlotEditWindow = dynamic_cast<QGScatterPlotEditWindow*>(fPlotEditWindow)) {
            SetXVariable(scatterPlotEditWindow->GetScatterPlotParametersFrame()->GetXVariable());
            SetYVariable(scatterPlotEditWindow->GetScatterPlotParametersFrame()->GetYVariable());
            SetXUnits(scatterPlotEditWindow->GetScatterPlotParametersFrame()->GetXUnits());
            SetYUnits(scatterPlotEditWindow->GetScatterPlotParametersFrame()->GetYUnits());
            SetSuperimpose(scatterPlotEditWindow->GetScatterPlotParametersFrame()->IsSuperimposeSet());
        } else {
            cout << "QGScatterPlot::GetParametersFromEditWindow()        Warning:  dynamic_cast<QGScatterPlotEditWindow*> failed" << endl;
        }
    }
}
 
void QGScatterPlot::MakeStylePlot()
{
    fStyleScatterPlot->Set(5);
    fStyleScatterPlot->SetPoint(0, 0.5, 2);
    fStyleScatterPlot->SetPoint(1, 1.5, 3);
    fStyleScatterPlot->SetPoint(2, 2.5, 6);
    fStyleScatterPlot->SetPoint(3, 3.5, 11);
    fStyleScatterPlot->SetPoint(4, 4.5, 18);
    TAttFill::Copy(*fStyleScatterPlot);
    TAttLine::Copy(*fStyleScatterPlot);
    TAttMarker::Copy(*fStyleScatterPlot);
}
 
void QGScatterPlot::SetName(const char *name)
{
    if (name) {
        string oldName = TGraph::GetName();
        string newName = name;
        if (newName != oldName) {
            if (IsNameInUse(name)) {
                TGraph::SetName(GeneratePlotName(newName).c_str());
            } else {
                TGraph::SetName(name);
            }
        }
    } else {
        TGraph::SetName(GeneratePlotName("ScatterPlot").c_str());
    }
}
 
void QGScatterPlot::SetProperty(const string& key, const string& value)
{
    QGPlot::SetProperty(key, value);
    TString valueTString(value);
    if (key == MARKER_COLOR_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerColor(valueTString.Atoi());
        }
    }
    else if (key == MARKER_SIZE_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerSize(valueTString.Atof());
        }
    }
    else if (key == MARKER_STYLE_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerStyle(valueTString.Atoi());
        }
    }
}