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 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 
)


Calculate affine transformation for 2 patterns.
b1 == b0->Transform(this);

232{
237
238 int n0 = b0->N();
239 int n1 = b1->N();
240 int n = TMath::Min(n0,n1);
241
242 Double_t a=0;
243 Double_t b=0;
244 Double_t c=0;
245 Double_t d=0;
246 Double_t p=0;
247 Double_t q=0;
248
249 if(n<2) return 0;
250
251 else if(n==2){
252
253 Double_t dx0 = b0->At(1)->X() - b0->At(0)->X();
254 Double_t dy0 = b0->At(1)->Y() - b0->At(0)->Y();
255 Double_t dx1 = b1->At(1)->X() - b1->At(0)->X();
256 Double_t dy1 = b1->At(1)->Y() - b1->At(0)->Y();
257
258 Double_t s = TMath::Sqrt(dx1*dx1+dy1*dy1)/TMath::Sqrt(dx0*dx0+dy0*dy0);
259 Double_t th = Phi(dx1,dy1)-Phi(dx0,dy0);
260
261 a = s*TMath::Cos(th);
262 b = -s*TMath::Sin(th);
263 c = s*TMath::Sin(th);
264 d = s*TMath::Cos(th);
265 p = b1->At(0)->X() - a*b0->At(0)->X() - b*b0->At(0)->Y();
266 q = b1->At(0)->Y() - c*b0->At(0)->X() - d*b0->At(0)->Y();
267
268 }
269 else {
270
271 Double_t
272 sx0 =0,
273 sy0 =0,
274 sx1 =0,
275 sy1 =0,
276 sx0x0 =0,
277 sy0y0 =0,
278 sx0y0 =0,
279 sx0x1 =0,
280 sx0y1 =0,
281 sx1y0 =0,
282 sy0y1 =0,
283 r =0;
284
285 for(int i=0; i<n; i++) {
286 r = 1./(i+1);
287 sx0 = sx0 *i*r + b0->At(i)->X() *r;
288 sy0 = sy0 *i*r + b0->At(i)->Y() *r;
289 sx1 = sx1 *i*r + b1->At(i)->X() *r;
290 sy1 = sy1 *i*r + b1->At(i)->Y() *r;
291 sx0x0 = sx0x0 *i*r + b0->At(i)->X() * b0->At(i)->X() *r;
292 sy0y0 = sy0y0 *i*r + b0->At(i)->Y() * b0->At(i)->Y() *r;
293 sx0y0 = sx0y0 *i*r + b0->At(i)->X() * b0->At(i)->Y() *r;
294 sx0x1 = sx0x1 *i*r + b0->At(i)->X() * b1->At(i)->X() *r;
295 sx0y1 = sx0y1 *i*r + b0->At(i)->X() * b1->At(i)->Y() *r;
296 sx1y0 = sx1y0 *i*r + b1->At(i)->X() * b0->At(i)->Y() *r;
297 sy0y1 = sy0y1 *i*r + b0->At(i)->Y() * b1->At(i)->Y() *r;
298 }
299
300 Double_t sp0 = sx0x1 - sx0*sx1;
301 Double_t sp1 = sx1y0 - sx1*sy0;
302 Double_t sq0 = sx0y1 - sx0*sy1;
303 Double_t sq1 = sy0y1 - sy0*sy1;
304
305 Double_t sar = sx0x0 - sx0*sx0;
306 Double_t sbr = sx0y0 - sx0*sy0;
307 Double_t scr = sbr;
308 Double_t sdr = sy0y0 - sy0*sy0;
309 Double_t det = sar*sdr-sbr*scr;
310
311 if ( det < 0.0000000001 ) { Log(1,"EdbAffine2D::Calculate","determinant is too small: %g",det); return 0; }
312
313 Double_t sa = sdr/det;
314 Double_t sb = -sbr/det;
315 Double_t sc = -scr/det;
316 Double_t sd = sar/det;
317
318 a = sa*sp0+sb*sp1;
319 b = sc*sp0+sd*sp1;
320 c = sa*sq0+sb*sq1;
321 d = sc*sq0+sd*sq1;
322 p = sx1-a*sx0-b*sy0;
323 q = sy1-c*sx0-d*sy0;
324 }
325
326 Log(3,"Calculate","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
327 n, a,b,c,d,p,q);
328
329 Set(a,b,c,d,p,q);
330
331 return 1;
332}
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
EdbAffine2D::Phi
Double_t Phi(Double_t x, Double_t y) const
Definition: EdbAffine.cxx:347
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
s
s
Definition: check_shower.C:55
sd
void sd()
Definition: check_vertex.C:185
q
q
Definition: testBGReduction_AllMethods.C:55
p
p
Definition: testBGReduction_AllMethods.C:8
r
void r(int rid=2)
Definition: test.C:201

