FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Private Attributes | List of all members
EdbAffine2D Class Reference

#include <EdbAffine.h>

Inheritance diagram for EdbAffine2D:
Inheritance graph
[legend]
Collaboration diagram for EdbAffine2D:
Collaboration graph
[legend]

Public Member Functions

Float_t A11 () const
 
Float_t A12 () const
 
Float_t A21 () const
 
Float_t A22 () const
 
const char * AsString () const
 
Float_t B1 () const
 
Float_t B2 () const
 
Int_t Calculate (EdbPointsBox2D *b1, EdbPointsBox2D *b2)
 
Int_t Calculate (int n, float *x0, float *y0, float *x1, float *y1, int flag=0)
 
Int_t CalculateFull (int n, float *x0, float *y0, float *x1, float *y1)
 
Int_t CalculateShift (int n, float *x0, float *y0, float *x1, float *y1)
 
Int_t CalculateTurn (int n, float *x0, float *y0, float *x1, float *y1)
 
 EdbAffine2D ()
 
 EdbAffine2D (const char *str)
 
 EdbAffine2D (float a11, float a12, float a21, float a22, float b1, float b2)
 
void Invert ()
 
Double_t Phi (Double_t x, Double_t y) const
 
void Print (Option_t *opt="") const
 
void Reset ()
 
void Rotate (float angle)
 
void Set (const char *str=0)
 
void Set (EdbAffine2D &a)
 
void Set (float a11, float a12, float a21, float a22, float b1, float b2)
 
void SetAxisX (float a, float b)
 
void SetAxisY (float a, float b)
 
void ShiftX (float d)
 
void ShiftY (float d)
 
void Transform (const EdbAffine2D &a)
 
void Transform (const EdbAffine2D *a)
 
Float_t Xtrans (Float_t x, Float_t y) const
 
Float_t Ytrans (Float_t x, Float_t y) const
 
void Zoom (float k)
 
void ZoomX (float k)
 
void ZoomY (float k)
 
virtual ~EdbAffine2D ()
 

Private Attributes

Float_t eA11
 
Float_t eA12
 
Float_t eA21
 
Float_t eA22
 
Float_t eB1
 
Float_t eB2
 

Constructor & Destructor Documentation

◆ EdbAffine2D() [1/3]

EdbAffine2D::EdbAffine2D ( )
inline
28 { Reset(); }
EdbAffine2D::Reset
void Reset()
Definition: EdbAffine.cxx:72

◆ EdbAffine2D() [2/3]

EdbAffine2D::EdbAffine2D ( const char *  str)
inline
29 { Set(str); }
EdbAffine2D::Set
void Set(EdbAffine2D &a)
Definition: EdbAffine.h:36

◆ EdbAffine2D() [3/3]

EdbAffine2D::EdbAffine2D ( float  a11,
float  a12,
float  a21,
float  a22,
float  b1,
float  b2 
)
inline
32  :
33  eA11(a11), eA12(a12), eA21(a21), eA22(a22), eB1(b1), eB2(b2) {}
EdbAffine2D::eA11
Float_t eA11
Definition: EdbAffine.h:23
EdbAffine2D::eB2
Float_t eB2
Definition: EdbAffine.h:25
EdbAffine2D::eA21
Float_t eA21
Definition: EdbAffine.h:24
EdbAffine2D::eB1
Float_t eB1
Definition: EdbAffine.h:25
EdbAffine2D::eA12
Float_t eA12
Definition: EdbAffine.h:23
EdbAffine2D::eA22
Float_t eA22
Definition: EdbAffine.h:24

◆ ~EdbAffine2D()

virtual EdbAffine2D::~EdbAffine2D ( )
inlinevirtual
34 {}

Member Function Documentation

◆ A11()

Float_t EdbAffine2D::A11 ( ) const
inline
43 { return eA11; }

◆ A12()

Float_t EdbAffine2D::A12 ( ) const
inline
44 { return eA12; }

◆ A21()

Float_t EdbAffine2D::A21 ( ) const
inline
45 { return eA21; }

◆ A22()

Float_t EdbAffine2D::A22 ( ) const
inline
46 { return eA22; }

◆ AsString()

const char * EdbAffine2D::AsString ( ) const
58 {
59  return Form("%9.6f %9.6f %9.6f %9.6f %12.6f %12.6f", eA11, eA12, eA21, eA22, eB1, eB2 );
60 }

