```// @(#)root/graf:\$Id: TGraphPolar.cxx 21371 2007-12-14 09:17:21Z rdm \$
// Author: Sebastian Boser, Mathieu Demaret 02/02/06

/*************************************************************************
* 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.             *
*************************************************************************/

//______________________________________________________________________________
/* Begin_Html
<center><h2>TGraphPolar : to draw a polar graph</h2></center>
TGraphPolar creates a polar graph (including error bars). A TGraphPolar is
a TGraphErrors represented in polar coordinates.
It uses the class TGraphPolargram to draw the polar axis.
<p>
Example:
End_Html
Begin_Macro(source)
{
TCanvas * CPol = new TCanvas("CPol","TGraphPolar Examples",500,500);

Double_t rmin=0;
Double_t rmax=TMath::Pi()*2;
Double_t r[1000];
Double_t theta[1000];

TF1 * fp1 = new TF1("fplot","cos(x)",rmin,rmax);
for (Int_t ipt = 0; ipt < 1000; ipt++) {
r[ipt] = ipt*(rmax-rmin)/1000+rmin;
theta[ipt] = fp1->Eval(r[ipt]);
}
TGraphPolar * grP1 = new TGraphPolar(1000,r,theta);
grP1->SetLineColor(2);
grP1->Draw("AOL");

return CPol;
}
End_Macro */

#include "TGaxis.h"
#include "TGraphPolar.h"
#include "THLimitsFinder.h"
#include "TPaveText.h"
#include "TStyle.h"
#include "TVirtualPad.h"
#include "TROOT.h"
#include "TLatex.h"
#include "TEllipse.h"
#include "TH1.h"
#include "TMath.h"
#include "Riostream.h"

ClassImp(TGraphPolar);

//______________________________________________________________________________
TGraphPolar::TGraphPolar() : TGraphErrors()
{
// TGraphPolar default constructor.
fXpol       = 0;
fYpol       = 0;
fPolargram  = 0;
fOptionAxis = kFALSE;
}

//______________________________________________________________________________
TGraphPolar::TGraphPolar(Int_t n, const Double_t* r, const Double_t* theta,
const Double_t *er, const Double_t* etheta)
: TGraphErrors(n,r,theta,er,etheta)
{
// TGraphPolar constructor.
//
// n      : number of points.
// r      : radial values.
// theta  : angular values.
// er     : errors on radial values.
// etheta : errors on angular values.

fXpol       = 0;
fYpol       = 0;
fPolargram  = 0;
fOptionAxis = kFALSE;
SetEditable(kFALSE);
}

//______________________________________________________________________________
TGraphPolar::~TGraphPolar()

{
// TGraphPolar destructor.

if (fXpol) delete fXpol;
if (fYpol) delete fYpol;
}

//______________________________________________________________________________
Int_t TGraphPolar::DistancetoPrimitive(Int_t px, Int_t py)

{
// Return the distance in pixel between the GraphPolar and (px,py).

// Swap Polar and orthognal coordinates.
Double_t* xold = fX; fX = fXpol;
Double_t* yold = fY; fY = fYpol;

// Now get proper distance.
Int_t dist = TGraphErrors::DistancetoPrimitive(px,py);

// Swap back.
fX = xold;
fY = yold;
return dist;
}

//______________________________________________________________________________
void TGraphPolar::Draw(Option_t* options)

{
// Draw TGraphPolar.

// Process options
TString opt = options;
opt.ToUpper();

// Ignore same
opt.ReplaceAll("SAME","");

// ReDraw polargram if required by options
if (opt.Contains("A")) fOptionAxis = kTRUE;
opt.ReplaceAll("A","");

AppendPad(opt);
}

//______________________________________________________________________________
void TGraphPolar::ExecuteEvent(Int_t /*event*/, Int_t /*px*/, Int_t /*py*/)

{
//Indicate that there is something to click here

gPad->SetCursor(kHand);
}

//______________________________________________________________________________
void TGraphPolar::Paint(Option_t* options)

{
// Paint TGraphPolar.
//
// "options" can have the following values:
//    - "O" Polar labels are paint orthogonally to the polargram radius.
//    - "P" Polymarker are paint at each point position.
//    - "E" Paint error bars.
//    - "F" Paint fill area (closed polygon).
//    - "A" Force axis redrawing even if a polargram already exists.
//    - "N" Disable the display of the polar labels.

Int_t ipt, i;
Double_t rwrmin, rwrmax, rwtmin, rwtmax;
if (fNpoints<1) return;
TString opt = options;
opt.ToUpper();

Bool_t nolabel = kFALSE;
if(opt.Contains("N")){
nolabel = kTRUE;
opt.ReplaceAll("N","");
}

// Check for existing TGraphPolargram in the Pad
if (gPad) {
// Existing polargram
if (fPolargram)
if (!gPad->FindObject(fPolargram->GetName())) fPolargram=0;
if (!fPolargram) {
// Find any other Polargram in the Pad
TListIter padObjIter(gPad->GetListOfPrimitives());
while (TObject* AnyObj = padObjIter.Next()) {
if (TString(AnyObj->ClassName()).CompareTo("TGraphPolargram",
TString::kExact)==0)
fPolargram = (TGraphPolargram*)AnyObj;
}
}
}

// Get new polargram range if necessary.
if (!fPolargram) {

// Get range, initialize with first/last value
rwrmin = fY[0]; rwrmax = fY[fNpoints-1];
rwtmin = fX[0]; rwtmax = fX[fNpoints-1];

for (ipt = 0; ipt < fNpoints; ipt++) {
// Check for errors if available
if (fEX) {
if (fX[ipt] -fEX[ipt] < rwtmin) rwtmin = fX[ipt]-fEX[ipt];
if (fX[ipt] +fEX[ipt] > rwtmax) rwtmax = fX[ipt]+fEX[ipt];
} else {
if (fX[ipt] < rwtmin) rwtmin=fX[ipt];
if (fX[ipt] > rwtmax) rwtmax=fX[ipt];
}
if (fEY) {
if (fY[ipt] -fEY[ipt] < rwrmin) rwrmin = fY[ipt]-fEY[ipt];
if (fY[ipt] +fEY[ipt] > rwrmax) rwrmax = fY[ipt]+fEY[ipt];
} else {
if (fY[ipt] < rwrmin) rwrmin=fY[ipt];
if (fY[ipt] > rwrmax) rwrmax=fY[ipt];
}
}

// Add radial and Polar margins.
if (rwrmin == rwrmax) rwrmax += 1.;
if (rwtmin == rwtmax) rwtmax += 1.;
Double_t dr = (rwrmax-rwrmin);
Double_t dt = (rwtmax-rwtmin);
rwrmax += 0.1*dr;
rwrmin -= 0.1*dr;

// Assume equaly spaced points for full 2*Pi.
rwtmax += dt/fNpoints;
} else {
rwrmin = fPolargram->GetRMin();
rwrmax = fPolargram->GetRMax();
rwtmin = fPolargram->GetTMin();
rwtmax = fPolargram->GetTMax();
}

if ((!fPolargram)||fOptionAxis) {
// Draw Polar coord system
fPolargram = new TGraphPolargram("Polargram",rwrmin,rwrmax,rwtmin,rwtmax);
if (opt.Contains("O")) fPolargram->SetBit(TGraphPolargram::kLabelOrtho);
else fPolargram->ResetBit(TGraphPolargram::kLabelOrtho);
if(nolabel) fPolargram->Draw("N");
else fPolargram->Draw("");
fOptionAxis = kFALSE;   //Prevent redrawing
}

// Convert points to polar.
if (fXpol) delete fXpol;
if (fYpol) delete fYpol;
fXpol = new Double_t[fNpoints];
fYpol = new Double_t[fNpoints];

// Project theta in [0,2*Pi] and radius in [0,1].
Double_t radiusNDC = rwrmax-rwrmin;
Double_t thetaNDC  = (rwtmax-rwtmin)/(2*TMath::Pi());

// Draw the error bars.
// Y errors are lines, but X errors are pieces of circles.
if (opt.Contains("E")) {
if (fEY) {
for (i=0; i<fNpoints; i++) {
Double_t eymin, eymax, exmin,exmax;
exmin = (fY[i]-fEY[i]-rwrmin)/radiusNDC*
TMath::Cos((fX[i]-rwtmin)/thetaNDC);
eymin = (fY[i]-fEY[i]-rwrmin)/radiusNDC*
TMath::Sin((fX[i]-rwtmin)/thetaNDC);
exmax = (fY[i]+fEY[i]-rwrmin)/radiusNDC*
TMath::Cos((fX[i]-rwtmin)/thetaNDC);
eymax = (fY[i]+fEY[i]-rwrmin)/radiusNDC*
TMath::Sin((fX[i]-rwtmin)/thetaNDC);
TAttLine::Modify();
gPad->PaintLine(exmin,eymin,exmax,eymax);
}
}
if (fEX) {
for (i=0; i<fNpoints; i++) {
Double_t rad = (fY[i]-rwrmin)/radiusNDC;
Double_t phimin = (fX[i]-fEX[i]-rwtmin)/thetaNDC*180/TMath::Pi();
Double_t phimax = (fX[i]+fEX[i]-rwtmin)/thetaNDC*180/TMath::Pi();
TAttLine::Modify();
fPolargram->PaintCircle(0,0,rad,phimin,phimax,0);
}
}
}

// Draw the graph itself.
if (!(gPad->GetLogx()) && !(gPad->GetLogy())) {
Double_t a, b, c=1, x1, x2, y1, y2, discr, norm1, norm2, xts, yts;
Bool_t previouspointin = kFALSE;
Double_t norm = 0;
Double_t xt   = 0;
Double_t yt   = 0 ;
Int_t j       = -1;
for (i=0; i<fNpoints; i++) {
if (fPolargram->fRadian) {c=1;}
if (fPolargram->fDegree) {c=180/TMath::Pi();}
if (fPolargram->fGrad) {c=100/TMath::Pi();}
xts  = xt;
yts  = yt;
xt   = (fY[i]-rwrmin)/radiusNDC*TMath::Cos(c*(fX[i]-rwtmin)/thetaNDC);
yt   = (fY[i]-rwrmin)/radiusNDC*TMath::Sin(c*(fX[i]-rwtmin)/thetaNDC);
norm = sqrt(xt*xt+yt*yt);
// Check if points are in the main circle.
if ( norm <= 1) {
// We check that the previous point was in the circle too.
// We record new point position.
if (!previouspointin) {
j++;
fXpol[j] = xt;
fYpol[j] = yt;
} else {
a = (yt-yts)/(xt-xts);
b = yts-a*xts;
discr = 4*(a*a-b*b+1);
x1 = (-2*a*b+sqrt(discr))/(2*(a*a+1));
x2 = (-2*a*b-sqrt(discr))/(2*(a*a+1));
y1 = a*x1+b;
y2 = a*x2+b;
norm1 = sqrt((x1-xt)*(x1-xt)+(y1-yt)*(y1-yt));
norm2 = sqrt((x2-xt)*(x2-xt)+(y2-yt)*(y2-yt));
previouspointin = kFALSE;
j = 0;
if (norm1 < norm2) {
fXpol[j] = x1;
fYpol[j] = y1;
} else {
fXpol[j] = x2;
fYpol[j] = y2;
}
j++;
fXpol[j] = xt;
fYpol[j] = yt;
TGraph::PaintGraph(j+1, fXpol, fYpol, opt);
}
} else {
// We check that the previous point was in the circle.
// We record new point position
if (j>=1 && !previouspointin) {
a = (yt-fYpol[j])/(xt-fXpol[j]);
b = fYpol[j]-a*fXpol[j];
previouspointin = kTRUE;
discr = 4*(a*a-b*b+1);
x1 = (-2*a*b+sqrt(discr))/(2*(a*a+1));
x2 = (-2*a*b-sqrt(discr))/(2*(a*a+1));
y1 = a*x1+b;
y2 = a*x2+b;
norm1 = sqrt((x1-xt)*(x1-xt)+(y1-yt)*(y1-yt));
norm2 = sqrt((x2-xt)*(x2-xt)+(y2-yt)*(y2-yt));
j++;
if (norm1 < norm2) {
fXpol[j] = x1;
fYpol[j] = y1;
} else {
fXpol[j] = x2;
fYpol[j] = y2;
}
TGraph::PaintGraph(j+1, fXpol, fYpol, opt);
}
j=-1;
}
}
if (j>=1) {
// If the last point is in the circle, we draw the last serie of point.
TGraph::PaintGraph(j+1, fXpol, fYpol, opt);
}
} else {
for (i=0; i<fNpoints; i++) {
fXpol[i] = TMath::Abs((fY[i]-rwrmin)/radiusNDC*TMath::Cos((fX[i]-rwtmin)/thetaNDC)+1);
fYpol[i] = TMath::Abs((fY[i]-rwrmin)/radiusNDC*TMath::Sin((fX[i]-rwtmin)/thetaNDC)+1);
}
TGraph::PaintGraph(fNpoints, fXpol, fYpol,opt);
}
PaintTitle();
}

//______________________________________________________________________________
void TGraphPolar::PaintTitle()

{
// Paint the title.

if (TestBit(TH1::kNoTitle)) return;
Int_t nt = strlen(GetTitle());
TPaveText *title = 0;
TObject *obj;
TIter next(gPad->GetListOfPrimitives());
while ((obj = next())) {
if (!obj->InheritsFrom(TPaveText::Class())) continue;
title = (TPaveText*)obj;
if (strcmp(title->GetName(),"title")) {title = 0; continue;}
break;
}
if (nt == 0 || gStyle->GetOptTitle() <= 0) {
if (title) delete title;
return;
}
Double_t ht = gStyle->GetTitleH();
Double_t wt = gStyle->GetTitleW();
if (ht <= 0) ht = 1.1*gStyle->GetTitleFontSize();
if (ht <= 0) ht = 0.05;
if (wt <= 0) {
TLatex l;
l.SetTextSize(ht);
l.SetTitle(GetTitle());
// Adjustment in case the title has several lines (#splitline)
ht = TMath::Max(ht, 1.2*l.GetYsize()/(gPad->GetY2() - gPad->GetY1()));
Double_t wndc = l.GetXsize()/(gPad->GetX2() - gPad->GetX1());
wt = TMath::Min(0.7, 0.02+wndc);
}
if (title) {
TText *t0 = (TText*)title->GetLine(0);
if (t0) {
if (!strcmp(t0->GetTitle(),GetTitle())) return;
t0->SetTitle(GetTitle());
if (wt > 0) title->SetX2NDC(title->GetX1NDC()+wt);
}
return;
}

Int_t talh = gStyle->GetTitleAlign()/10;
if (talh < 1) talh = 1; if (talh > 3) talh = 3;
Int_t talv = gStyle->GetTitleAlign()%10;
if (talv < 1) talv = 1; if (talv > 3) talv = 3;

Double_t xpos, ypos;
xpos = gStyle->GetTitleX();
ypos = gStyle->GetTitleY();

if (talh == 2) xpos = xpos-wt/2.;
if (talh == 3) xpos = xpos-wt;
if (talv == 2) ypos = ypos+ht/2.;
if (talv == 1) ypos = ypos+ht;

TPaveText *ptitle = new TPaveText(xpos, ypos-ht, xpos+wt, ypos,"blNDC");

// Box with the histogram title.
ptitle->SetFillColor(gStyle->GetTitleFillColor());
ptitle->SetFillStyle(gStyle->GetTitleStyle());
ptitle->SetName("title");
ptitle->SetBorderSize(gStyle->GetTitleBorderSize());
ptitle->SetTextColor(gStyle->GetTitleTextColor());
ptitle->SetTextFont(gStyle->GetTitleFont(""));
if (gStyle->GetTitleFont("")%10 > 2)
ptitle->SetTextSize(gStyle->GetTitleFontSize());
ptitle->AddText(GetTitle());
ptitle->SetBit(kCanDelete);
ptitle->Draw();
ptitle->Paint();
}

//______________________________________________________________________________
void TGraphPolar::SetMaxPolar(Double_t maximum)
{
// Set maximum Polar.

if (fPolargram) fPolargram->ChangeRangePolar(fPolargram->GetTMin(),maximum);
}

//______________________________________________________________________________
void TGraphPolar::SetMaxRadial(Double_t maximum)
{
// Set maximum radial at the intersection of the positive X axis part and
// the circle.

if (fPolargram) fPolargram->SetRangeRadial(fPolargram->GetRMin(),maximum);
}

//______________________________________________________________________________
void TGraphPolar::SetMinPolar(Double_t minimum)
{
// Set minimum Polar.

if (fPolargram) fPolargram->ChangeRangePolar(minimum, fPolargram->GetTMax());
}

//______________________________________________________________________________
void TGraphPolar::SetMinRadial(Double_t minimum)
{
// Set minimum radial in the center of the circle.

if (fPolargram) fPolargram->SetRangeRadial(minimum, fPolargram->GetRMax());
}

ClassImp(TGraphPolargram);

//______________________________________________________________________________

//______________________________________________________________________________
TGraphPolargram::TGraphPolargram(const char* name, Double_t rmin, Double_t rmax,
Double_t tmin, Double_t tmax):
TNamed(name,"Polargram")
{
// TGraphPolargram Constructor.
Init();
fNdivRad          = 508;
fNdivPol          = 508;
fPolarLabels      = NULL;
fRwrmax           = rmax;
fRwrmin           = rmin;
fRwtmin           = tmin;
fRwtmax           = tmax;
}

//______________________________________________________________________________
TGraphPolargram::TGraphPolargram(const char* name):
TNamed(name,"Polargram")
{
// Short constructor used in the case of a spider plot.

Init();
fNdivRad          = 0;
fNdivPol          = 0;
fPolarLabels      = NULL;
fRwrmax           = 1;
fRwrmin           = 0;
}

//______________________________________________________________________________
TGraphPolargram::~TGraphPolargram()
{
// TGraphPolargram destructor.
if (fPolarLabels != NULL)
delete [] fPolarLabels;
}

//______________________________________________________________________________
void TGraphPolargram::ChangeRangePolar(Double_t tmin, Double_t tmax)
{
// Set the Polar range.
// tmin is the start number.
// tmax is the end number.

if (tmin < tmax) {
fRwtmin = tmin;
fRwtmax = tmax;
}
if (gPad) gPad->Modified();
}

//______________________________________________________________________________
Int_t TGraphPolargram::DistancetoPrimitive(Int_t px, Int_t py)
{
// Everything within the circle belongs to the TGraphPolargram.

Int_t i;
Double_t x = gPad->AbsPixeltoX(px);
Double_t y = gPad->AbsPixeltoY(py);

// Check if close to a (major) radial line.
Double_t rad = TMath::Sqrt(x*x+y*y);
Int_t div    = (Int_t)rad*(fNdivRad%100);
Double_t dr  = TMath::Min(TMath::Abs(rad-div*1./(fNdivRad%100)),
TMath::Abs(rad-(div+1)*1./(fNdivRad%100)));
Int_t drad   = gPad->XtoPixel(dr)-gPad->XtoPixel(0);

// Check if close to a (major) Polar line.
// This is not a proper calculation, but rather fast.
Int_t dt = kMaxPixel;
for (i=0; i<(fNdivPol%100); i++) {
Double_t theta = i*2*TMath::Pi()/(fNdivPol%100);

// Attention: px,py in pixel units, line given in user coordinates.
Int_t dthis = DistancetoLine(px,py,0.,0.,TMath::Cos(theta),
TMath::Sin(theta));

// Fails if we are outside box discribed by the line.
// (i.e for all hor/vert lines)
if (dthis==9999) {

// Outside -> Get distance to endpoint of line.
if (rad>1) {
dthis = (Int_t)TMath::Sqrt(
TMath::Power(px-gPad->XtoPixel(TMath::Cos(theta)),2)+
TMath::Power(py-gPad->YtoPixel(TMath::Sin(theta)),2));
} else {

// Check for horizontal line.
if (((TMath::Abs(theta-TMath::Pi())<0.1) &&
((px-gPad->XtoPixel(0))<0))          ||
((TMath::Abs(theta)<0.1)             &&
((px-gPad->XtoPixel(0))>0))) {
dthis = TMath::Abs(py-gPad->YtoPixel(0.));
}

//Check for vertical line.
if (((TMath::Abs(theta-TMath::PiOver2())<0.1)   &&
((py-gPad->YtoPixel(0))>0))                 ||
((TMath::Abs(theta-3*TMath::PiOver2())<0.1) &&
(py-gPad->YtoPixel(0))<0)) {
dthis = TMath::Abs(px-gPad->XtoPixel(0.));
}
if (dthis==9999) {

// Inside, but out of box for nonorthogonal line ->
// get distance to start point.
dthis = (Int_t)TMath::Sqrt(
TMath::Power(px-gPad->XtoPixel(0.),2)+
TMath::Power(py-gPad->YtoPixel(0.),2));
}
}
}

// Take distance to closes line.
dt = TMath::Min(dthis,dt);
}
return TMath::Min(drad, dt);
}

//______________________________________________________________________________
void TGraphPolargram::Draw(Option_t* options)
{
// Draw Polargram.

Paint(options);
AppendPad(options);
}

//______________________________________________________________________________
void TGraphPolargram::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
// Indicate that there is something to click here.

Int_t kMaxDiff = 20;
static Int_t d1, d2, d3, px1, py1, px3, py3, px4, py4;
static Bool_t p1, p2, p3, p4, p5, p6, p7, p8;
Double_t px2, py2;
p2 = p3 = p4 = p5 = p6 = p7 = p8 = kFALSE;
if (!gPad->IsEditable()) return;
switch (event) {
case kMouseMotion:
px1 = gPad->XtoAbsPixel(TMath::Cos(GetAngle()));
py1 = gPad->YtoAbsPixel(TMath::Sin(GetAngle()));
d1  = TMath::Abs(px1 - px) + TMath::Abs(py1-py); //simply take sum of pixels differences
p1  = kFALSE;
px2 = gPad->XtoAbsPixel(-1);
py2 = gPad->YtoAbsPixel(1);
d2  = (Int_t)(TMath::Abs(px2 - px) + TMath::Abs(py2 - py)) ;
px3 = gPad->XtoAbsPixel(-1);
py3 = gPad->YtoAbsPixel(-1);
d3  = TMath::Abs(px3 - px) + TMath::Abs(py3 - py) ; //simply take sum of pixels differences
// check if point is close to the radial axis
if (d1 < kMaxDiff) {
gPad->SetCursor(kMove);
p1 = kTRUE;
}
// check if point is close to the left high axis
if ( d2 < kMaxDiff) {
gPad->SetCursor(kHand);
p7 = kTRUE;
}
// check if point is close to the left down axis
if ( d3 < kMaxDiff) {
gPad->SetCursor(kHand);
p8 = kTRUE;
}
// check if point is close to a main circle
if (!p1 && !p7 ) {
p6 = kTRUE;
gPad->SetCursor(kHand);
}
break;

case kButton1Down:
// Record initial coordinates
px4 = px;
py4 = py;

case kButton1Motion:
if (p1) {
px2 = gPad->AbsPixeltoX(px);
py2 = gPad->AbsPixeltoY(py);
if ( px2 < 0 && py2 < 0)  {p2 = kTRUE;};
if ( px2 < 0 && py2 > 0 ) {p3 = kTRUE;};
if ( px2 > 0 && py2 > 0 ) {p4 = kTRUE;};
if ( px2 > 0 && py2 < 0 ) {p5 = kTRUE;};
px2 = TMath::ACos(TMath::Abs(px2));
py2 = TMath::ASin(TMath::Abs(py2));
if (p2) {
fAxisAngle = TMath::Pi()+(px2+py2)/2;
p2 = kFALSE;
};
if (p3) {
fAxisAngle = TMath::Pi()-(px2+py2)/2;
p3 = kFALSE;
};
if (p4) {
fAxisAngle = (px2+py2)/2;
p4 = kFALSE;
};
if (p5) {
fAxisAngle = -(px2+py2)/2;
p5 = kFALSE;
};
}
break;

case kButton1Up:
Paint();
}
}

//______________________________________________________________________________
Int_t TGraphPolargram::FindAlign(Double_t angle)
{
// Find the alignement rule to apply for TText::SetTextAlign(Short_t).

Double_t pi = TMath::Pi();

while(angle < 0 || angle > 2*pi){
if(angle < 0) angle+=2*pi;
if(angle > 2*pi) angle-=2*pi;
}
if(!TestBit(TGraphPolargram::kLabelOrtho)){
if(angle > 0 && angle < pi/2) return 11;
else if(angle > pi/2 && angle < pi) return 31;
else if(angle > pi && angle < 3*pi/2) return 33;
else if(angle > 3*pi/2 && angle < 2*pi) return 13;
else if(angle == 0 || angle == 2*pi) return 12;
else if(angle == pi/2) return 21;
else if(angle == pi) return 32;
else if(angle == 3*pi/2) return 23;
else return 0;
}
else{
if(angle >= 0 && angle <= pi/2) return 12;
else if((angle > pi/2 && angle <= pi) || (angle > pi && angle <= 3*pi/2)) return 32;
else if(angle > 3*pi/2 && angle <= 2*pi) return 12;
else return 0;
}
}

//______________________________________________________________________________
Double_t TGraphPolargram::FindTextAngle(Double_t angle)
{
// Determine the orientation of the polar labels according to their angle.

Double_t pi = TMath::Pi();
Double_t convraddeg = 180.0/pi;

while(angle < 0 || angle > 2*pi){
if(angle < 0) angle+=2*pi;
if(angle > 2*pi) angle-=2*pi;
}

if(angle >= 0 && angle <= pi/2) return angle*convraddeg;
else if(angle > pi/2 && angle <= pi) return (angle + pi)*convraddeg;
else if(angle > pi && angle <= 3*pi/2) return (angle - pi)*convraddeg;
else if(angle > 3*pi/2 && angle <= 2*pi) return angle*convraddeg;
else return 0;
}

//______________________________________________________________________________
void TGraphPolargram::Init()
{
// Initiallize some of the fields of TGraphPolargram.

fAxisAngle        = 0;
fCutRadial        = 0;
fDegree           = kFALSE;
fGrad             = kFALSE;
fLineStyle        = 3;
fPolarLabelColor  = 1;
fPolarLabelFont   = 62;
fPolarOffset      = 0.04;
fPolarTextSize    = 0.04;
fRadialOffset     = 0.025;
fRadian           = kTRUE;
fRadialLabelColor = 1;
fRadialLabelFont  = 62;
fRadialTextSize   = 0.035;
fTickpolarSize    = 0.02;
}

//______________________________________________________________________________
void TGraphPolargram::Paint(Option_t * chopt)
{
// Paint TGraphPolargram.

Int_t optionpoldiv, optionraddiv;
Bool_t optionLabels = kTRUE;

TString opt = chopt;
opt.ToUpper();

if(opt.Contains('P')) optionpoldiv=1; else optionpoldiv=0;
if(opt.Contains('R')) optionraddiv=1; else optionraddiv=0;
if(opt.Contains('O')) SetBit(TGraphPolargram::kLabelOrtho);
else ResetBit(TGraphPolargram::kLabelOrtho);
if(!opt.Contains('P') && !opt.Contains('R')) optionpoldiv=optionraddiv=1;
if(opt.Contains('N')) optionLabels = kFALSE;

if(optionraddiv) PaintRadialDivisions(kTRUE);
else PaintRadialDivisions(kFALSE);
if(optionpoldiv) PaintPolarDivisions(optionLabels);
}

//______________________________________________________________________________
void TGraphPolargram::PaintCircle(Double_t x1, Double_t y1, Double_t r,
Double_t phimin, Double_t phimax, Double_t theta)
{
// This is simplifed from TEllipse::PaintEllipse.
// Draw this ellipse with new coordinates.

Int_t i;
const Int_t np = 200; // Number of point to draw circle
static Double_t x[np+3], y[np+3];

// Set number of points approximatively proportional to the ellipse
// circumference.

Double_t circ = TMath::Pi()*2*r*(phimax-phimin)/36;
Int_t n = (Int_t)(np*circ/((gPad->GetX2()-gPad->GetX1())+
(gPad->GetY2()-gPad->GetY1())));
if (n < 8) n  = 8;
if (n > np) n = np;
Double_t angle,dx,dy;
Double_t dphi = (phimax-phimin)*TMath::Pi()/(180*n);
Double_t ct   = TMath::Cos(TMath::Pi()*theta/180);
Double_t st   = TMath::Sin(TMath::Pi()*theta/180);
for (i=0; i<=n; i++) {
angle = phimin*TMath::Pi()/180 + Double_t(i)*dphi;
dx    = r*TMath::Cos(angle);
dy    = r*TMath::Sin(angle);
x[i]  =  x1 + dx*ct - dy*st;
y[i]  =  y1 + dx*st + dy*ct;
}
gPad->PaintPolyLine(n+1,x,y);
}

//______________________________________________________________________________
void TGraphPolargram::PaintPolarDivisions(Bool_t optionLabels)
{
// Draw Polar divisions.
// Check for editable pad or create default.

Int_t i, j, rnum, rden, first, last;
if (!gPad) return ;
if (!gPad->IsEditable()) gROOT->MakeDefCanvas();

gPad->RangeAxis(-1,-1,1,1);
gPad->Range(-1.25,-1.25,1.25,1.25);
Int_t ndivMajor = fNdivPol%100;
Int_t ndivMinor = fNdivPol/100;

if (!gPad->GetLogy()) {
for (i=0; i<ndivMajor; i++) {
Double_t txtval    = fRwtmin + i*(fRwtmax-fRwtmin)/ndivMajor;
Double_t theta     = i*2*TMath::Pi()/ndivMajor;
Double_t costheta  = TMath::Cos(theta);
Double_t sintheta  = TMath::Sin(theta);
Double_t tantheta  = TMath::Tan(theta);
Double_t costhetas = (1+fPolarOffset)*costheta;
Double_t sinthetas = (1+fPolarOffset)*sintheta;
Double_t corr = 0.01;

TLatex *textangular = new TLatex();
textangular->SetTextColor(GetPolarColorLabel());
textangular->SetTextFont(GetPolarLabelFont());

const char* form = (char *)" ";
TGaxis axis;
if (TestBit(TGraphPolargram::kLabelOrtho)) {
// Polar numbers are aligned with their axis.
if(fPolarLabels == NULL && optionLabels){;
if (fRadian) {
// Radian case.
ReduceFraction(2*i, ndivMajor, rnum, rden); // Reduces the fraction.
if (rnum == 0)                       form = Form("%d",rnum);
if (rnum == 1 && rden == 1)          form = Form("#pi");
if (rnum == 1 && rden != 1)          form = Form("#frac{#pi}{%d}",rden);
if (rnum != 1 && rden == 1 && i !=0) form= Form("%d#pi",rnum);
if (rnum != 1 && rden != 1)          form = Form("#frac{%d#pi}{%d}",rnum,rden);
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas,
sinthetas, FindTextAngle(theta),
GetPolarLabelSize(), form);
} else {
// Any other cases: numbers are aligned with their axis.
form = Form("%5.3g",txtval);
axis.LabelsLimits(form,first,last);
TString s = Form("%s",form);
if (first != 0) s.Remove(0, first);
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas,
sinthetas, FindTextAngle(theta),
GetPolarLabelSize(), s);
}
} else if (fPolarLabels){
// print the specified polar labels
TLatex *textangular = new TLatex();
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas,sinthetas,FindTextAngle(theta),
GetPolarLabelSize(), fPolarLabels[i]);
}
} else {
// Polar numbers are shown horizontaly.
if(fPolarLabels == NULL && optionLabels){
if (fRadian) {
// Radian case
ReduceFraction(2*i, ndivMajor, rnum, rden);
if (rnum == 0) form = Form("%d",rnum);
if (rnum == 1 && rden == 1)          form = Form("#pi");
if (rnum == 1 && rden != 1)          form = Form("#frac{#pi}{%d}",rden);
if (rnum != 1 && rden == 1 && i !=0) form = Form("%d#pi",rnum);
if (rnum != 1 && rden != 1)          form = Form("#frac{%d#pi}{%d}",rnum,rden);
if(theta >= 3*TMath::Pi()/12.0 && theta < 2*TMath::Pi()/3.0) corr=0.04;
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas,corr+sinthetas,0,
GetPolarLabelSize(),form);
} else {
// Any other cases where numbers are shown horizontaly.
form = Form("%5.3g",txtval);
axis.LabelsLimits(form,first,last);
TString s = Form("%s",form);
if (first != 0) s.Remove(0, first);
if(theta >= 3*TMath::Pi()/12.0 && theta < 2*TMath::Pi()/3.0) corr=0.04;
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas, //j'ai efface des offset la
corr+sinthetas,0,GetPolarLabelSize(),s);
}
} else if (fPolarLabels) {
// print the specified polar labels
TLatex *textangular = new TLatex();
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintText(costhetas,sinthetas,fPolarLabels[i]);
}
}
TAttLine::Modify();
//Check if SetTickpolar is actived, and draw Tickmarcks
Bool_t issettickpolar = gPad->GetTicky();

if (issettickpolar) {
if (theta != 0 && theta !=TMath::Pi()) {
gPad->PaintLine((sintheta-GetTickpolarSize())/tantheta,sintheta-GetTickpolarSize(),
(sintheta+GetTickpolarSize())/tantheta,sintheta+GetTickpolarSize());
}
if (theta == 0 || theta ==TMath::Pi()) {
gPad->PaintLine(1-GetTickpolarSize(),0,1+GetTickpolarSize(),0);
gPad->PaintLine(-1+GetTickpolarSize(),0,-1-GetTickpolarSize(),0);
}
}
TAttLine::SetLineStyle(1);
TAttLine::Modify();
gPad->PaintLine(0.,0.,costheta,sintheta);
delete textangular;
// Add minor lines w/o text.
Int_t oldLineStyle = GetLineStyle();
TAttLine::SetLineStyle(2);  //Minor lines always in this style.
TAttLine::Modify();  //Changes line attributes apart from style.
for (j=1; j<ndivMinor; j++) {
Double_t thetamin = theta+j*2*TMath::Pi()/(ndivMajor*ndivMinor);
gPad->PaintLine(0.,0.,TMath::Cos(thetamin),TMath::Sin(thetamin));
}
TAttLine::SetLineStyle(oldLineStyle);
TAttLine::Modify();
}
} else {
Int_t big = (Int_t)fRwtmax;
Int_t test= 1;
while (big >= 10) {
big = big/10;
test++;
}
for (i=1; i<=test; i++) {
Double_t txtval    = pow((double)10,(double)(i-1));
Double_t theta     = (i-1)*2*TMath::Pi()/(double)(test);
Double_t costheta  = TMath::Cos(theta);
Double_t sintheta  = TMath::Sin(theta);
Double_t tantheta  = TMath::Tan(theta);
Double_t costhetas = (1+fPolarOffset)*costheta;
Double_t sinthetas = (1+fPolarOffset)*sintheta;
Double_t corr      = 0.01;

TLatex *textangular = new TLatex();
textangular->SetTextColor(GetPolarColorLabel());
textangular->SetTextFont(GetPolarLabelFont());

const char* form = (char *)" ";
TGaxis axis;

if (TestBit(TGraphPolargram::kLabelOrtho)) {
if(fPolarLabels==NULL && optionLabels){
// Polar numbers are aligned with their axis.
form = Form("%5.3g",txtval);
axis.LabelsLimits(form,first,last);
TString s = Form("%s",form);
if (first != 0) s.Remove(0, first);
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas,
sinthetas, FindTextAngle(theta), GetPolarLabelSize(), s);
}
else if (fPolarLabels){
// print the specified polar labels
TLatex *textangular = new TLatex();
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintText(costhetas,sinthetas,fPolarLabels[i]);
}

} else {
if(fPolarLabels==NULL && optionLabels){
// Polar numbers are shown horizontaly.
cout<<"ici"<<endl;
form = Form("%5.3g",txtval);
axis.LabelsLimits(form,first,last);
TString s = Form("%s",form);
if (first != 0) s.Remove(0, first);
if(theta >= 3*TMath::Pi()/12.0 && theta < 2*TMath::Pi()/3.0) corr=0.04;
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintLatex(costhetas,
corr+sinthetas,0,GetPolarLabelSize(),s);
} else if (fPolarLabels){
// print the specified polar labels
TLatex *textangular = new TLatex();
textangular->SetTextAlign(FindAlign(theta));
textangular->PaintText(costhetas,sinthetas,fPolarLabels[i]);
}
}

TAttLine::Modify();
//Check if SetTickpolar is actived, and draw Tickmarcks
Bool_t issettickpolar = gPad->GetTicky();
if (issettickpolar) {
if (theta != 0 && theta !=TMath::Pi()) {
gPad->PaintLine((sintheta-GetTickpolarSize())/tantheta,sintheta-GetTickpolarSize(),
(sintheta+GetTickpolarSize())/tantheta,sintheta+GetTickpolarSize());
}
if (theta == 0 || theta ==TMath::Pi()) {
gPad->PaintLine(1-GetTickpolarSize(),0,1+GetTickpolarSize(),0);
gPad->PaintLine(-1+GetTickpolarSize(),0,-1-GetTickpolarSize(),0);
}
}
TAttLine::SetLineStyle(1);
TAttLine::Modify();
gPad->PaintLine(0.,0.,costheta,sintheta);
delete textangular;
// Add minor lines w/o text.
Int_t oldLineStyle = GetLineStyle();
TAttLine::SetLineStyle(2);  //Minor lines always in this style.
TAttLine::Modify();  //Changes line attributes apart from style.
Double_t a=0;
Double_t b,c,d;
b = TMath::Log(10)*test;
d= 2*TMath::Pi()/(double)test;
for (j=1; j<9; j++) {
a=TMath::Log(j+1)-TMath::Log(j)+a;
c=a/b*6.28+d*(i-1);
gPad->PaintLine(0.,0.,TMath::Cos(c),TMath::Sin(c));
}
TAttLine::SetLineStyle(oldLineStyle);
TAttLine::Modify();
}
}
}

//______________________________________________________________________________
void TGraphPolargram::PaintRadialDivisions(Bool_t drawaxis)
{
// Paint radial divisions.
// Check for editable pad or create default.

static char chopt[8] = "";
Int_t i,j;
Int_t ndiv      = TMath::Abs(fNdivRad);
Int_t ndivMajor = ndiv%100;
Int_t ndivMinor = ndiv/100;
Int_t ndivmajor;
Double_t frwrmin, frwrmax, binWidth = 0;

THLimitsFinder::Optimize(fRwrmin,fRwrmax,ndivMajor,frwrmin,
frwrmax, ndivmajor,binWidth,"");

if (!gPad) return ;
if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
if (!gPad->GetLogx()) {
gPad->RangeAxis(-1,-1,1,1);
gPad->Range(-1.25,-1.25,1.25,1.25);
Double_t umin  = fRwrmin;
Double_t umax  = fRwrmax;
Double_t rmajmin  = (frwrmin-fRwrmin)/(fRwrmax-fRwrmin);
Double_t rmajmax  = (frwrmax-fRwrmin)/(fRwrmax-fRwrmin);
Double_t dist  = (rmajmax-rmajmin)/ndivmajor;
Int_t ndivminor;

chopt[0] = 0;
strcat(chopt, "SDH");
if (fNdivRad < 0) strcat(chopt, "N");
if(drawaxis){
// Paint axis.
TGaxis axis;
axis.SetLabelSize(GetRadialLabelSize());
axis.SetLabelColor(GetRadialColorLabel());
axis.SetLabelFont(GetRadialLabelFont());
axis.SetLabelOffset(GetRadialOffset());
axis.PaintAxis(0, 0, TMath::Cos(GetAngle()), TMath::Sin(GetAngle()),
umin, umax,  ndiv, chopt, 0., kFALSE);
}

// Paint Circles.
// First paint main circle.
PaintCircle(0.,0.,1,0.,360,0);
// Optimised case.
if (fNdivRad>0 ) {
Double_t frwrmini, frwrmaxi, binWidth2 =0;
THLimitsFinder::Optimize(frwrmin,frwrmin+binWidth,ndivMinor,frwrmini,
frwrmaxi, ndivminor,binWidth2,"");
Double_t dist2 = dist/(ndivminor);
// Paint major circles.
for (i=1; i<=ndivmajor+2; i++) {
TAttLine::SetLineStyle(1);
TAttLine::Modify();
PaintCircle(0.,0.,rmajmin,0.,360,0);

//Paint minor circles.
TAttLine::SetLineStyle(2);
TAttLine::Modify();
for (j=1; j<ndivminor+1; j++) {
if (rmajmin+j*dist2<=1) PaintCircle(0.,0.,rmajmin+j*dist2,0.,360,0);
}
rmajmin = (frwrmin-fRwrmin)/(fRwrmax-fRwrmin)+(i-1)*dist;
}
// Non-optimized case.
} else {

// Paint major circles.
for (i=1; i<=ndivMajor; i++) {
TAttLine::SetLineStyle(1);
TAttLine::Modify();
Double_t rmaj = i*1./ndivMajor;
PaintCircle(0.,0.,rmaj,0.,360,0);

// Paint minor circles.
for (j=1; j<ndivMinor; j++) {
TAttLine::SetLineStyle(2);
TAttLine::Modify();
PaintCircle(0.,0.,rmaj- j*1./(ndivMajor*ndivMinor),0.,360,0);
}
}
}
} else {
// Draw Log scale on radial axis if option activated.
Int_t big = (Int_t)fRwrmax;
Int_t test= 0;
while (big >= 10) {
big = big/10;
test++;
}
for (i=1; i<=test; i++) {
TAttLine::SetLineStyle(1);
TAttLine::Modify();
Double_t ecart;
ecart = ((double) i)/ ((double) test);
PaintCircle(0.,0.,ecart,0,360,0);
TAttLine::SetLineStyle(GetLineStyle());
TAttLine::Modify();
Double_t a=0;
Double_t b,c,d;
b = TMath::Log(10)*test;
d = 1/(double)test;
for (j=1; j<9; j++) {
a = TMath::Log(j+1)-TMath::Log(j)+a;
c = a/b+d*(i-1);
PaintCircle(0,0.,c,0.,360,0);
}
}
}
TAttLine::SetLineStyle(1);
TAttLine::Modify();
}

//______________________________________________________________________________
void TGraphPolargram::ReduceFraction(Int_t num, Int_t den, Int_t &rnum, Int_t &rden)
{
// Reduce fractions.

Int_t a = 0;
Int_t b = 0;
Int_t i = 0;
Int_t j = 0;
a = den;
b = num;
if (b > a) {
j = b;
} else {
j = a;
}
for (i=j; i > 1; i--) {
if ((a % i == 0) && (b % i == 0)) {
a = a/i;
b = b/i;
}
}
rden = a;
rnum = b;
}

//______________________________________________________________________________
void TGraphPolargram::SetAxisAngle(Double_t angle)
{
// Set axis angle.

fAxisAngle = angle/180*TMath::Pi();
}

//______________________________________________________________________________
void TGraphPolargram::SetNdivPolar(Int_t ndiv)
{
// Set the number of Polar divisions: enter a number ij with 0<i<99
//                                                           0<j<99
// i sets the major Polar divisions.
// j sets the minor Polar divisions.

if (ndiv > 0)
fNdivPol = ndiv;
if (gPad) gPad->Modified();
}

//_____________________________________________________________________________
void TGraphPolargram::SetNdivRadial(Int_t ndiv)
{
// Set the number of radial divisions: enter a number ij with 0<i<99
//                                                            0<j<99
// i sets the major radial divisions.
// j sets the minor radial divisions.

fNdivRad = ndiv;
if (gPad) gPad->Modified();
}

//_____________________________________________________________________________
void TGraphPolargram::SetPolarLabel(Int_t div, const TString & label)
{
// Set some specified polar labels, used in the case of a spider plot.
if(fPolarLabels == NULL)
fPolarLabels = new TString[fNdivPol];
fPolarLabels[div]=label;
if (gPad) gPad->Modified();
}

//_____________________________________________________________________________
void TGraphPolargram::SetPolarLabelColor(Color_t tcolorangular )
{
// Set Polar labels color.

fPolarLabelColor = tcolorangular;
}

//______________________________________________________________________________
void TGraphPolargram::SetPolarLabelFont(Font_t tfontangular)
{

// Set Polar label font.

fPolarLabelFont = tfontangular;
}

//______________________________________________________________________________
void TGraphPolargram::SetPolarLabelSize(Double_t angularsize )
{
// Set angular labels size.

fPolarTextSize = angularsize;
}

//______________________________________________________________________________
void TGraphPolargram::SetPolarOffset(Double_t angularOffset)
{
// Set the labels offset.

fPolarOffset = angularOffset;
if (gPad) gPad->Modified();
}

//______________________________________________________________________________
void TGraphPolargram::SetRadialLabelColor(Color_t tcolorradial )
{
// Set radial labels color.

fRadialLabelColor = tcolorradial;
}

//______________________________________________________________________________
void TGraphPolargram::SetRadialLabelFont(Font_t tfontradial)
{
// Set radial label font.

fRadialLabelFont = tfontradial;
}

//______________________________________________________________________________
void TGraphPolargram::SetRadialLabelSize(Double_t radialsize )
{
// Set radial labels size.

fRadialTextSize = radialsize;
}

//______________________________________________________________________________
void TGraphPolargram::SetRadialOffset(Double_t radialOffset)
{
// Set the labels offset.

fRadialOffset = radialOffset;
if (gPad) gPad->Modified();
}

//______________________________________________________________________________
void TGraphPolargram::SetRangePolar(Double_t tmin, Double_t tmax)
{
// Allows to change range Polar.
// tmin is the start number.
// tmax is the end number.

fDegree = kFALSE;
fGrad   = kFALSE;
fRadian = kFALSE;

if (tmin < tmax) {
fRwtmin = tmin;
fRwtmax = tmax;
}
if (gPad) gPad->Modified();
}

//______________________________________________________________________________
void TGraphPolargram::SetRangeRadial(Double_t rmin, Double_t rmax)
{
// Set the radial range.
// rmin is at center of the circle.
// rmax is at the intersection of the right X axis part and the circle.

if (rmin < rmax) {
fRwrmin = rmin;
fRwrmax = rmax;
}
if (gPad) gPad->Modified();
}

//______________________________________________________________________________
void TGraphPolargram::SetTickpolarSize(Double_t tickpolarsize)
{
// Set polar ticks size.

fTickpolarSize = tickpolarsize;
}

//______________________________________________________________________________
void TGraphPolargram::SetToDegree()
{
// The Polar circle is labelled using degree.

fDegree = kTRUE;
fGrad   = kFALSE;
fRadian = kFALSE;
ChangeRangePolar(0,360);
}

//______________________________________________________________________________
void TGraphPolargram::SetToGrad()
{
// The Polar circle is labelled using gradian.

fGrad   = kTRUE;
fRadian = kFALSE;
fDegree = kFALSE;
ChangeRangePolar(0,200);
}

//______________________________________________________________________________
void TGraphPolargram::SetToRadian()
{
// The Polar circle is labelled using radian.

fRadian = kTRUE;
fGrad   = kFALSE;
fDegree = kFALSE;
ChangeRangePolar(0,2*TMath::Pi());
}

//______________________________________________________________________________
void TGraphPolargram::SetTwoPi()
{
//set range from 0 to 2*pi
SetRangePolar(0,2*TMath::Pi());
}
```

Last update: Thu Jan 17 08:57:08 2008

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.