◆ Calculate() [2/2]

Int_t EdbAffine2D::Calculate ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1,
int  flag = 0 
)

Calculate affine transformation for 2 patterns
if flag==2 : do not permit scaling of patterns

126{
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:420
EdbAffine2D::CalculateFull
Int_t CalculateFull(int n, float *x0, float *y0, float *x1, float *y1)
Definition: EdbAffine.cxx:135

◆ CalculateFull()

Int_t EdbAffine2D::CalculateFull ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1 
)


Calculate affine transformation for 2 patterns.
b1 == b0->Transform(this);

136{
141
142 Double_t a,b,c,d,p,q;
143 a=b=c=d=p=q=0;
144
145 if(n<2) return 0;
146
147 else if(n==2){
148
149 Double_t dx0 = x0[1] - x0[0];
150 Double_t dy0 = y0[1] - y0[0];
151 Double_t dx1 = x1[1] - x1[0];
152 Double_t dy1 = y1[1] - y1[0];
153
154 Double_t s = TMath::Sqrt(dx1*dx1+dy1*dy1)/TMath::Sqrt(dx0*dx0+dy0*dy0);
155 Double_t th = Phi(dx1,dy1)-Phi(dx0,dy0);
156
157 a = s*TMath::Cos(th);
158 b = -s*TMath::Sin(th);
159 c = s*TMath::Sin(th);
160 d = s*TMath::Cos(th);
161 p = x1[0] - a*x0[0] - b*y0[0];
162 q = y1[0] - c*x0[0] - d*y0[0];
163
164 }
165 else {
166
167 Double_t
168 sx0 =0,
169 sy0 =0,
170 sx1 =0,
171 sy1 =0,
172 sx0x0 =0,
173 sy0y0 =0,
174 sx0y0 =0,
175 sx0x1 =0,
176 sx0y1 =0,
177 sx1y0 =0,
178 sy0y1 =0,
179 r =0;
180
181 for(int i=0; i<n; i++) {
182 r = 1./(i+1);
183 sx0 = sx0 *i*r + x0[i] *r;
184 sy0 = sy0 *i*r + y0[i] *r;
185 sx1 = sx1 *i*r + x1[i] *r;
186 sy1 = sy1 *i*r + y1[i] *r;
187 sx0x0 = sx0x0 *i*r + x0[i] * x0[i] *r;
188 sy0y0 = sy0y0 *i*r + y0[i] * y0[i] *r;
189 sx0y0 = sx0y0 *i*r + x0[i] * y0[i] *r;
190 sx0x1 = sx0x1 *i*r + x0[i] * x1[i] *r;
191 sx0y1 = sx0y1 *i*r + x0[i] * y1[i] *r;
192 sx1y0 = sx1y0 *i*r + x1[i] * y0[i] *r;
193 sy0y1 = sy0y1 *i*r + y0[i] * y1[i] *r;
194 }
195
196 Double_t sp0 = sx0x1 - sx0*sx1;
197 Double_t sp1 = sx1y0 - sx1*sy0;
198 Double_t sq0 = sx0y1 - sx0*sy1;
199 Double_t sq1 = sy0y1 - sy0*sy1;
200
201 Double_t sar = sx0x0 - sx0*sx0;
202 Double_t sbr = sx0y0 - sx0*sy0;
203 Double_t scr = sbr;
204 Double_t sdr = sy0y0 - sy0*sy0;
205 Double_t det = sar*sdr-sbr*scr;
206
207 if ( det == 0 ) return 0;
208
209 Double_t sa = sdr/det;
210 Double_t sb = -sbr/det;
211 Double_t sc = -scr/det;
212 Double_t sd = sar/det;
213
214 a = sa*sp0+sb*sp1;
215 b = sc*sp0+sd*sp1;
216 c = sa*sq0+sb*sq1;
217 d = sc*sq0+sd*sq1;
218 p = sx1-a*sx0-b*sy0;
219 q = sy1-c*sx0-d*sy0;
220 }
221
222 Log(3,"CalculateFull","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
223 n, a,b,c,d,p,q);
224
225 Set(a,b,c,d,p,q);
226
227 return 1;
228}

◆ CalculateTurn()

Int_t EdbAffine2D::CalculateTurn ( int  n,
float *  x0,
float *  y0,
float *  x1,
float *  y1 
)


Calculate affine transformation for 2 patterns: shift and rotation only
b1 == b0->Transform(this);

421{
426
427 Double_t a,b,c,d,p,q;
428 a=b=c=d=p=q=0;
429 Double_t X = 0.0;
430 Double_t Y = 0.0;
431 Double_t X_ = 0.0;
432 Double_t Y_ = 0.0;
433 Double_t f = 0.0;
434 Double_t e = 0.0;
435 Double_t teta1,teta2,a1,a2,b1,b2,F1=0,F2=0;
436 Int_t i;
437
438
439 if (n==0){
440 return 0;
441 }
442 else if(n==1){
443 a = 1.0;
444 b = 0.0;
445 c = 0.0;
446 d = 1.0;
447 p = x1[0] - x0[0];
448 q = y1[0] - y0[0];
449 }
450 else {
451 for (i=0;i<n;i++) {
452 X += x0[i];
453 Y += y0[i];
454 X_ += x1[i];
455 Y_ += y1[i];
456 }
457 X /= (Double_t)n;
458 Y /= (Double_t)n;
459 X_ /= (Double_t)n;
460 Y_ /= (Double_t)n;
461
462 for (i=0;i<n;i++) {
463 f += x1[i] * (x0[i] - X) + y1[i] * (y0[i] - Y);
464 d += x1[i] * (Y - y0[i]) + y1[i] * (x0[i] - X);
465 e += x1[i] * Y_ - y1[i] * X_;
466 }
467
468 teta1 = TMath::ASin((e*f-d*TMath::Sqrt(sqr(f)+sqr(d)-sqr(e)))/(sqr(f)+sqr(d)));
469 teta2 = TMath::Pi() - TMath::ASin((e*f+d*TMath::Sqrt(sqr(f)+sqr(d)-sqr(e)))/(sqr(f)+sqr(d)));
470
471 a1 = X + Y_*TMath::Sin(teta1) - X_*TMath::Cos(teta1);
472 b1 = Y - Y_*TMath::Cos(teta1) - X_*TMath::Sin(teta1);
473
474 a2 = X + Y_*TMath::Sin(teta2) - X_*TMath::Cos(teta2);
475 b2 = Y - Y_*TMath::Cos(teta2) - X_*TMath::Sin(teta2);
476
477 for (i=0;i<n;i++) {
478 F1 += sqr(x0[i] - x1[i]*TMath::Cos(teta1) + y1[i]*TMath::Sin(teta1) - a1) \
479 + sqr(y0[i] - x1[i]*TMath::Sin(teta1) - y1[i]*TMath::Cos(teta1) - b1);
480
481 F2 += sqr(x0[i] - x1[i]*TMath::Cos(teta2) + y1[i]*TMath::Sin(teta2) - a2) \
482 + sqr(y0[i] - x1[i]*TMath::Sin(teta2) - y1[i]*TMath::Cos(teta2) - b2);
483 }
484
485 if (F1<F2) {
486 a = TMath::Cos(teta1);
487 b = TMath::Sin(teta1);
488 c = -TMath::Sin(teta1);
489 d = TMath::Cos(teta1);
490 p = -a1*TMath::Cos(teta1) - b1*TMath::Sin(teta1);
491 q = a1*TMath::Sin(teta1) - b1*TMath::Cos(teta1);
492 }
493 else {
494 a = TMath::Cos(teta2);
495 b = TMath::Sin(teta2);
496 c = -TMath::Sin(teta2);
497 d = TMath::Cos(teta2);
498 p = -a2*TMath::Cos(teta2) - b2*TMath::Sin(teta2);
499 q = a2*TMath::Sin(teta2) - b2*TMath::Cos(teta2);
500 }
501 }
502
503 Log(3,"CalculateTurn","Aff2D( %6d ): %9.6f %9.6f %9.6f %9.6f %12.6f %12.6f",
504 n, a,b,c,d,p,q);
505
506 Set(a,b,c,d,p,q);
507 return 1;
508}
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: tlg2couples.C:76
Header::Center::Y
Double_t Y
Definition: tlg2couples.C:76

◆ 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

phi() is defined in [0,TWOPI]

348{
350 return TMath::Pi()+TMath::ATan2(-y,-x);
351}

◆ 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 ( )

set to self-transformation:

73{
75
76 eA11=1; eA12=0;
77 eA21=0; eA22=1;
78 eB1=0; eB2=0;
79}

◆ Rotate()

void EdbAffine2D::Rotate ( float  angle)
355{
356 EdbAffine2D aff(
357 TMath::Cos(angle), -TMath::Sin(angle),
358 TMath::Sin(angle), TMath::Cos(angle),
359 0, 0 );
360
361 Transform( &aff );
362}
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
77{ return eA11*x + eA12*y + eB1; }

◆ Ytrans()

Float_t EdbAffine2D::Ytrans ( Float_t  x,
Float_t  y 
) const
inline
78{ 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

x1 = A11*x + A12*y + B1 y1 = A21*x + A22*y + B2

◆ 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: