Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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
22using std::sqrt;
23
24/** \class TAttLine
25\ingroup Base
26\ingroup GraphicsAtt
27
28Line Attributes class.
29
30This class is used (in general by secondary inheritance)
31by many other classes (graphics, histograms). It holds all the line attributes.
32
33## Line attributes
34Line attributes are:
35
36 - [Line Color](#L1)
37 - [Line Width](#L2)
38 - [Line Style](#L3)
39
40## <a name="L1"></a> Line Color
41The line color is a color index (integer) pointing in the ROOT
42color table.
43The line color of any class inheriting from `TAttLine` can
44be changed using the method `SetLineColor` and retrieved using the
45method `GetLineColor`.
46The following table shows the first 50 default colors.
47
48Begin_Macro
49{
50 TCanvas *c = new TCanvas("c","Fill Area colors",0,0,500,200);
51 c->DrawColorTable();
52 return c;
53}
54End_Macro
55
56### Color transparency
57`SetLineColorAlpha()`, allows to set a transparent color.
58In the following example the line color of the histogram `histo`
59is set to blue with a transparency of 35%. The color `kBlue`
60itself remains fully opaque.
61
62~~~ {.cpp}
63histo->SetLineColorAlpha(kBlue, 0.35);
64~~~
65
66The transparency is available on all platforms when the flag `OpenGL.CanvasPreferGL` is set to `1`
67in `$ROOTSYS/etc/system.rootrc`, or on Mac with the Cocoa backend. On the file output
68it is visible with PDF, PNG, Gif, JPEG, SVG, TeX ... but not PostScript.
69
70
71## <a name="L2"></a> Line Width
72The line width is expressed in pixel units.
73The line width of any class inheriting from `TAttLine` can
74be changed using the method `SetLineWidth` and retrieved using the
75method `GetLineWidth`.
76The following picture shows the line widths from 1 to 10 pixels.
77
78Begin_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}
92End_Macro
93
94## <a name="L3"></a> Line Style
95Line styles are identified via integer numbers. The line style of any class
96inheriting from `TAttLine` can be changed using the method
97`SetLineStyle` and retrieved using the method `GetLineStyle`.
98
99The first 10 line styles are predefined as shown on the following picture:
100
101Begin_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}
116End_Macro
117
118Some 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
127Additional line styles can be defined using `TStyle::SetLineStyleString`.
128For example the line style number 11 can be defined as follow:
129~~~ {.cpp}
130 gStyle->SetLineStyleString(11,"400 200");
131~~~
132Existing 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;}
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;
160}
161
162////////////////////////////////////////////////////////////////////////////////
163/// AttLine destructor.
164
166{
167}
168
169////////////////////////////////////////////////////////////////////////////////
170/// Copy this line attributes to a new TAttLine.
171
172void 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
270void 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}
#define d(i)
Definition RSha256.hxx:102
#define b(i)
Definition RSha256.hxx:100
#define c(i)
Definition RSha256.hxx:101
#define a(i)
Definition RSha256.hxx:99
static const double x2[5]
static const double x1[5]
int Int_t
Definition RtypesCore.h:45
short Width_t
Definition RtypesCore.h:82
double Double_t
Definition RtypesCore.h:59
short Color_t
Definition RtypesCore.h:83
short Style_t
Definition RtypesCore.h:80
float Float_t
Definition RtypesCore.h:57
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:364
include TDocParser_001 C image html pict1_TDocParser_001 png width
char name[80]
Definition TGX11.cxx:110
double sqrt(double)
R__EXTERN TStyle * gStyle
Definition TStyle.h:412
#define gPad
#define gVirtualX
Definition TVirtualX.h:338
Line Attributes class.
Definition TAttLine.h:18
virtual Color_t GetLineColor() const
Return the line color.
Definition TAttLine.h:33
virtual Width_t GetLineWidth() const
Return the line width.
Definition TAttLine.h:35
virtual void SetLineAttributes()
Invoke the DialogCanvas Line attributes.
Definition TAttLine.cxx:290
virtual void SetLineColorAlpha(Color_t lcolor, Float_t lalpha)
Set a transparent line color.
Definition TAttLine.cxx:299
Width_t fLineWidth
Line width.
Definition TAttLine.h:23
virtual void ResetAttLine(Option_t *option="")
Reset this line attributes to default values.
Definition TAttLine.cxx:260
virtual ~TAttLine()
AttLine destructor.
Definition TAttLine.cxx:165
TAttLine()
AttLine default constructor.
Definition TAttLine.cxx:138
virtual Style_t GetLineStyle() const
Return the line style.
Definition TAttLine.h:34
virtual void Modify()
Change current line attributes if necessary.
Definition TAttLine.cxx:242
Style_t fLineStyle
Line style.
Definition TAttLine.h:22
void Copy(TAttLine &attline) const
Copy this line attributes to a new TAttLine.
Definition TAttLine.cxx:172
Color_t fLineColor
Line color.
Definition TAttLine.h:21
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
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
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:2121
static Int_t GetColorTransparent(Int_t color, Float_t a)
Static function: Returns the transparent color number corresponding to n.
Definition TColor.cxx:1979
static void UpdateLineAttributes(Int_t col, Int_t sty, Int_t width)
Update line attributes via the pad editor.
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Short_t Abs(Short_t d)
Definition TMathBase.h:120
TCanvas * style()
Definition style.C:1