◆ B1()

Float_t EdbAffine2D::B1 ( ) const
inline
47 { return eB1; }

◆ B2()

Float_t EdbAffine2D::B2 ( ) const
inline
48 { return eB2; }

◆ Calculate() [1/2]

Int_t EdbAffine2D::Calculate ( EdbPointsBox2D *  b1,
EdbPointsBox2D *  b2 
)
261 {
262  //
263  // Calculate affine transformation for 2 patterns.
264  // b1 == b0->Transform(this);
265  //
266 
267  int n0 = b0->N();
268  int n1 = b1->N();
269  int n = TMath::Min(n0,n1);
270 
271  Double_t a=0;
272  Double_t b=0;
273  Double_t c=0;
274  Double_t d=0;
275  Double_t p=0;
276  Double_t q=0;
277 
278  if(n<2) return 0;
279 
280  else if(n==2){
281 
282  Double_t dx0 = b0->At(1)->X() - b0->At(0)->X();
283  Double_t dy0 = b0->At(1)->Y() - b0->At(0)->Y();
284  Double_t dx1 = b1->At(1)->X() - b1->At(0)->X();
285  Double_t dy1 = b1->At(1)->Y() - b1->At(0)->Y();
286 
287  Double_t s = TMath::Sqrt(dx1*dx1+dy1*dy1)/TMath::Sqrt(dx0*dx0+dy0*dy0);
288  Double_t th = Phi(dx1,dy1)-Phi(dx0,dy0);
289 
290  a = s*TMath::Cos(th);
291  b = -s*TMath::Sin(th);
292  c = s*TMath::Sin(th);
293  d = s*TMath::Cos(th);
294  p = b1->At(0)->X() - a*b0->At(0)->X() - b*b0->At(0)->Y();
295  q = b1->At(0)->Y() - c*b0->At(0)->X() - d*b0->At(0)->Y();
296 
297  }
298  else {
299 
300  Double_t
301  sx0 =0,
302  sy0 =0,
303  sx1 =0,
304  sy1 =0,
305  sx0x0 =0,
306  sy0y0 =0,
307  sx0y0 =0,
308  sx0x1 =0,
309  sx0y1 =0,
310  sx1y0 =0,
311  sy0y1 =0,
312  r =0;
313 
314  for(int i=0; i<n; i++) {
315  r = 1./(i+1);
316  sx0 = sx0 *i*r + b0->At(i)->X() *r;
317  sy0 = sy0 *i*r + b0->At(i)->Y() *r;
318  sx1 = sx1 *i*r + b1->At(i)->X() *r;
319  sy1 = sy1 *i*r + b1->At(i)->Y() *r;
320  sx0x0 = sx0x0 *i*r + b0->At(i)->X() * b0->At(i)->X() *r;
321  sy0y0 = sy0y0 *i*r + b0->At(i)->Y() * b0->At(i)->Y() *r;
322  sx0y0 = sx0y0 *i*r + b0->At(i)->X() * b0->At(i)->Y() *r;
323  sx0x1 = sx0x1 *i*r + b0->At(i)->X() * b1->At(i)->X() *r;
324  sx0y1 = sx0y1 *i*r + b0->At(i)->X() * b1->At(i)->Y() *r;
325  sx1y0 = sx1y0 *i*r + b1->At(i)->X() * b0->At(i)->Y() *r;
326  sy0y1 = sy0y1 *i*r + b0->At(i)->Y() * b1->At(i)->Y() *r;
327  }
328 
329  Double_t sp0 = sx0x1 - sx0*sx1;
330  Double_t sp1 = sx1y0 - sx1*sy0;
331  Double_t sq0 = sx0y1 - sx0*sy1;
332  Double_t sq1 = sy0y1 - sy0*sy1;
333 
334  Double_t sar = sx0x0 - sx0*sx0;
335  Double_t sbr = sx0y0 - sx0*sy0;
336  Double_t scr = sbr;
337  Double_t sdr = sy0y0 - sy0*sy0;
338  Double_t det = sar*sdr-sbr*scr;
339 
340  if ( det < 0.0000000001 ) { Log(1,"EdbAffine2D::Calculate","determinant is too small: %g",det); return 0; }
341 
342  Double_t sa = sdr/det;
343  Double_t sb = -sbr/det;
344  Double_t sc = -scr/det;
345  Double_t sd = sar/det;
346 
347  a = sa*sp0+sb*sp1;
348  b = sc*sp0+sd*sp1;
349  c = sa*sq0+sb*sq1;
350  d = sc*sq0+sd*sq1;
351  p = sx1-a*sx0-b*sy0;
352  q = sy1-c*sx0-d*sy0;
353  }
354 
355  Log(3,"Calculate","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
356  n, a,b,c,d,p,q);
357 
358  Set(a,b,c,d,p,q);
359 
360  return 1;
361 }
Log
bool Log(int level, const char *location, const char *fmt,...)
Definition: EdbLog.cxx:75
d
void d()
Definition: RecDispEX.C:381
a
void a()
Definition: check_aligned.C:59
sd
void sd()
Definition: check_vertex.C:185
EdbAffine2D::Phi
Double_t Phi(Double_t x, Double_t y) const
Definition: EdbAffine.cxx:376
EdbPoint::Y
virtual Float_t Y() const =0
EdbPoint::X
virtual Float_t X() const =0
EdbPointsBox2D::N
virtual Int_t N() const =0
EdbPointsBox2D::At
virtual EdbPoint * At(int i) const =0
q
q
Definition: testBGReduction_AllMethods.C:55
p
p
Definition: testBGReduction_AllMethods.C:8
r
void r(int rid=2)
Definition: test.C:201
s
EdbSegP * s
Definition: tlg2pattern.C:32

