TCurlyArc.cxx

Go to the documentation of this file.

// @(#)root/graf:$Id$
// Author: Otto Schaile   20/11/99
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
/** \class TCurlyArc
\ingroup BasicGraphics
 
Implements curly or wavy arcs used to draw Feynman diagrams.
 
Amplitudes and wavelengths may be specified in the constructors,
via commands or interactively from popup menus.
The class make use of TCurlyLine by inheritance, ExecuteEvent methods
are highly inspired from the methods used in TPolyLine and TArc.
The picture below has been generated by the tutorial feynman.
 
Begin_Macro(source)
../../../tutorials/visualisation/graphics/feynman.C
End_Macro
*/
 
#include <iostream>
#include "TCurlyArc.h"
#include "TROOT.h"
#include "TVirtualPad.h"
#include "TVirtualPadPainter.h"
#include "TAttMarker.h"
#include "TMath.h"
#include "TPoint.h"
 
Double_t TCurlyArc::fgDefaultWaveLength = 0.02;
Double_t TCurlyArc::fgDefaultAmplitude  = 0.01;
Bool_t   TCurlyArc::fgDefaultIsCurly    = kTRUE;
 
 
////////////////////////////////////////////////////////////////////////////////
/// Default constructor
 
TCurlyArc::TCurlyArc()
{
   fR1     = 0.;
   fPhimin = 0.;
   fPhimax = 0.;
   fTheta  = 0.;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a new TCurlyArc with center (x1, y1) and radius rad.
/// The wavelength and amplitude are given in percent of the line length
/// phimin and phimax are given in degrees.
 
TCurlyArc::TCurlyArc(Double_t x1, Double_t y1,
                   Double_t rad, Double_t phimin, Double_t phimax,
                   Double_t wl, Double_t amp)
         : fR1(rad), fPhimin(phimin),fPhimax(phimax)
{
   fX1         = x1;
   fY1         = y1;
   fIsCurly    = fgDefaultIsCurly;
   fAmplitude  = amp;
   fWaveLength = wl;
   fTheta      = 0;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a curly (Gluon) or wavy (Gamma) arc.
 
void TCurlyArc::Build()
{
   Double_t pixeltoX = 1;
   Double_t pixeltoY = 1;
   Double_t rPix = fR1;
   if (gPad) {
      Double_t pxrange = gPad->GetPadWidth();
      Double_t pyrange = -1. * gPad->GetPadHeight();
      Double_t xrange  = gPad->GetX2() - gPad->GetX1();
      Double_t yrange  = gPad->GetY2() - gPad->GetY1();
      pixeltoX  = xrange / pxrange;
      pixeltoY  = yrange/pyrange;
      rPix = fR1 / pixeltoX;
   }
   Double_t dang = fPhimax - fPhimin;
   if (dang < 0) dang += 360;
   Double_t length = TMath::Pi() * fR1 * dang/180;
   Double_t x1sav = fX1;
   Double_t y1sav = fY1;
   fX1 = fY1 = 0;
   fX2 = length;
   fY2 = 0;
   TCurlyLine::Build();
   fX1 = x1sav;
   fY1 = y1sav;
   Double_t *xv= GetX();
   Double_t *yv= GetY();
   Double_t xx, yy, angle;
   for(Int_t i = 0; i < fNsteps; i++){
      angle = xv[i] / rPix + fPhimin * TMath::Pi()/180;
      xx    = (yv[i] + rPix) * cos(angle);
      yy    = (yv[i] + rPix) * sin(angle);
      xx *= pixeltoX;
      yy *= TMath::Abs(pixeltoY);
      xv[i] = xx + fX1;
      yv[i] = yy + fY1;
   }
   if (gPad)
      gPad->Modified();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from point px,py to an arc.
///
///  Compute the closest distance of approach from point px,py to this arc.
///  The distance is computed in pixels units.
 
Int_t TCurlyArc::DistancetoPrimitive(Int_t px, Int_t py)
{
   if (!gPad) return 9999;
   // Compute distance of point to center of arc
   Int_t pxc    = gPad->XtoAbsPixel(gPad->XtoPad(fX1));
   Int_t pyc    = gPad->YtoAbsPixel(gPad->YtoPad(fY1));
   Double_t dist = TMath::Sqrt(Long64_t(pxc-px)*(pxc-px)+Long64_t(pyc-py)*(pyc-py));
   Double_t cosa = (px - pxc)/dist;
   Double_t sina = (pyc - py)/dist;
   Double_t phi  = TMath::ATan2(sina,cosa);
   if (phi < 0) phi += 2 * TMath::Pi();
   phi = phi * 180 / TMath::Pi();
   if (fPhimax > fPhimin){
      if (phi < fPhimin || phi > fPhimax) return 9999;
   } else {
      if (phi > fPhimin && phi < fPhimax) return 9999;
   }
   Int_t pxa = gPad->XtoAbsPixel(gPad->XtoPad(fX1 + cosa*fR1));
   Int_t pya = gPad->YtoAbsPixel(gPad->YtoPad(fY1 + sina*fR1));
   Double_t dista = TMath::Sqrt(Long64_t(pxc-pxa)*(pxc-pxa)+Long64_t(pyc-pya)*(pyc-pya));
   return (Int_t) TMath::Abs(dist - dista);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Execute action corresponding to one event.
///
/// This member function is called when a TCurlyArc is clicked with the locator
///
/// If Left button clicked on one of the line end points, this point
/// follows the cursor until button is released.
///
/// if Middle button clicked, the line is moved parallel to itself
/// until the button is released.
 
void TCurlyArc::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   if (!gPad || !gPad->IsEditable()) return;
 
   auto &parent = *gPad;
 
   constexpr Int_t kMaxDiff = 10;
   static enum { pNone, pTop, pL, pR, pBot, pINSIDE } mode = pNone;
   static Int_t sdx = 0, sdy = 0;
   static Bool_t first_move = kTRUE;
 
   auto paint_hollow = [this, &parent]() {
      int np = 10;
      std::vector<Double_t> x(np+3), y(np+3);
 
      Double_t dphi = (fPhimax - fPhimin) * TMath::Pi() / 180;
      if (dphi < 0)
         dphi += 2 * TMath::Pi();
      Double_t phi0 = fPhimin * TMath::Pi() / 180;
      for (int i = 0; i <= np; i++) {
         Double_t angle = phi0 + i*dphi/np;
         x[i]  = parent.XtoPad(fX1 + fR1*TMath::Cos(angle));
         y[i]  = parent.YtoPad(fY1 + fR1*TMath::Sin(angle));
      }
      if (fPhimax - fPhimin < 360) {
         ++np;
         x[np] = parent.XtoPad(fX1);
         y[np] = parent.YtoPad(fY1);
      }
      ++np;
      x[np] = x[0];
      y[np] = y[0];
 
      auto pp = parent.GetPainter();
      pp->SetAttLine(*this);
      pp->DrawPolyLine(np + 1, x.data(), y.data());
 
      Double_t xm[4] = { fX1, fX1, fX1 - fR1, fX1 + fR1 };
      Double_t ym[4] = { fY1 + fR1, fY1 - fR1, fY1, fY1 };
      for (Int_t i = 0; i < 4; ++i) {
         xm[i] = parent.XtoPad(xm[i]);
         ym[i] = parent.YtoPad(ym[i]);
      }
      pp->SetAttMarker({GetLineColor(), 25, 2});
      pp->DrawPolyMarker(4, xm, ym);
   };
 
   Bool_t opaque  = parent.OpaqueMoving();
 
   switch (event) {
 
   case kArrowKeyPress:
   case kButton1Down:
      // No break !!!
   case kMouseMotion: {
      Int_t px1 = parent.XtoAbsPixel(parent.XtoPad(fX1));
      Int_t py1 = parent.YtoAbsPixel(parent.YtoPad(fY1));
      Int_t pLx = parent.XtoAbsPixel(parent.XtoPad(fX1 - fR1));
      Int_t pRx = parent.XtoAbsPixel(parent.XtoPad(fX1 + fR1));
      Int_t pTy = parent.YtoAbsPixel(parent.YtoPad(fY1 + fR1));
      Int_t pBy = parent.YtoAbsPixel(parent.YtoPad(fY1 - fR1));
 
      if ((abs(px - px1) < kMaxDiff) && (abs(py - pTy) < kMaxDiff)) {
         mode = pTop;
         parent.SetCursor(kTopSide);
      } else if ((abs(px - px1) < kMaxDiff) && (abs(py - pBy) < kMaxDiff)) {
         mode = pBot;
         parent.SetCursor(kBottomSide);
      } else if ((abs(py - py1) < kMaxDiff) && (abs(px - pLx) < kMaxDiff)) {
         mode = pL;
         parent.SetCursor(kLeftSide);
      } else if ((abs(py - py1) < kMaxDiff) && (abs(px - pRx) < kMaxDiff)) {
         mode = pR;
         parent.SetCursor(kRightSide);
      } else {
         mode = pINSIDE;
         sdx = px1 - px;
         sdy = py1 - py;
         parent.SetCursor(kMove);
      }
      first_move = kTRUE;
 
      break;
   }
 
   case kArrowKeyRelease:
   case kButton1Motion: {
      if (!opaque && !first_move)
         paint_hollow();
      char guide = 0;
      switch (mode) {
      case pNone:
         break;
      case pTop:
         fR1 = GetYCoord(py, kFALSE, kTRUE) - fY1;
         guide = 't';
         break;
      case pBot:
         fR1 = fY1 - GetYCoord(py, kFALSE, kTRUE);
         guide = 'b';
         break;
      case pL:
         fR1 = fX1 - GetXCoord(px, kFALSE, kTRUE);
         guide = 'l';
         break;
      case pR:
         fR1 = GetXCoord(px, kFALSE, kTRUE) - fX1;
         guide = 'r';
         break;
      case pINSIDE:
         fX1 = GetXCoord(px + sdx, kFALSE, kTRUE);
         fY1 = GetYCoord(py + sdy, kFALSE, kTRUE);
         guide = 'i';
         break;
      }
 
      first_move = kFALSE;
 
      if (!opaque)
         paint_hollow();
      else {
         if (guide)
            parent.ShowGuidelines(this, event, guide, true);
         Build();
         parent.ModifiedUpdate();
      }
      break;
   }
 
   case kButton1Up:
      if (opaque) {
         parent.ShowGuidelines(this, event);
      } else {
         Build();
         parent.Modified(kTRUE);
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save primitive as a C++ statement(s) on output stream out
 
void TCurlyArc::SavePrimitive(std::ostream &out, Option_t *option)
{
   SavePrimitiveConstructor(
      out, Class(), "curlyarc",
      TString::Format("%g, %g, %g, %g, %g, %g, %g", fX1, fY1, fR1, fPhimin, fPhimax, fWaveLength, fAmplitude));
 
   SaveLineAttributes(out, "curlyarc", 1, 1, 1);
   if (!fIsCurly)
      out << "   curlyarc->SetWavy();\n";
 
   SavePrimitiveDraw(out, "curlyarc", option);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Curly Arc center.
 
void TCurlyArc::SetCenter(Double_t x, Double_t y)
{
   fX1 = x;
   fY1 = y;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Curly Arc radius.
 
void TCurlyArc::SetRadius(Double_t x)
{
   fR1 = x;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Curly Arc minimum Phi.
 
void TCurlyArc::SetPhimin(Double_t x)
{
   fPhimin = x;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Curly Arc maximum Phi.
 
void TCurlyArc::SetPhimax(Double_t x)
{
   fPhimax = x;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set default wave length.
 
void TCurlyArc::SetDefaultWaveLength(Double_t WaveLength)
{
   fgDefaultWaveLength = WaveLength;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set default wave amplitude.
 
void TCurlyArc::SetDefaultAmplitude(Double_t Amplitude)
{
   fgDefaultAmplitude = Amplitude ;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set default "IsCurly".
 
void TCurlyArc::SetDefaultIsCurly(Bool_t IsCurly)
{
   fgDefaultIsCurly = IsCurly;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get default wave length.
 
Double_t TCurlyArc::GetDefaultWaveLength()
{
   return fgDefaultWaveLength;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get default wave amplitude.
 
Double_t TCurlyArc::GetDefaultAmplitude()
{
   return fgDefaultAmplitude;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get default "IsCurly".
 
Bool_t TCurlyArc::GetDefaultIsCurly()
{
   return fgDefaultIsCurly;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the bounding Box of the Line
 
Rectangle_t TCurlyArc::GetBBox()
{
   Rectangle_t bbox{0, 0, 0, 0};
   if (gPad) {
      Double_t R2 = fR1 * TMath::Abs(gPad->GetY2() - gPad->GetY1()) / TMath::Abs(gPad->GetX2() - gPad->GetX1());
      bbox.fX = gPad->XtoPixel(fX1 - fR1);
      bbox.fY = gPad->YtoPixel(fY1 + R2);
      bbox.fWidth = gPad->XtoPixel(fX1 + fR1) - bbox.fX;
      bbox.fHeight = gPad->YtoPixel(fY1 - R2) - bbox.fY;
   }
   return bbox;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the center of the BoundingBox as TPoint in pixels
 
TPoint TCurlyArc::GetBBoxCenter()
{
   TPoint p(0,0);
   if (gPad) {
      p.SetX(gPad->XtoPixel(fX1));
      p.SetY(gPad->YtoPixel(fY1));
   }
   return p;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set X coordinate of the center of the BoundingBox
 
void TCurlyArc::SetBBoxCenterX(const Int_t x)
{
   fX1 = GetXCoord(x);
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Y coordinate of the center of the BoundingBox
 
void TCurlyArc::SetBBoxCenterY(const Int_t y)
{
   fY1 = GetYCoord(y);
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set left hand side of BoundingBox to a value
/// (resize in x direction on left)
 
void TCurlyArc::SetBBoxX1(const Int_t x)
{
   fR1 = fX1 - GetXCoord(x);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set right hand side of BoundingBox to a value
/// (resize in x direction on right)
 
void TCurlyArc::SetBBoxX2(const Int_t x)
{
   fR1 = GetXCoord(x) - fX1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set top of BoundingBox to a value (resize in y direction on top)
 
void TCurlyArc::SetBBoxY1(const Int_t y)
{
   fR1 = GetYCoord(y) - fY1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set bottom of BoundingBox to a value
/// (resize in y direction on bottom)
 
void TCurlyArc::SetBBoxY2(const Int_t y)
{
   fR1 = fY1 - GetYCoord(y);
}