Logo ROOT  
Reference Guide
TAttLine.cxx
Go to the documentation of this file.
1 // @(#)root/base:$Id$
2 // Author: Rene Brun 28/11/94
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #include "TAttLine.h"
13 #include "TVirtualPad.h"
14 #include "TStyle.h"
15 #include "TVirtualX.h"
16 #include "TVirtualPadEditor.h"
17 #include "TColor.h"
18 #include <cmath>
19 #include <iostream>
20 
22 using std::sqrt;
23 
24 /** \class TAttLine
25 \ingroup Base
26 \ingroup GraphicsAtt
27 
28 Line Attributes class.
29 
30 This class is used (in general by secondary inheritance)
31 by many other classes (graphics, histograms). It holds all the line attributes.
32 
33 ## Line attributes
34 Line attributes are:
35 
36  - [Line Color](#L1)
37  - [Line Width](#L2)
38  - [Line Style](#L3)
39 
40 ## <a name="L1"></a> Line Color
41 The line color is a color index (integer) pointing in the ROOT
42 color table.
43 The line color of any class inheriting from `TAttLine` can
44 be changed using the method `SetLineColor` and retrieved using the
45 method `GetLineColor`.
46 The following table shows the first 50 default colors.
47 
48 Begin_Macro
49 {
50  TCanvas *c = new TCanvas("c","Fill Area colors",0,0,500,200);
51  c->DrawColorTable();
52  return c;
53 }
54 End_Macro
55 
56 ### Color transparency
57 `SetLineColorAlpha()`, allows to set a transparent color.
58 In the following example the line color of the histogram `histo`
59 is set to blue with a transparency of 35%. The color `kBlue`
60 itself remains fully opaque.
61 
62 ~~~ {.cpp}
63 histo->SetLineColorAlpha(kBlue, 0.35);
64 ~~~
65 
66 The transparency is available on all platforms when the flag `OpenGL.CanvasPreferGL` is set to `1`
67 in `$ROOTSYS/etc/system.rootrc`, or on Mac with the Cocoa backend. On the file output
68 it is visible with PDF, PNG, Gif, JPEG, SVG, TeX ... but not PostScript.
69 
70 
71 ## <a name="L2"></a> Line Width
72 The line width is expressed in pixel units.
73 The line width of any class inheriting from `TAttLine` can
74 be changed using the method `SetLineWidth` and retrieved using the
75 method `GetLineWidth`.
76 The following picture shows the line widths from 1 to 10 pixels.
77 
78 Begin_Macro
79 {
80  TCanvas *Lw = new TCanvas("Lw","test",500,200);
81  TText t;
82  t.SetTextAlign(32);
83  t.SetTextSize(0.08);
84  Int_t i=1;
85  for (float s=0.1; s<1.0 ; s+=0.092) {
86  TLine *lh = new TLine(0.15,s,.85,s);
87  lh->SetLineWidth(i);
88  t.DrawText(0.1,s,Form("%d",i++));
89  lh->Draw();
90  }
91 }
92 End_Macro
93 
94 ## <a name="L3"></a> Line Style
95 Line styles are identified via integer numbers. The line style of any class
96 inheriting from `TAttLine` can be changed using the method
97 `SetLineStyle` and retrieved using the method `GetLineStyle`.
98 
99 The first 10 line styles are predefined as shown on the following picture:
100 
101 Begin_Macro
102 {
103  TCanvas *Ls = new TCanvas("Ls","test",500,200);
104  TText t;
105  t.SetTextAlign(32);
106  t.SetTextSize(0.08);
107  Int_t i=1;
108  for (float s=0.1; s<1.0 ; s+=0.092) {
109  TLine *lh = new TLine(0.15,s,.85,s);
110  lh->SetLineStyle(i);
111  lh->SetLineWidth(3);
112  t.DrawText(0.1,s,Form("%d",i++));
113  lh->Draw();
114  }
115 }
116 End_Macro
117 
118 Some line styles can be accessed via the following enum:
119 
120 ~~~ {.cpp}
121  kSolid = 1
122  kDashed = 2
123  kDotted = 3
124  kDashDotted = 4
125 ~~~
126 
127 Additional line styles can be defined using `TStyle::SetLineStyleString`.
128 For example the line style number 11 can be defined as follow:
129 ~~~ {.cpp}
130  gStyle->SetLineStyleString(11,"400 200");
131 ~~~
132 Existing line styles (1 to 10) can be redefined using the same method.
133  */
134 
135 ////////////////////////////////////////////////////////////////////////////////
136 /// AttLine default constructor.
137 
139 {
140  if (!gStyle) {fLineColor=1; fLineWidth=1; fLineStyle=1; return;}
141  fLineColor = gStyle->GetLineColor();
142  fLineWidth = gStyle->GetLineWidth();
143  fLineStyle = gStyle->GetLineStyle();
144 }
145 
146 ////////////////////////////////////////////////////////////////////////////////
147 /// AttLine normal constructor.
148 /// Line attributes are taking from the argument list
149 ///
150 /// - color : must be one of the valid color index
151 /// - style : 1=solid, 2=dash, 3=dash-dot, 4=dot-dot. New styles can be
152 /// defined using TStyle::SetLineStyleString.
153 /// - width : expressed in pixel units
154 
156 {
157  fLineColor = color;
158  fLineWidth = width;
159  fLineStyle = style;
160 }
161 
162 ////////////////////////////////////////////////////////////////////////////////
163 /// AttLine destructor.
164 
166 {
167 }
168 
169 ////////////////////////////////////////////////////////////////////////////////
170 /// Copy this line attributes to a new TAttLine.
171 
172 void TAttLine::Copy(TAttLine &attline) const
173 {
174  attline.fLineColor = fLineColor;
175  attline.fLineStyle = fLineStyle;
176  attline.fLineWidth = fLineWidth;
177 }
178 
179 ////////////////////////////////////////////////////////////////////////////////
180 /// Compute distance from point px,py to a line.
181 /// Compute the closest distance of approach from point px,py to this line.
182 /// The distance is computed in pixels units.
183 ///
184 /// Algorithm:
185 ///~~~ {.cpp}
186 /// A(x1,y1) P B(x2,y2)
187 /// -----------------+------------------------------
188 /// |
189 /// |
190 /// |
191 /// |
192 /// M(x,y)
193 ///
194 /// Let us call a = distance AM A=a**2
195 /// b = distance BM B=b**2
196 /// c = distance AB C=c**2
197 /// d = distance PM D=d**2
198 /// u = distance AP U=u**2
199 /// v = distance BP V=v**2 c = u + v
200 ///
201 /// D = A - U
202 /// D = B - V = B -(c-u)**2
203 /// ==> u = (A -B +C)/2c
204 ///~~~
205 
207 {
208  Double_t xl, xt, yl, yt;
209  Double_t x = px;
210  Double_t y = py;
211  Double_t x1 = gPad->XtoAbsPixel(xp1);
212  Double_t y1 = gPad->YtoAbsPixel(yp1);
213  Double_t x2 = gPad->XtoAbsPixel(xp2);
214  Double_t y2 = gPad->YtoAbsPixel(yp2);
215  if (x1 < x2) {xl = x1; xt = x2;}
216  else {xl = x2; xt = x1;}
217  if (y1 < y2) {yl = y1; yt = y2;}
218  else {yl = y2; yt = y1;}
219  if (x < xl-2 || x> xt+2) return 9999; //following algorithm only valid in the box
220  if (y < yl-2 || y> yt+2) return 9999; //surrounding the line
221  Double_t xx1 = x - x1;
222  Double_t xx2 = x - x2;
223  Double_t x1x2 = x1 - x2;
224  Double_t yy1 = y - y1;
225  Double_t yy2 = y - y2;
226  Double_t y1y2 = y1 - y2;
227  Double_t a = xx1*xx1 + yy1*yy1;
228  Double_t b = xx2*xx2 + yy2*yy2;
229  Double_t c = x1x2*x1x2 + y1y2*y1y2;
230  if (c <= 0) return 9999;
231  Double_t v = sqrt(c);
232  Double_t u = (a - b + c)/(2*v);
233  Double_t d = TMath::Abs(a - u*u);
234  if (d < 0) return 9999;
235 
236  return Int_t(sqrt(d) - 0.5*Double_t(fLineWidth));
237 }
238 
239 ////////////////////////////////////////////////////////////////////////////////
240 /// Change current line attributes if necessary.
241 
243 {
244  if (!gPad) return;
245  Int_t lineWidth = TMath::Abs(fLineWidth%100);
246  if (!gPad->IsBatch()) {
247  gVirtualX->SetLineColor(fLineColor);
248  if (fLineStyle > 0 && fLineStyle < 30) gVirtualX->SetLineStyle(fLineStyle);
249  else gVirtualX->SetLineStyle(1);
250  gVirtualX->SetLineWidth(lineWidth);
251  }
252 
253  if (fLineStyle > 0 && fLineStyle < 30) gPad->SetAttLinePS(fLineColor,fLineStyle,lineWidth);
254  else gPad->SetAttLinePS(fLineColor,1,lineWidth);
255 }
256 
257 ////////////////////////////////////////////////////////////////////////////////
258 /// Reset this line attributes to default values.
259 
261 {
262  fLineColor = 1;
263  fLineStyle = 1;
264  fLineWidth = 1;
265 }
266 
267 ////////////////////////////////////////////////////////////////////////////////
268 /// Save line attributes as C++ statement(s) on output stream out.
269 
270 void TAttLine::SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef, Int_t stydef, Int_t widdef)
271 {
272  if (fLineColor != coldef) {
273  if (fLineColor > 228) {
275  out<<" "<<name<<"->SetLineColor(ci);" << std::endl;
276  } else
277  out<<" "<<name<<"->SetLineColor("<<fLineColor<<");"<<std::endl;
278  }
279  if (fLineStyle != stydef) {
280  out<<" "<<name<<"->SetLineStyle("<<fLineStyle<<");"<<std::endl;
281  }
282  if (fLineWidth != widdef) {
283  out<<" "<<name<<"->SetLineWidth("<<fLineWidth<<");"<<std::endl;
284  }
285 }
286 
287 ////////////////////////////////////////////////////////////////////////////////
288 /// Invoke the DialogCanvas Line attributes.
289 
291 {
293 }
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 /// Set a transparent line color. lalpha defines the percentage of
297 /// the color opacity from 0. (fully transparent) to 1. (fully opaque).
298 
300 {
301  fLineColor = TColor::GetColorTransparent(lcolor, lalpha);
302 }
c
#define c(i)
Definition: RSha256.hxx:119
TAttLine::fLineColor
Color_t fLineColor
Line color.
Definition: TAttLine.h:27
Style_t
short Style_t
Definition: RtypesCore.h:80
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Float_t
float Float_t
Definition: RtypesCore.h:57
width
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
TAttLine::SetLineColorAlpha
virtual void SetLineColorAlpha(Color_t lcolor, Float_t lalpha)
Set a transparent line color.
Definition: TAttLine.cxx:299
TStyle.h
Int_t
int Int_t
Definition: RtypesCore.h:45
TAttLine::SaveLineAttributes
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:270
x
Double_t x[n]
Definition: legend1.C:17
TColor.h
TVirtualX.h
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TAttLine::fLineWidth
Width_t fLineWidth
Line width.
Definition: TAttLine.h:29
TColor::SaveColor
static void SaveColor(std::ostream &out, Int_t ci)
Save a color with index > 228 as a C++ statement(s) on output stream out.
Definition: TColor.cxx:2118
Color_t
short Color_t
Definition: RtypesCore.h:83
v
@ v
Definition: rootcling_impl.cxx:3635
b
#define b(i)
Definition: RSha256.hxx:118
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
TAttLine::Modify
virtual void Modify()
Change current line attributes if necessary.
Definition: TAttLine.cxx:242
TAttLine.h
style
TCanvas * style()
Definition: style.C:1
TAttLine::SetLineAttributes
virtual void SetLineAttributes()
Invoke the DialogCanvas Line attributes.
Definition: TAttLine.cxx:290
TAttLine::Copy
void Copy(TAttLine &attline) const
Copy this line attributes to a new TAttLine.
Definition: TAttLine.cxx:172
Option_t
const typedef char Option_t
Definition: RtypesCore.h:66
TVirtualPadEditor.h
TAttLine
Definition: TAttLine.h:18
gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
a
auto * a
Definition: textangle.C:12
Width_t
short Width_t
Definition: RtypesCore.h:82
TAttLine::ResetAttLine
virtual void ResetAttLine(Option_t *option="")
Reset this line attributes to default values.
Definition: TAttLine.cxx:260
TVirtualPad.h
y
Double_t y[n]
Definition: legend1.C:17
sqrt
double sqrt(double)
TAttLine::~TAttLine
virtual ~TAttLine()
AttLine destructor.
Definition: TAttLine.cxx:165
TVirtualPadEditor::UpdateLineAttributes
static void UpdateLineAttributes(Int_t col, Int_t sty, Int_t width)
Update line attributes via the pad editor.
Definition: TVirtualPadEditor.cxx:152
Double_t
double Double_t
Definition: RtypesCore.h:59
TColor::GetColorTransparent
static Int_t GetColorTransparent(Int_t color, Float_t a)
Static function: Returns the transparent color number corresponding to n.
Definition: TColor.cxx:1976
TAttLine::TAttLine
TAttLine()
AttLine default constructor.
Definition: TAttLine.cxx:138
name
char name[80]
Definition: TGX11.cxx:110
d
#define d(i)
Definition: RSha256.hxx:120
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
gPad
#define gPad
Definition: TVirtualPad.h:287
TAttLine::DistancetoLine
Int_t DistancetoLine(Int_t px, Int_t py, Double_t xp1, Double_t yp1, Double_t xp2, Double_t yp2)
Compute distance from point px,py to a line.
Definition: TAttLine.cxx:206
TAttLine::fLineStyle
Style_t fLineStyle
Line style.
Definition: TAttLine.h:28
int