TBinTracking Class Reference

#include <bitview.h>

Inheritance diagram for TBinTracking:

Collaboration diagram for TBinTracking:

Public Member Functions
EdbView *	AdoptSegment (EdbView *view, float sx, float sy, float Xmin, float Xmax, float Ymin, float Ymax, float bs, int thr, float accept, int inside=1, int excludeCommonClusters=0, int rep=1)
void	FillByteArray (TBitView *Tv)
TObjArray *	FindBinTracks (int thr)
TByteMatrix *	GetElement (double tgx, double tgy)
TByteMatrix *	GetElement (int n)
int	GetNelements (void)
TH2F *	Histo (double tgx, double tgy)
void	ImproveTracksArray (TObjArray *tracks, int thr, float accept)
TByteMatrix *	operator[] (int n)
	TBinTracking ()
	TBinTracking (double tgxmin, double tgxmax, double tgymin, double tgymax, double tgstep)
	TBinTracking (double tgxmin, double tgxmax, double tgymin, double tgymax, double tgstep, double dx, double dy, double dz)
virtual	~TBinTracking ()

Public Attributes
double	dX
double	dY
double	dZ
double	Tgstep
double	Tgxmax
double	Tgxmin
double	Tgymax
double	Tgymin
float	ZBase

Protected Attributes
TObjArray *	TByteArray

Constructor & Destructor Documentation

TBinTracking() [1/3]

TBinTracking::TBinTracking

(

)

{
    TByteArray = new TObjArray();
    dX = 1.0;
    dY = 1.0;
    dZ = 1.0;
//  TTrackArray = NULL;
}

TBinTracking() [2/3]

TBinTracking::TBinTracking	(	double	tgxmin,
		double	tgxmax,
		double	tgymin,
		double	tgymax,
		double	tgstep
	)

{
    Tgxmin = tgxmin;
    Tgxmax = tgxmax;
    Tgymin = tgymin;
    Tgymax = tgymax;
    Tgstep = tgstep;
    TByteArray = new TObjArray();
    dX = 1.0;
    dY = 1.0;
    dZ = 1.0;
//  TTrackArray = NULL;
}

TBinTracking() [3/3]

TBinTracking::TBinTracking	(	double	tgxmin,
		double	tgxmax,
		double	tgymin,
		double	tgymax,
		double	tgstep,
		double	dx,
		double	dy,
		double	dz
	)

{
    Tgxmin = tgxmin;
    Tgxmax = tgxmax;
    Tgymin = tgymin;
    Tgymax = tgymax;
    Tgstep = tgstep;
    TByteArray = new TObjArray();
    dX = dx;
    dY = dy;
    dZ = dz;
}

~TBinTracking()

TBinTracking::~TBinTracking ( )

virtual

{
    if (TByteArray) {
        TByteArray->Delete();
        delete TByteArray;
    }
/*  if (TTrackArray) {
        TTrackArray->Delete();
        delete TTrackArray;
    }*/
}

Member Function Documentation

AdoptSegment()

EdbView * TBinTracking::AdoptSegment	(	EdbView *	view,
		float	sx,
		float	sy,
		float	Xmin,
		float	Xmax,
		float	Ymin,
		float	Ymax,
		float	bs,
		int	thr,
		float	accept,
		int	inside = 1,
		int	excludeCommonClusters = 0,
		int	rep = 1
	)