◆ Calculate() [2/2]

Int_t EdbAffine2D::Calculate ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1,
int  flag = 0 
)
126 {
127  // Calculate affine transformation for 2 patterns
128  // if flag==2 : do not permit scaling of patterns
129 
130  if(flag==2) return CalculateTurn( n, x0,y0, x1,y1 );
131  else return CalculateFull( n, x0,y0, x1,y1 );
132 }
EdbAffine2D::CalculateTurn
Int_t CalculateTurn(int n, float *x0, float *y0, float *x1, float *y1)
Definition: EdbAffine.cxx:449
EdbAffine2D::CalculateFull
Int_t CalculateFull(int n, float *x0, float *y0, float *x1, float *y1)
Definition: EdbAffine.cxx:164

◆ CalculateFull()

Int_t EdbAffine2D::CalculateFull ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1 
)
165 {
166  //
167  // Calculate affine transformation for 2 patterns.
168  // b1 == b0->Transform(this);
169  //
170 
171  Double_t a,b,c,d,p,q;
172  a=b=c=d=p=q=0;
173 
174  if(n<2) return 0;
175 
176  else if(n==2){
177 
178  Double_t dx0 = x0[1] - x0[0];
179  Double_t dy0 = y0[1] - y0[0];
180  Double_t dx1 = x1[1] - x1[0];
181  Double_t dy1 = y1[1] - y1[0];
182 
183  Double_t s = TMath::Sqrt(dx1*dx1+dy1*dy1)/TMath::Sqrt(dx0*dx0+dy0*dy0);
184  Double_t th = Phi(dx1,dy1)-Phi(dx0,dy0);
185 
186  a = s*TMath::Cos(th);
187  b = -s*TMath::Sin(th);
188  c = s*TMath::Sin(th);
189  d = s*TMath::Cos(th);
190  p = x1[0] - a*x0[0] - b*y0[0];
191  q = y1[0] - c*x0[0] - d*y0[0];
192 
193  }
194  else {
195 
196  Double_t
197  sx0 =0,
198  sy0 =0,
199  sx1 =0,
200  sy1 =0,
201  sx0x0 =0,
202  sy0y0 =0,
203  sx0y0 =0,
204  sx0x1 =0,
205  sx0y1 =0,
206  sx1y0 =0,
207  sy0y1 =0,
208  r =0;
209 
210  for(int i=0; i<n; i++) {
211  r = 1./(i+1);
212  sx0 = sx0 *i*r + x0[i] *r;
213  sy0 = sy0 *i*r + y0[i] *r;
214  sx1 = sx1 *i*r + x1[i] *r;
215  sy1 = sy1 *i*r + y1[i] *r;
216  sx0x0 = sx0x0 *i*r + x0[i] * x0[i] *r;
217  sy0y0 = sy0y0 *i*r + y0[i] * y0[i] *r;
218  sx0y0 = sx0y0 *i*r + x0[i] * y0[i] *r;
219  sx0x1 = sx0x1 *i*r + x0[i] * x1[i] *r;
220  sx0y1 = sx0y1 *i*r + x0[i] * y1[i] *r;
221  sx1y0 = sx1y0 *i*r + x1[i] * y0[i] *r;
222  sy0y1 = sy0y1 *i*r + y0[i] * y1[i] *r;
223  }
224 
225  Double_t sp0 = sx0x1 - sx0*sx1;
226  Double_t sp1 = sx1y0 - sx1*sy0;
227  Double_t sq0 = sx0y1 - sx0*sy1;
228  Double_t sq1 = sy0y1 - sy0*sy1;
229 
230  Double_t sar = sx0x0 - sx0*sx0;
231  Double_t sbr = sx0y0 - sx0*sy0;
232  Double_t scr = sbr;
233  Double_t sdr = sy0y0 - sy0*sy0;
234  Double_t det = sar*sdr-sbr*scr;
235 
236  if ( det == 0 ) return 0;
237 
238  Double_t sa = sdr/det;
239  Double_t sb = -sbr/det;
240  Double_t sc = -scr/det;
241  Double_t sd = sar/det;
242 
243  a = sa*sp0+sb*sp1;
244  b = sc*sp0+sd*sp1;
245  c = sa*sq0+sb*sq1;
246  d = sc*sq0+sd*sq1;
247  p = sx1-a*sx0-b*sy0;
248  q = sy1-c*sx0-d*sy0;
249  }
250 
251  Log(3,"CalculateFull","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
252  n, a,b,c,d,p,q);
253 
254  Set(a,b,c,d,p,q);
255 
256  return 1;
257 }

