TCurlyLine.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 TCurlyLine
\ingroup BasicGraphics
 
Implements curly or wavy polylines 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 TPolyLine 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 "TCurlyLine.h"
#include "TVirtualPad.h"
#include "TVirtualPadPainter.h"
#include "TMath.h"
#include "TPoint.h"
 
#include <iostream>
 
Double_t TCurlyLine::fgDefaultWaveLength = 0.02;
Double_t TCurlyLine::fgDefaultAmplitude  = 0.01;
Bool_t   TCurlyLine::fgDefaultIsCurly    = kTRUE;
 
 
////////////////////////////////////////////////////////////////////////////////
/// Default constructor.
 
TCurlyLine::TCurlyLine()
{
   fX1         = 0.;
   fY1         = 0.;
   fX2         = 0.;
   fY2         = 0.;
   fWaveLength = 0.;
   fAmplitude  = 0.;
   fIsCurly    = fgDefaultIsCurly;
   fNsteps     = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a new TCurlyLine with starting point (x1, y1), end point (x2,y2).
/// The wavelength and amplitude are given in percent of the pad height.
 
TCurlyLine::TCurlyLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t wl, Double_t amp)
{
   fX1         = x1;
   fY1         = y1;
   fX2         = x2;
   fY2         = y2;
   fWaveLength = wl;
   fAmplitude  = amp;
   fIsCurly    = fgDefaultIsCurly;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a curly (Gluon) or wavy (Gamma) line.
 
void TCurlyLine::Build()
{
   Double_t pixeltoX = 1;
   Double_t pixeltoY = 1;
 
   Double_t wavelengthPix,amplitudePix, lengthPix, hPix;
   Double_t px1, py1, px2, py2;
 
   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;
      hPix  = TMath::Max(pxrange, -pyrange);
      px1      = gPad->XtoAbsPixel(fX1);
      py1      = gPad->YtoAbsPixel(fY1);
      px2      = gPad->XtoAbsPixel(fX2);
      py2      = gPad->YtoAbsPixel(fY2);
      lengthPix = TMath::Sqrt((px2-px1)*(px2-px1) + (py1-py2)*(py1-py2));
      wavelengthPix = hPix*fWaveLength;
      amplitudePix  = hPix*fAmplitude;
   } else {
      wavelengthPix = fWaveLength;
      amplitudePix  = fAmplitude;
      px1           = fX1;
      py1           = fY1;
      px2           = fX2;
      py2           = fY2;
      lengthPix = TMath::Sqrt((px2-px1)*(px2-px1) + (py1-py2)*(py1-py2));
   }
   // construct the curly / wavy line in pixel coordinates at angle 0
   Double_t anglestep = 40;
   Double_t phimaxle  = TMath::Pi() * 2. / anglestep ;
   Double_t dx        = wavelengthPix / 40;
   Double_t len2pi    = dx * anglestep;
 
   // make sure there is a piece of straight line a both ends
 
   Double_t  lengthcycle = 0.5 * len2pi + 2 * amplitudePix;
   // if (fIsCurly) lengthcycle +=  amplitudePix;
   Int_t nperiods = (Int_t)((lengthPix - lengthcycle) / len2pi);
   Double_t restlength = 0.5 * (lengthPix - nperiods * len2pi - lengthcycle);
   fNsteps = (Int_t)(anglestep * nperiods + anglestep / 2 + 4);
   if (fNsteps < 2) fNsteps = 2;
   SetPolyLine(fNsteps);
   Double_t *xv = GetX();
   Double_t *yv = GetY();
   xv[0] = 0;          yv[0] = 0;
   xv[1] = restlength; yv[1] = 0;
   Double_t phase =  1.5 * TMath::Pi();
   Double_t x0 = amplitudePix + restlength;
   Int_t i;
   for(i = 2; i < fNsteps-1; i++){
   // distinguish between curly and wavy
      if (fIsCurly) xv[i] = x0 + amplitudePix * TMath::Sin(phase);
      else         xv[i] = x0;
      yv[i]  = amplitudePix*TMath::Cos(phase);
      phase += phimaxle;
      x0    += dx;
   }
   xv[fNsteps-1] = lengthPix; yv[fNsteps-1] = 0;
 
   if (InheritsFrom("TCurlyArc")) return;  // called by TCurlyArc
 
   // rotate object and transform back to user coordinates
   Double_t angle = TMath::ATan2(py2-py1, px2-px1);
   if (angle < 0) angle += 2*TMath::Pi();
 
   Double_t cosang = TMath::Cos(angle);
   Double_t sinang = TMath::Sin(angle);
   Double_t xx, yy;
 
   for(i = 0; i < fNsteps; i++){
      xx = xv[i] * cosang - yv[i] * sinang;
      yy = xv[i] * sinang + yv[i] * cosang;
      if (gPad) {
         xx *= pixeltoX;
         yy *= pixeltoY;
      }
      xv[i] = xx + fX1;
      yv[i] = yy + fY1;
   }
   if (gPad) gPad->Modified();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from point px,py to a line.
 
Int_t TCurlyLine::DistancetoPrimitive(Int_t px, Int_t py)
{
   return DistancetoLine(px,py,fX1,fY1,fX2,fY2);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Execute action corresponding to one event.
///
/// This member function is called when a  TCurlyLine 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 TCurlyLine::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   if (!gPad || !gPad->IsEditable()) return;
 
   constexpr Int_t kMaxDiff = 20;
   static Int_t sdx = 0, sdy = 0, selectPoint;
 
   auto &parent = *gPad;
 
   Bool_t opaque  = parent.OpaqueMoving();
 
   auto paint = [this, &parent]() {
      auto pp = parent.GetPainter();
      pp->SetAttLine(*this);
      pp->DrawLine(parent.XtoPad(fX1), parent.YtoPad(fY1), parent.XtoPad(fX2), parent.YtoPad(fY2));
   };
 
   auto set_coord = [this](Int_t _x1, Int_t _y1, Int_t _x2, Int_t _y2) {
      if (selectPoint & 1) {
         fX1 = GetXCoord(_x1, kFALSE, kTRUE);
         fY1 = GetYCoord(_y1, kFALSE, kTRUE);
      }
      if (selectPoint & 2) {
         fX2 = GetXCoord(_x2, kFALSE, kTRUE);
         fY2 = GetYCoord(_y2, kFALSE, kTRUE);
      }
   };
 
   Int_t px1 = parent.XtoAbsPixel(parent.XtoPad(fX1));
   Int_t py1 = parent.YtoAbsPixel(parent.YtoPad(fY1));
   Int_t px2 = parent.XtoAbsPixel(parent.XtoPad(fX2));
   Int_t py2 = parent.YtoAbsPixel(parent.YtoPad(fY2));
 
   switch (event) {
 
   case kArrowKeyPress:
   case kButton1Down:
 
      // No break !!!
 
   case kMouseMotion:
 
      if (abs(px1 - px) + abs(py1 - py) < kMaxDiff) {
         selectPoint = 1;
         parent.SetCursor(kPointer);
      } else if (abs(px2 - px) + abs(py2 - py) < kMaxDiff) {
         selectPoint = 2;
         parent.SetCursor(kPointer);
      } else {
         selectPoint = 3;
         sdx = px1 - px;
         sdy = py1 - py;
         parent.SetCursor(kMove);
      }
 
      break;
 
   case kArrowKeyRelease:
   case kButton1Motion:
      if (!opaque)
         paint();
      if (selectPoint == 1) {
         set_coord(px, py, 0, 0);
      } else if (selectPoint == 2) {
         set_coord(0, 0, px, py);
      } else if (selectPoint == 3) {
         set_coord(px + sdx, py + sdy, px + sdx + px2 - px1, py + sdy + py2 - py1);
      }
      if (!opaque)
         paint();
      else {
         char guide = selectPoint == 3 ? 'i' : '\0';
         if ((selectPoint == 1) || (selectPoint == 2))  {
            static const char GUIDES[2][2][2] = {
              { { '4', '1' }, { '3', '2' } },
              { { '2', '3' }, { '1', '4' } }
            };
            int x_idx = fX1 > fX2 ? 1 : 0;
            int y_idx = fY1 > fY2 ? 1 : 0;
            guide = GUIDES[selectPoint-1][x_idx][y_idx];
         }
         if (guide)
            parent.ShowGuidelines(this, event, guide, true);
 
         Build();
         parent.ModifiedUpdate();
      }
      break;
 
   case kButton1Up:
 
      if (opaque)
         parent.ShowGuidelines(this, event);
      else {
         Build();
         parent.ModifiedUpdate();
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save primitive as a C++ statement(s) on output stream out
 
void TCurlyLine::SavePrimitive(std::ostream &out, Option_t *option)
{
   SavePrimitiveConstructor(out, Class(), "curlyline",
                            TString::Format("%g, %g, %g, %g, %g, %g", fX1, fY1, fX2, fY2, fWaveLength, fAmplitude));
 
   SaveLineAttributes(out, "curlyline", 1, 1, 1);
 
   if (!fIsCurly)
      out << "   curlyline->SetWavy();\n";
 
   SavePrimitiveDraw(out, "curlyline", option);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set curly.
 
void TCurlyLine::SetCurly()
{
   fIsCurly = kTRUE;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set wavy.
 
void TCurlyLine::SetWavy()
{
   fIsCurly = kFALSE;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set wave length.
 
void TCurlyLine::SetWaveLength(Double_t x)
{
   fWaveLength = x;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set amplitude.
 
void TCurlyLine::SetAmplitude(Double_t x)
{
   fAmplitude = x;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set start point.
 
void TCurlyLine::SetStartPoint(Double_t x, Double_t y)
{
   fX1 = x;
   fY1 = y;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set end point.
 
void TCurlyLine::SetEndPoint(Double_t x, Double_t y)
{
   fX2 = x;
   fY2 = y;
   Build();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set default wave length.
 
void TCurlyLine::SetDefaultWaveLength(Double_t WaveLength)
{
   fgDefaultWaveLength = WaveLength;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set default amplitude.
 
void TCurlyLine::SetDefaultAmplitude(Double_t Amplitude)
{
   fgDefaultAmplitude  = Amplitude;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set default "IsCurly".
 
void TCurlyLine::SetDefaultIsCurly(Bool_t IsCurly)
{
   fgDefaultIsCurly    = IsCurly;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get default wave length.
 
Double_t TCurlyLine::GetDefaultWaveLength()
{
   return fgDefaultWaveLength;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get default amplitude.
 
Double_t TCurlyLine::GetDefaultAmplitude()
{
   return fgDefaultAmplitude;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get default "IsCurly".
 
Bool_t TCurlyLine::GetDefaultIsCurly()
{
   return fgDefaultIsCurly;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the bounding Box of the CurlyLine
 
Rectangle_t TCurlyLine::GetBBox()
{
   Rectangle_t bbox{0,0,0,0};
   if (gPad) {
      Int_t px1 = gPad->XtoPixel(fX1);
      Int_t px2 = gPad->XtoPixel(fX2);
      Int_t py1 = gPad->YtoPixel(fY1);
      Int_t py2 = gPad->YtoPixel(fY2);
 
      if (px1 > px2)
         std::swap(px1, px2);
      if (py1 > py2)
         std::swap(py1, py2);
 
      bbox.fX = px1;
      bbox.fY = py1;
      bbox.fWidth = px2 - px1;
      bbox.fHeight = py2 - py1;
   }
   return bbox;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set X coordinate of the center of the BoundingBox
 
void TCurlyLine::SetBBoxCenterX(const Int_t x)
{
   Double_t w2 = 0.5 * (fX2 - fX1);
   Double_t midx = GetXCoord(x);
   SetStartPoint(midx - w2, fY1);
   SetEndPoint(midx + w2, fY2);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Y coordinate of the center of the BoundingBox
 
void TCurlyLine::SetBBoxCenterY(const Int_t y)
{
   Double_t h2 = 0.5 * (fY2 - fY1);
   Double_t midy = GetYCoord(y);
   SetStartPoint(fX1, midy - h2);
   SetEndPoint(fX2, midy + h2);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set left hand side of BoundingBox to a value
/// (resize in x direction on left)
 
void TCurlyLine::SetBBoxX1(const Int_t x)
{
   if (fX2 > fX1)
      SetStartPoint(GetXCoord(x), fY1);
   else
      SetEndPoint(GetXCoord(x), fY2);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set right hands ide of BoundingBox to a value
/// (resize in x direction on right)
 
void TCurlyLine::SetBBoxX2(const Int_t x)
{
   if (fX2 > fX1)
      SetEndPoint(GetXCoord(x), fY2);
   else
      SetStartPoint(GetXCoord(x), fY1);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set top of BoundingBox to a value (resize in y direction on top)
 
void TCurlyLine::SetBBoxY1(const Int_t y)
{
   if (fY2 > fY1)
      SetEndPoint(fX2, GetYCoord(y));
   else
      SetStartPoint(fX1, GetYCoord(y));
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set bottom of BoundingBox to a value
/// (resize in y direction on bottom)
 
void TCurlyLine::SetBBoxY2(const Int_t y)
{
   if (fY2 > fY1)
      SetStartPoint(fX1, GetYCoord(y));
   else
      SetEndPoint(fX2, GetYCoord(y));
}