RxThresholdDisplayer.cpp

#include "RxThresholdDisplayer.h"
#include "DisplayManager.h"
#include "DisplayInfo.h"
#include "RawDisplayer.h"

#include "SctData/RawScanResult.h"
#include "SctData/RxThresholdBasedOnConfigRegisterTestResult.h"
#include "Sct/IS/IOManagerIS.h"
#include "Sct/IS/IONameIS.h"
#include "Sct/Archive/IONameArchiveFile.h"
#include "Sct/Archive/IOManagerArchiveFile.h"

#include <vector>
#include <sstream>
#include <algorithm>
#include <boost/shared_ptr.hpp>

#include <TCanvas.h>
#include <TLine.h>
#include <TAxis.h>
#include <TH2.h>

using namespace std;
using namespace SctData;
using namespace Sct;
using namespace Sct::IS;
using namespace boost;

namespace SctDataDisplay {

bool RxThresholdDisplayer::inMap = DisplayManager::addToMap("SctData::RxThresholdBasedOnConfigRegisterTestResult", shared_ptr<Displayer>(new RxThresholdDisplayer()));


class RxThresholdDisplayData : public DisplayData {
 public:
  boost::shared_ptr<RawDisplayData> rawDisplayData;
  boost::shared_ptr<const RawScanResult> raw;
};

shared_ptr<DisplayData> RxThresholdDisplayer::display(shared_ptr<const Sct::Serializable> serial, const DisplayInfo& info, std::ostream& os) {  
    shared_ptr<RxThresholdDisplayData> data (new RxThresholdDisplayData());
    const RxThresholdBasedOnConfigRegisterTestResult& result = dynamic_cast<const RxThresholdBasedOnConfigRegisterTestResult&>(*serial);
    os << result.getHeader().getScanNumber() << endl;
    
    try {
        Sct::IS::IONameIS name_is(result.getUniqueID(), "SctData::RawScanResult");
    shared_ptr<Serializable> ob = IOManagerIS::instance().read(name_is.getIOName());
    data->raw = dynamic_pointer_cast<const RawScanResult>(ob);
    } catch (Sct::IoException& e) {
    e.sendToMrs(MRS_DIAGNOSTIC);
    }
    if (data->raw==0) try {
      Sct::Archive::IONameArchiveFile name(result.getHeader().getUniqueID(),"SctData::RawScanResult");
      shared_ptr<Serializable> ob = Sct::Archive::IOManagerArchiveFile::instance().read(name.getIOName());
      data->raw = dynamic_pointer_cast<const RawScanResult>(ob);
    } catch (Sct::IoException& e) {
    e.sendToMrs(MRS_DIAGNOSTIC);
    }

    if (data->raw == 0){
        cerr << "Couldn't get RawScanResult associated with this RxThresholdScanResult" << endl;    
    }else{
      boost::shared_ptr<DisplayData> ddata = DisplayManager::display(data->raw, info, os);
      data->rawDisplayData = dynamic_pointer_cast<RawDisplayData>(ddata);

      if (data->rawDisplayData->canvas.empty() || !data->rawDisplayData->canvas[0].get()) {
    std::cout << "Can not draw lines on empty canvas" << std::endl; 
      }else {


    TVirtualPad* pad = (TVirtualPad*)data->rawDisplayData->canvas[0]->GetPrimitive("Data");
    if (!pad) std::cerr << "no pad" << std::endl;
    for (unsigned int link=0; link<2; ++link) {
      
      if (pad) pad->cd(link+1);
      TAxis* axis = data->raw->getScanData(link).GetXaxis();
 
      double min = axis->GetXmin();
      double max = axis->GetXmax();
      TLine*l = new TLine(min, result.getStreamResult(link).bestRxThresh(), max,result.getStreamResult(link).bestRxThresh());
      l->SetLineWidth(2);
      l->SetLineColor(kBlue);
      l->Draw();

      TLine*lmax = new TLine(min, result.getStreamResult(link).maxErrorFreeRxThresh(), max,result.getStreamResult(link).maxErrorFreeRxThresh());
      lmax->SetLineWidth(1);
      lmax->SetLineColor(kRed);
      lmax->Draw();

      TLine*lmin = new TLine(min, result.getStreamResult(link).minErrorFreeRxThresh(), max,result.getStreamResult(link).minErrorFreeRxThresh());
      lmin->SetLineWidth(1);
      lmin->SetLineColor(kRed);
      lmin->Draw();
      
    }
    
      }
    }
    
    //Now print out defects:
    os << endl << "Defects: " << endl;
    printDefectList(result.getDefects(), os);   
    
    return data;
}
}

---