◆ CalculateShift()

Int_t EdbAffine2D::CalculateShift ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1 
)
136 {
137  // calculate only the offset without scaling and rotation
138  Double_t a,b,c,d,p,q;
139  a=b=c=d=p=q=0;
140 
141  if(n<1) return 0;
142  else {
143  Double_t sx0 =0, sy0 =0;
144  for(int i=0; i<n; i++) {
145  sx0 += x1[i]-x0[i];
146  sy0 += y1[i]-y0[i];
147  }
148 
149  a = 1;
150  b = 0;
151  c = 0;
152  d = 1;
153  p = sx0/n;
154  q = sy0/n;
155  }
156 
157  Log(3,"CalculateShift","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
158  n, a,b,c,d,p,q);
159  Set(a,b,c,d,p,q);
160  return 1;
161 }

◆ CalculateTurn()

Int_t EdbAffine2D::CalculateTurn ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1 
)
450 {
451  //
452  // Calculate affine transformation for 2 patterns: shift and rotation only
453  // b1 == b0->Transform(this);
454  //
455 
456  Double_t a,b,c,d,p,q;
457  a=b=c=d=p=q=0;
458  Double_t X = 0.0;
459  Double_t Y = 0.0;
460  Double_t X_ = 0.0;
461  Double_t Y_ = 0.0;
462  Double_t f = 0.0;
463  Double_t e = 0.0;
464  Double_t teta1,teta2,a1,a2,b1,b2,F1=0,F2=0;
465  Int_t i;
466 
467 
468  if (n==0){
469  return 0;
470  }
471  else if(n==1){
472  a = 1.0;
473  b = 0.0;
474  c = 0.0;
475  d = 1.0;
476  p = x1[0] - x0[0];
477  q = y1[0] - y0[0];
478  }
479  else {
480  for (i=0;i<n;i++) {
481  X += x0[i];
482  Y += y0[i];
483  X_ += x1[i];
484  Y_ += y1[i];
485  }
486  X /= (Double_t)n;
487  Y /= (Double_t)n;
488  X_ /= (Double_t)n;
489  Y_ /= (Double_t)n;
490 
491  for (i=0;i<n;i++) {
492  f += x1[i] * (x0[i] - X) + y1[i] * (y0[i] - Y);
493  d += x1[i] * (Y - y0[i]) + y1[i] * (x0[i] - X);
494  e += x1[i] * Y_ - y1[i] * X_;
495  }
496 
497  Double_t det=sqr(f)+sqr(d);
498  if ( (sqr(f)+sqr(d)) < 0.0000000001 ) { Log(1,"EdbAffine2D::CalculateTurn","determinant is too small: %g",det); return 0; }
499 
500  teta1 = TMath::ASin((e*f-d*TMath::Sqrt(sqr(f)+sqr(d)-sqr(e)))/(det));
501  teta2 = TMath::Pi() - TMath::ASin((e*f+d*TMath::Sqrt(sqr(f)+sqr(d)-sqr(e)))/(det));
502 
503  a1 = X + Y_*TMath::Sin(teta1) - X_*TMath::Cos(teta1);
504  b1 = Y - Y_*TMath::Cos(teta1) - X_*TMath::Sin(teta1);
505 
506  a2 = X + Y_*TMath::Sin(teta2) - X_*TMath::Cos(teta2);
507  b2 = Y - Y_*TMath::Cos(teta2) - X_*TMath::Sin(teta2);
508 
509  for (i=0;i<n;i++) {
510  F1 += sqr(x0[i] - x1[i]*TMath::Cos(teta1) + y1[i]*TMath::Sin(teta1) - a1) \
511  + sqr(y0[i] - x1[i]*TMath::Sin(teta1) - y1[i]*TMath::Cos(teta1) - b1);
512 
513  F2 += sqr(x0[i] - x1[i]*TMath::Cos(teta2) + y1[i]*TMath::Sin(teta2) - a2) \
514  + sqr(y0[i] - x1[i]*TMath::Sin(teta2) - y1[i]*TMath::Cos(teta2) - b2);
515  }
516 
517  if (F1<F2) {
518  a = TMath::Cos(teta1);
519  b = TMath::Sin(teta1);
520  c = -TMath::Sin(teta1);
521  d = TMath::Cos(teta1);
522  p = -a1*TMath::Cos(teta1) - b1*TMath::Sin(teta1);
523  q = a1*TMath::Sin(teta1) - b1*TMath::Cos(teta1);
524  }
525  else {
526  a = TMath::Cos(teta2);
527  b = TMath::Sin(teta2);
528  c = -TMath::Sin(teta2);
529  d = TMath::Cos(teta2);
530  p = -a2*TMath::Cos(teta2) - b2*TMath::Sin(teta2);
531  q = a2*TMath::Sin(teta2) - b2*TMath::Cos(teta2);
532  }
533  }
534 
535  Log(3,"CalculateTurn","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
536  n, a,b,c,d,p,q);
537 
538  Set(a,b,c,d,p,q);
539  return 1;
540 }
sqr
Double_t sqr(Double_t x)
Definition: EdbAffine.cxx:22
f
FILE * f
Definition: RecDispMC.C:150
Header::Center::X
Double_t X
Definition: tlg2pattern.C:77
Header::Center::Y
Double_t Y
Definition: tlg2pattern.C:77