{
    EdbView *vmod = view;       
//  EdbView *vmod = new EdbView(*view);
//  TClonesArray *SAr = new TClonesArray("EdbSegment");
    TObjArray *SAr = new TObjArray();
    TBitView* Tv = new TBitView();
    Tv->bitSize = bs;
    Tv->FillBitView(vmod,cfx,cfy,Xmin,Xmax,Ymin,Ymax,inside,rep);
    FillByteArray(Tv);
    TObjArray* tracks = FindBinTracks(thr);
    ImproveTracksArray(tracks,thr,bs);      // was accept instead of bs
    float X[200], Y[200] ,Z[200];
    int ntracks = tracks->GetEntries();
    track* tr = 0;
    EdbCluster* cl = 0;
    int nclusters = vmod->Nclusters();
    int sid = 0;
    int cyclelimit = 10;
//  cout<<"tracks="<<ntracks<<endl;
    for (long t=0; t<ntracks; t++) {
        tr = (track *)(tracks->At(t));
        tr->x = tr->x * bs + Xmin;
        tr->y = tr->y * bs + Ymin;
        EdbSegment* s = new EdbSegment();
        float resinit = 0;
        int pulsinit = 0;
        int cyc = 0;
CYCLE:
        cyc++;
        int n = 0;
/*      float teta,phi;
        TrackAngle(*tr,&teta,&phi);
*/
        for (long i=0; i<nclusters; i++) {
            int flag = false;
            cl = vmod->GetCluster(i);
            float xc = cl->GetX();
            float yc = cl->GetY();
            float zc = cl->GetZ();
            if (In(xc,yc,Xmin,Xmax,Ymin,Ymax)&&SatCondAccept(tr,xc,yc,zc,dX,dY,dZ,accept)) {
/*              (!(inside)||
                ((zc>(view->GetNframesTop()?Tv->GetZ2():Tv->GetZ4()))
                &&(zc<(view->GetNframesTop()?Tv->GetZ1():Tv->GetZ3()))))) {
*/
                //printf("distance=%f\n",Distance(cl->GetX(),   cl->GetY(),cl->GetZ(),*tr));
                //if (rep!=1) {
                if (inside) {
                    for (int j=0; j<Tv->GetNumberOfLayers(); j++) {
//              cout<<c->GetZ()<<" "<<GetLayer(j)->GetZ()<<endl;
                        if (zc==Tv->GetLayer(j)->GetZ()) {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag) continue;
                }
                if (int last = s->GetNelements()) {
                    EdbCluster *clsucc = ((EdbCluster *)(s->GetElements()->Last()));
                    if (zc==clsucc->GetZ()) {
                        if (Distance(clsucc->GetX(),
                                    clsucc->GetY(),
                                    clsucc->GetZ(),
                                    *tr) <= Distance(xc,yc,zc,*tr)) continue;
                        else {
                            (*(s->GetElements()))[last-1] = cl;
                            X[n-1] = xc;
                            Y[n-1] = yc;
                            Z[n-1] = zc;
                            continue;
                        }
                    }
                }
                s->AddElement(cl);
                X[n] = xc;
                Y[n] = yc;
                Z[n] = zc;
                n++;
            }
        }
        float Ax,Bx,erAx,erBx,sx,Ay,By,erAy,erBy,sy;;
        int flagx = MY_LFIT(Z,X,n,1,Ax,Bx,erAx,erBx,sx);
        int flagy = MY_LFIT(Z,Y,n,1,Ay,By,erAy,erBy,sy);
        if (flagx&&flagy) {
            int puls = s->GetNelements();
            int side = ((EdbCluster *)(s->GetElements()->At(0)))->GetSide();
            float maxz = ((EdbCluster *)(s->GetElements()->At(0)))->GetZ();
            float minz = maxz;
            for (long j=0; j<puls; j++) {
                cl = (EdbCluster *)(s->GetElements()->At(j));
                if (minz>=cl->GetZ()) minz = cl->GetZ();
                if (maxz<cl->GetZ()) maxz = cl->GetZ();
            }
            float res = sqrt((sx*sx)+(sy*sy));
            if (((pulsinit!=puls)||(res!=resinit))&&cyc<cyclelimit) {
                pulsinit = puls;
                resinit = res;
                float zl =  ZBase;          //side?maxz:minz;
                tr->tgx = Ax;
                tr->tgy = Ay;
                tr->z = zl;
                tr->x = Ax*zl+Bx;
                tr->y = Ay*zl+By;
                s->GetElements()->Clear();
                goto CYCLE;
            }
//          cout<<"cycle="<<cyc<<endl;
            float dz = maxz-minz;
            s->Set(tr->x,tr->y,tr->z,Ax,Ay,dz,side,puls,sid);
/*          for (int nclust=0; nclust<puls; nclust++) {
                cl = (EdbCluster *)(s->GetElements()->At(nclust));
                printf("< clnum=%d ", nclust);
                cl->Print();
            }
*/
//          new ((*SAr)[sid]) EdbSegment(*s);
            SAr->Add(s);
            sid++;
        }
//      delete s;
    }
    delete Tv;
    delete tracks;
 
    if (sid==0) return vmod;            //SAr;
//  int newsid=sid;
    EdbSegment* seg0 = 0;
    EdbSegment* seg = 0;
    for (int s0=0; s0<sid-1; s0++) {
//REPEAT:
        seg0 = (EdbSegment *)(SAr->At(s0));
        int newid=seg0->GetID();
        int numofdel = 0;
        int rep = 0;
 
        for (int s=s0+1; s<sid; s++) {
            seg = (EdbSegment *)(SAr->At(s));
/*          if ((seg->GetX0()==seg0->GetX0())&&(seg->GetY0()==seg0->GetY0())&&
                (seg->GetZ0()==seg0->GetZ0())&&
                (seg->GetTx()==seg0->GetTx())&&(seg->GetTy()==seg0->GetTy())&&
                (seg->GetDz()==seg0->GetDz())&&(seg->GetPuls()==seg0->GetPuls())) {
*/
            if (((fabs(seg->GetX0()-seg0->GetX0())<bs&&fabs(seg->GetY0()-seg0->GetY0())<bs)&&
//              (seg->GetZ0()==seg0->GetZ0())&&
                fabs(seg->GetTx()-seg0->GetTx())<Tgstep&&fabs(seg->GetTy()-seg0->GetTy())<Tgstep)
//              &&(seg->GetDz()==seg0->GetDz())&&(seg->GetPuls()==seg0->GetPuls())
// added at 13.11.2004 ///////////////////////////////
                ||(excludeCommonClusters
                &&CommonClusters(seg0,seg))
                )
            {
                if (seg->GetPuls()>seg0->GetPuls()) {
                    (*(SAr))[s] = seg0;
                    (*(SAr))[s0] = seg;
                    ((EdbSegment *)(SAr->At(s0)))->SetID(seg0->GetID());
                    seg0 = seg;
                    rep=1;
                }
                delete (SAr->RemoveAt(s));
                numofdel++;
//              sid--;
            }
            else {
                newid++;
                seg->SetID(newid);
//              seg0 = seg;
            }
        }
        SAr->Compress();
//      printf("sid=%d, del=%d\n",sid,numofdel);
        sid -= numofdel;
        if (rep) s0--;
    }
 
    vmod->GetHeader()->SetNsegments(sid);
//  printf("sid=%d\n",sid);
//  EdbSegment* seg = 0;
    for (int ss=0; ss<sid; ss++) {
        seg = (EdbSegment *)(SAr->At(ss));
        EdbSegment *segnew = new EdbSegment(
            seg->GetX0(),
            seg->GetY0(),
            seg->GetZ0(),
            seg->GetTx(),
            seg->GetTy(),
            seg->GetDz(),
            seg->GetSide(),
            seg->GetPuls(),
            seg->GetID());
        vmod->AddSegment(segnew);
        delete segnew;
        seg0 = ((EdbSegment *)(vmod->GetSegments()->At(ss)));
//      cout<<seg->GetNelements()<<" "<<seg->GetID()<<endl;
        for (int cc=0; cc<seg->GetNelements(); cc++) {
            cl = (EdbCluster *)(seg->GetElements()->At(cc));
            seg0->AddElement(cl);
            cl->SetSegment(seg->GetID());
        }
//      vmod->AddSegment(seg);
    }
    SAr->Delete();
    delete SAr;
    return vmod;
}

FillByteArray()

void TBinTracking::FillByteArray

(

TBitView *

Tv

)

{
    ZBase = Tv->ZBase;
    long tgxi = (long)((Tgxmax-Tgxmin)/Tgstep +1);
    long tgyi = (long)((Tgymax-Tgymin)/Tgstep +1);
    long xs, ys;
    TBitMatrix *TBit = 0;
    Tv->GetLayer(0)->GetSize(&xs,&ys);
    for (long j=0; j<tgyi; j++) {
        for (long i=0; i<tgxi; i++) {
            double tgx = Tgxmin + (i+0.5)*Tgstep;
            double tgy = Tgymin + (j+0.5)*Tgstep;
            TByteMatrix *TByte = new TByteMatrix(xs,ys,tgx,tgy);
            for (long k=0; k<Tv->GetNumberOfLayers(); k++) {
                TBit = Tv->GetLayer(k);
                long shiftX = (long)((TBit->GetZ()-ZBase)*tgx/Tv->bitSize);
                long shiftY = (long)((TBit->GetZ()-ZBase)*tgy/Tv->bitSize);
                TBit->MoveMatrix(-shiftY,-shiftX);
                *TByte += *TBit;
            }
//          TByte->Print(0);
//          _getch();
            TByteArray->Add(TByte);
//          delete TByte;
        }
    }
}

FindBinTracks()

TObjArray * TBinTracking::FindBinTracks

(

int

thr

)

{
    TByteMatrix* TByte = 0;
    TObjArray* Tob = new TObjArray();
    for (long i=0; i<GetNelements(); i++) {
        TByte = GetElement(i);
        double tgx, tgy;
        TByte->GetAngle(&tgx, &tgy);
        TObjArray* points = TByte->Pick8(0,thr);
        MyPoint* point = 0;
        for (long ii=0; ii<points->GetEntries(); ii++) {
            point = (MyPoint *)(points->At(ii));
            Tob->Add(new track(tgx, tgy, point->x, point->y, ZBase,point->height));
//          TByte->Print(0);
        }
        delete points;
    }
    return Tob;
}

GetElement() [1/2]

TByteMatrix * TBinTracking::GetElement	(	double	tgx,
		double	tgy
	)

{
    if ((tgx>=Tgxmin)&&(tgx<Tgxmax)&&(tgy>=Tgymin)&&(tgy<Tgymax)) {
        TByteMatrix *TByte = 0;
        double Tgx, Tgy;
        for (long i=0; i<GetNelements(); i++) {
            TByte = GetElement(i);
            TByte->GetAngle(&Tgx,&Tgy);
            if ((fabs(Tgx-tgx)<=Tgstep)&&(fabs(Tgy-tgy)<=Tgstep)) return TByte;
        }
    }
    return NULL;
}

GetElement() [2/2]

TByteMatrix * TBinTracking::GetElement

(

int

n

)

{
    if (n<TByteArray->GetEntries()) return (TByteMatrix *)TByteArray->At(n);
    else return NULL;
}

GetNelements()

int TBinTracking::GetNelements ( void  )

inline

{return TByteArray->GetEntries();}

Histo()

TH2F * TBinTracking::Histo	(	double	tgx,
		double	tgy
	)

{
    TByteMatrix *tbyte = 0;
    if ((tbyte = GetElement(tgx,tgy)) == NULL) return 0;
    long xs, ys;
    tbyte->GetSize(&xs,&ys);
    printf("xs=%ld, ys=%ld\n",xs,ys);
    TH2F* h2 = new TH2F("h2","h2",xs,0.,xs,ys,0., ys);
    for (long j=0; j<ys; j++) {
        for (long i=0; i<xs; i++) {
            h2->Fill(i+.5,j+.5,tbyte->GetByte(0,i,j));
        }
    }
    return h2;
}

ImproveTracksArray()

void TBinTracking::ImproveTracksArray	(	TObjArray *	tracks,
		int	thr,
		float	accept
	)

{
    track* tr = 0;
    track* tr1 = 0;
 
    int xn[8] = { 1, -1, 0,  0, 1,  1, -1, -1 }; //pixel 3x3 suburbs
    int yn[8] = { 0,  0, 1, -1, 1, -1,  1, -1 };
 
    long nc = (long)((Tgymax-Tgymin)/Tgstep);
    long nr = (long)((Tgxmax-Tgxmin)/Tgstep);
    
    int pic=0,pic1=0;
 
//  printf("hist: %d %d\n",nc,nr);
//  int npeaks=0;
    int ic,ir,in;           // declare here to fix marazmatic eror messages of VC++
    for(ic=0; ic<nc; ic++) {
        for(ir=0; ir<nr; ir++) {
            float tgx0 = Tgxmin + ir*Tgstep;
            float tgx1 = Tgxmin + (ir+1)*Tgstep;
            float tgy0 = Tgymin + ic*Tgstep;
            float tgy1 = Tgymin + (ic+1)*Tgstep;
            int nmax = -1;
            for (int i=0; i<tracks->GetEntries(); i++) {
              if ( (tr = (track *)(tracks->At(i))) )
                if (In(tr->tgx,tr->tgy,tgx0,tgx1,tgy0,tgy1)) {
                    nmax = i;
                    pic = tr->height;
                    pic1 = pic+1;
                    break;
                }
            }
            if (nmax==-1) continue;
            if (pic<thr) {
                delete (track *)(tracks->RemoveAt(nmax));
                tracks->Compress();
                continue;
            }
//          tr->height = pic1;
//          pic = GetByte(type,ic,ir); 
//          if( pix < thr)   goto NEXT;
//          pix1=pix+1;
            int n = 0;
            int nn[8];
            for(in=0; in<8; in++) {
                int icc = ic+xn[in];
                int irr = ir+yn[in];
                tgx0 = Tgxmin + irr*Tgstep;
                tgx1 = Tgxmin + (irr+1)*Tgstep;
                tgy0 = Tgymin + icc*Tgstep;
                tgy1 = Tgymin + (icc+1)*Tgstep;
                for (int i=0; i<tracks->GetEntries(); i++) {
                    if ((tr1 = (track *)(tracks->At(i))) == tr) continue;
                    if (In(tr1->tgx,tr1->tgy,tgx0,tgx1,tgy0,tgy1)&&
                        (fabs(tr->x-tr1->x)<accept&&fabs(tr->y-tr1->y)<accept)) {
                        if (pic1<=tr1->height) goto NEXT;
                        nn[n] = i;
                        n++;
                    }
                }
            }
            if (n) {
//printf("         %d \n",n);
                for (int i=0; i<n; i++) delete (track *)(tracks->RemoveAt(nn[i]));
                tr->height = pic1;
                tracks->Compress();
            }
//              pp = GetByte(type, ic+xn[in], ir+yn[in] );
//                  if( pix1 <= pp ) goto NEXT;
//              SetByte(type,ic,ir,pix1);
//      printf("peak8(%d,%d) =  %d\n",ic,ir,pix); 
//      Ta->Add(new MyPoint(ic,ir,pix));
NEXT:
        continue;
    }
  }
}

operator[]()

TByteMatrix * TBinTracking::operator[] ( int  n )

inline

{return GetElement(n);}

Member Data Documentation

dX

double TBinTracking::dX

dY

double TBinTracking::dY

dZ

double TBinTracking::dZ

TByteArray

TObjArray* TBinTracking::TByteArray

protected

Tgstep

double TBinTracking::Tgstep

Tgxmax

double TBinTracking::Tgxmax

Tgxmin

double TBinTracking::Tgxmin

Tgymax

double TBinTracking::Tgymax

Tgymin

double TBinTracking::Tgymin

ZBase

float TBinTracking::ZBase

---

The documentation for this class was generated from the following files:

• /home/antonio/fedra_doxygen/src/appl/bmatrix/bitview.h
• /home/antonio/fedra_doxygen/src/appl/bmatrix/bitview.cxx