JDrawDetector2D.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <limits>
#include <vector>
#include <map>
#include <set>

#include "TROOT.h"
#include "TH2D.h"
#include "TApplication.h"
#include "TGraph.h"
#include "TEllipse.h"
#include "TCanvas.h"
#include "TMarker.h"
#include "TText.h"
#include "TStyle.h"
#include "TLegend.h"
#include "TError.h"

#include "JLang/JSinglePointer.hh"
#include "JROOT/JCanvas.hh"
#include "JROOT/JStyle.hh"
#include "JROOT/JMarkerAttributes.hh"
#include "JROOT/JLegend.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JTripod.hh"
#include "JGeometry2D/JPosition2D.hh"
#include "JGeometry2D/JCircle2D.hh"

#include "Jeep/JeepToolkit.hh"
#include "Jeep/JContainer.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

namespace {

  /**
   * Marker with text.
   */
  struct JPoint_t {
    /**
     * Constructor.
     *
     * \param  id         identifier
     * \param  x          x-position
     * \param  y          y-position
     * \param  marker     marker attributes
     * \param  text       text   attributes
     * \param  offset     text ofset
     */
    JPoint_t(const int         id,
             const double      x,
             const double      y,
             const TAttMarker& marker,
             const TAttText&   text,
             const double      offset)
    {
      static_cast<TAttMarker&>(this->marker) = marker;
      static_cast<TAttText&>  (this->text)   = text;

      this->marker.SetX(x);
      this->marker.SetY(y);

      this->text.SetText(x + offset * cos(text.GetTextAngle()),
                         y + offset * sin(text.GetTextAngle()),
                         MAKE_CSTRING(id));

      // overwrite text attributes

      this->text.SetTextAngle(0.0);
      this->text.SetTextColor(marker.GetMarkerColor());
    }

    /**
     * Add offset.
     *
     * \param  x          x-position
     * \param  y          y-position
     */
    void add(const double x, const double y)
    {
      this->marker.SetX(this->marker.GetX() + x);
      this->marker.SetY(this->marker.GetY() + y);
      this->text  .SetX(this->text  .GetX() + x);
      this->text  .SetY(this->text  .GetY() + y);
    }

    /**
     * Subtract offset.
     *
     * \param  x          x-position
     * \param  y          y-position
     */
    void sub(const double x, const double y)
    {
      this->marker.SetX(this->marker.GetX() - x);
      this->marker.SetY(this->marker.GetY() - y);
      this->text  .SetX(this->text  .GetX() - x);
      this->text  .SetY(this->text  .GetY() - y);
    }

    /**
     * Draw.
     */
    void Draw()
    {
      marker.Draw();
      text  .Draw();
    }

    TMarker marker;
    TText   text;
  };


  /**
   * Container of markers.
   */
  struct JGraph_t : 
    public std::vector<JPoint_t>
  {
    /**
     * Add offset.
     *
     * \param  x          x-position
     * \param  y          y-position
     */
    void add(const double x, const double y)
    {
      for (iterator i = begin(); i != end(); ++i) {
        i->add(x, y);
      }
    }

    /**
     * Subtract offset.
     *
     * \param  x          x-position
     * \param  y          y-position
     */
    void sub(const double x, const double y)
    {
      for (iterator i = begin(); i != end(); ++i) {
        i->sub(x, y);
      }
    }    

    /**
     * Draw.
     */
    void Draw()
    {
      for (iterator i = begin(); i != end(); ++i) {
        i->Draw();
      }
    }    
  };
}


/**
 * \file
 * Auxiliary program to draw the footprint of detector(s).
 * \author mdejong
 */
int main(int argc, char**argv)
{
  using namespace std;
  using namespace JPP;

  typedef JContainer< vector<JTripod> >      tripods_container;

  vector<string>      detectorFile;
  vector<string>      tripodsFile;
  string              outputFile;
  JCanvas             canvas;
  string              legend;
  double              markerSize;
  double              textSize;
  bool                drawCircle;
  bool                batch;
  int                 debug;

  try {

    JParser<> zap("Auxiliary program to draw the footprint of detector(s).");

    zap['w'] = make_field(canvas,       "size of canvas <nx>x<ny> [pixels]")  = JCanvas(500, 500);
    zap['a'] = make_field(detectorFile, "detector file")                      = JPARSER::initialised();
    zap['T'] = make_field(tripodsFile,  "tripod file")                        = JPARSER::initialised();
    zap['o'] = make_field(outputFile,   "graphics output")                    = "";
    zap['L'] = make_field(legend,       "position legend e.g. TR")            = "", "TL", "TR", "BR", "BL";
    zap['S'] = make_field(markerSize,   "marker size")                        = 1.0;
    zap['s'] = make_field(textSize,     "text size")                          = 0.02;
    zap['C'] = make_field(drawCircle,   "draw smallest enclosing cicrle");
    zap['B'] = make_field(batch,        "batch processing");
    zap['d'] = make_field(debug)                                              = 1;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  if (detectorFile.empty() && tripodsFile.empty()) {
    FATAL("No detector elements." << endl);
  }


  gROOT->SetBatch(batch);

  gErrorIgnoreLevel = kWarning;

  TApplication* tp = new TApplication("user", NULL, NULL);
  TCanvas*      cv = new TCanvas("detector", "", canvas.x, canvas.y);

  JSinglePointer<TStyle> gStyle(new JStyle("gplot", cv->GetWw(), cv->GetWh()));

  gROOT->SetStyle("gplot");
  gROOT->ForceStyle();

  cv->SetFillStyle(4000);
  cv->SetFillColor(kWhite);
  cv->Divide(1, 1);
  cv->cd(1);

  JMarkerAttributes::getInstance().setMarkerSize(markerSize);

  vector<TAttText> text_attributes = {
    TAttText(kHAlignLeft  + kVAlignBottom, 0.25*PI, kBlack, 62, textSize),
    TAttText(kHAlignRight + kVAlignBottom, 0.75*PI, kBlack, 62, textSize),
    TAttText(kHAlignRight + kVAlignTop,    1.25*PI, kBlack, 62, textSize),
    TAttText(kHAlignLeft  + kVAlignTop,    1.75*PI, kBlack, 62, textSize)
  };

  map<string, JGraph_t> data;                // graphics data
  JCircle2D             circle;              // enclosing circle
  JUTMPosition          position;            // UTM position

  for (size_t i = 0; i != detectorFile.size(); ++i) {

    JDetector detector;

    try {
      load(detectorFile[i], detector);
    }
    catch(const JException& error) {
      FATAL(error);
    }

    JCircle2D c1(detector.begin(), detector.end());

    if (c1.getRadius() > circle.getRadius()) {
      circle = c1;
    }

    position = detector.getUTMPosition();

    const TAttMarker& marker = *JMarkerAttributes::getInstance().next();
    const TAttText&   text   =  text_attributes[i%text_attributes.size()];

    vector<JPoint_t>& buffer = data[getFilename(detectorFile[i])];

    set<int> counter;

    for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {      

      if (counter.count(module->getString()) == 0) {

        buffer.push_back(JPoint_t(module->getString(),
                                  module->getX(),
                                  module->getY(),
                                  marker,
                                  text,
                                  3.0 * textSize * c1.getRadius()));

        counter.insert(module->getString());
      }
    }
  }

  for (size_t i = 0; i != tripodsFile.size(); ++i) {

    tripods_container tripods;
    
    ifstream in(tripodsFile[i].c_str());

    in >> tripods;

    in.close();
    
    if (detectorFile.empty()) {
      position = getAverage(make_array(tripods.begin(), tripods.end(), &JTripod::getUTMPosition));
    }

    JCircle2D c1(make_array(tripods.begin(), tripods.end(), &JTripod::getPosition));

    c1.sub(position.getPosition());

    if (c1.getRadius() > circle.getRadius()) {
      circle = c1;
    }

    const TAttMarker& marker = *JMarkerAttributes::getInstance().next();
    const TAttText&   text   =  text_attributes[i%text_attributes.size()];

    vector<JPoint_t>& buffer = data[getFilename(tripodsFile[i])];

    for (tripods_container::iterator i = tripods.begin(); i != tripods.end(); ++i) {

      buffer.push_back(JPoint_t(i->getID(),
                                i->getUTMEast()  - position.getUTMEast(),
                                i->getUTMNorth() - position.getUTMNorth(),
                                marker,
                                text,
                                3.0 * textSize * c1.getRadius()));
    }
  }


  DEBUG("Detector (x,y,R): " << FIXED(12,3) << circle.getX() << ' ' << FIXED(12,3) << circle.getY() << ' ' << FIXED(9,3) << circle.getRadius() << endl);

  // center

  for (map<string, JGraph_t>::iterator i = data.begin(); i != data.end(); ++i) {
    i->second.sub(circle.getX(), circle.getY());
  }

  circle.sub(circle.getPosition());


  // draw

  cv->cd(1);

  const Double_t xmin  =  circle.getX()  -  1.15 * circle.getRadius();
  const Double_t xmax  =  circle.getX()  +  1.15 * circle.getRadius();
  const Double_t ymin  =  circle.getY()  -  1.15 * circle.getRadius();
  const Double_t ymax  =  circle.getY()  +  1.15 * circle.getRadius();

  TH2D h2("h2", "", 1, xmin, xmax, 1, ymin, ymax);

  h2.GetXaxis()->SetTitle("x [m]");
  h2.GetYaxis()->SetTitle("y [m]");
  
  h2.GetXaxis()->CenterTitle(true);
  h2.GetYaxis()->CenterTitle(true);

  h2.SetStats(kFALSE);
  h2.Draw("AXIS");


  TEllipse ellipse(circle.getX(), circle.getY(), circle.getRadius());

  if (drawCircle) {
    ellipse.Draw();
  }
  
  for (map<string, JGraph_t>::iterator i = data.begin(); i != data.end(); ++i) {
    i->second.Draw();
  }
  
  if (legend != "") {

    Ssiz_t height = data.size();
    Ssiz_t width  = 1;
    
    for (map<string, JGraph_t>::const_iterator i = data.begin(); i != data.end(); ++i) {
      width = max(width, (Ssiz_t) i->first.size());
    }
    
    TLegend* lg = getLegend(width, height, legend);

    lg->SetTextSize(textSize);
    
    for (map<string, JGraph_t>::const_iterator i = data.begin(); i != data.end(); ++i) {
      if (!i->second.empty()) {
        lg->AddEntry(&i->second[0].marker, i->first.c_str(), "P"); 
      }
    }
    
    lg->Draw();
  }

  cv->Update();

  if (outputFile != "") {
    cv->SaveAs(outputFile.c_str());
  }

  if (!batch) {
    tp->Run();
  }
}