◆ Invert()

void EdbAffine2D::Invert ( )
104 {
105  Double_t d;
106  Float_t a11,a12,a21,a22,b1,b2;
107 
108  d = eA11*eA22 - eA12*eA21;
109  if( Abs(d)<0.0000001 ) {
110  Log(1,"EdbAffine2D::Invert","ERROR: Determinant is too small! %f. Do nothing!", d);
111  return;
112  }
113  a11 = eA22/d;
114  a12 = -eA12/d;
115  b1 = (eA12*eB2 - eA22*eB1)/d;
116 
117  a21 = -eA21/d;
118  a22 = eA11/d;
119  b2 = (eA21*eB1 - eA11*eB2)/d;
120 
121  Set( a11, a12, a21, a22, b1, b2 );
122 }

◆ Phi()

Double_t EdbAffine2D::Phi ( Double_t  x,
Double_t  y 
) const
377 {
378  // phi() is defined in [0,TWOPI]
379  return TMath::Pi()+TMath::ATan2(-y,-x);
380 }

◆ Print()

void EdbAffine2D::Print ( Option_t *  opt = "") const
53 {
54  printf("EdbAffine2D: %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f\n", eA11, eA12, eA21, eA22, eB1, eB2 );
55 }

◆ Reset()

void EdbAffine2D::Reset ( )
73 {
74  // set to self-transformation:
75 
76  eA11=1; eA12=0;
77  eA21=0; eA22=1;
78  eB1=0; eB2=0;
79 }

◆ Rotate()

void EdbAffine2D::Rotate ( float  angle)
384 {
385  EdbAffine2D aff(
386  TMath::Cos(angle), -TMath::Sin(angle),
387  TMath::Sin(angle), TMath::Cos(angle),
388  0, 0 );
389 
390  Transform( &aff );
391 }
EdbAffine2D
Definition: EdbAffine.h:17
EdbAffine2D::Transform
void Transform(const EdbAffine2D *a)
Definition: EdbAffine.cxx:93

◆ Set() [1/3]

void EdbAffine2D::Set ( const char *  str = 0)
64 {
65  float a11=1, a12=0, a21=0, a22=1, b1=0,b2=0;
66  if(!str) Reset();
67  else if( sscanf(str, "%f %f %f %f %f %f", &a11, &a12, &a21, &a22, &b1, &b2 ) == 6 ) Set(a11,a12,a21,a22,b1,b2);
68  else Log(1,"EdbAffine2D::Set", "wrond aff string: %s", str);
69 }

◆ Set() [2/3]

void EdbAffine2D::Set ( EdbAffine2D &  a)
inline
36 {Set(a.A11(),a.A12(),a.A21(),a.A22(),a.B1(),a.B2());}

◆ Set() [3/3]

void EdbAffine2D::Set ( float  a11,
float  a12,
float  a21,
float  a22,
float  b1,
float  b2 
)
inline
41  { eA11=a11; eA12=a12; eA21=a21; eA22=a22; eB1=b1; eB2=b2; }

◆ SetAxisX()

void EdbAffine2D::SetAxisX ( float  a,
float  b 
)
inline
57 { eA11 = a; eB1 = b; }

◆ SetAxisY()

void EdbAffine2D::SetAxisY ( float  a,
float  b 
)
inline
58 { eA22 = a; eB2 = b; }

◆ ShiftX()

void EdbAffine2D::ShiftX ( float  d)
inline
64 { eB1+=d; }

◆ ShiftY()

void EdbAffine2D::ShiftY ( float  d)
inline
65 { eB2+=d; }

◆ Transform() [1/2]

void EdbAffine2D::Transform ( const EdbAffine2D &  a)
inline
53 {Transform(&a);}

◆ Transform() [2/2]

void EdbAffine2D::Transform ( const EdbAffine2D *  a)
94 {
95  Set(
96  a->A11()*A11() + a->A12()*A21(), a->A11()*A12() + a->A12()*A22(),
97  a->A21()*A11() + a->A22()*A21(), a->A21()*A12() + a->A22()*A22(),
98  a->A11()*B1() + a->A12()*B2() + a->B1(),
99  a->A21()*B1() + a->A22()*B2() + a->B2() );
100 }
EdbAffine2D::B2
Float_t B2() const
Definition: EdbAffine.h:48
EdbAffine2D::A22
Float_t A22() const
Definition: EdbAffine.h:46
EdbAffine2D::A21
Float_t A21() const
Definition: EdbAffine.h:45
EdbAffine2D::A12
Float_t A12() const
Definition: EdbAffine.h:44
EdbAffine2D::B1
Float_t B1() const
Definition: EdbAffine.h:47
EdbAffine2D::A11
Float_t A11() const
Definition: EdbAffine.h:43

◆ Xtrans()

Float_t EdbAffine2D::Xtrans ( Float_t  x,
Float_t  y 
) const
inline
78 { return eA11*x + eA12*y + eB1; }

◆ Ytrans()

Float_t EdbAffine2D::Ytrans ( Float_t  x,
Float_t  y 
) const
inline
79 { return eA21*x + eA22*y + eB2; }

◆ Zoom()

void EdbAffine2D::Zoom ( float  k)
inline
62 { ZoomX(k); ZoomY(k); }
EdbAffine2D::ZoomX
void ZoomX(float k)
Definition: EdbAffine.h:60
EdbAffine2D::ZoomY
void ZoomY(float k)
Definition: EdbAffine.h:61

◆ ZoomX()

void EdbAffine2D::ZoomX ( float  k)
inline
60 { eA11*=k; eA12*=k; }

◆ ZoomY()

void EdbAffine2D::ZoomY ( float  k)
inline
61 { eA21*=k; eA22*=k; }

Member Data Documentation

◆ eA11

Float_t EdbAffine2D::eA11
private

◆ eA12

Float_t EdbAffine2D::eA12
private

◆ eA21

Float_t EdbAffine2D::eA21
private

◆ eA22

Float_t EdbAffine2D::eA22
private

◆ eB1

Float_t EdbAffine2D::eB1
private

◆ eB2

Float_t EdbAffine2D::eB2
private
The documentation for this class was generated from the following files: