EdbDistortionCorr Class Reference

#include <EdbDistortion.h>

Inheritance diagram for EdbDistortionCorr:

Collaboration diagram for EdbDistortionCorr:

Public Member Functions
void	AddCluster (EdbClDist *c)
void	CalculateCorr ()
void	CalculateGrRef ()
void	CalculateGrRefMean ()
void	CutGrRef ()
TNtuple *	DumpGr (const char *name)
	EdbDistortionCorr ()
void	GenerateCorrectionMatrix (bool do_add)
void	InitCorrMap ()
void	InitGMap ()
void	MakeDistortionMap (const char *fname, TEnv &env, const char *usefile=0, const char *addfile=0)
int	MakeViewDirectionList (EdbRun &run, int dirx, int diry, TArrayI &entries)
void	Print ()
void	ReadClusters (const char *fname, TClonesArray &arr)
void	SaveCorrMap ()
void	SetPar (TEnv &env)
void	SetPixelSize (float xpix, float ypix)
virtual	~EdbDistortionCorr ()

Public Attributes
float	eAreaMax
float	eAreaMin
bool	eDumpGr
TFile *	eOutputFile
float	eVolumeMax
float	eVolumeMin

Private Attributes
TClonesArray	eCl
float	eCorrectionMatrixStepX
float	eCorrectionMatrixStepY
EdbDistortionMap	eCorrMap
EdbDistortionMap	eCorrMap0
EdbDistortionMap	eCorrMapTot
int	eDirX
int	eDirY
EdbCell2	eGMap
TClonesArray	eGr
int	eNCenterMin
int	eNClMin
int	eNXpix
int	eNYpix
float	eR2CenterMax
float	eRmax
float	eXpix
float	eYpix

Constructor & Destructor Documentation

EdbDistortionCorr()

EdbDistortionCorr::EdbDistortionCorr

(

)

~EdbDistortionCorr()

virtual EdbDistortionCorr::~EdbDistortionCorr ( )

inlinevirtual

{}

Member Function Documentation

AddCluster()

void EdbDistortionCorr::AddCluster

(

EdbClDist *

c

)

{
  float v[2]={ c->eX+c->eXv,  c->eY+c->eYv };
  int  ir[2]={1,1};
  TObjArray arr;
  EdbSegment *s0 = 0;
  int n = eGMap.SelectObjectsC( v, ir, arr);
  if(n>100) printf("n=%d\n",n);
  if(n) { 
    float r, rmin=2.*eRmax;
    for(int i=0; i<n; i++) {
      EdbSegment *s = (EdbSegment *)arr.At(i);
      r = Sqrt( (s->GetX0()-v[0])*(s->GetX0()-v[0]) + (s->GetY0()-v[1])*(s->GetY0()-v[1]) );
      if(r<eRmax) if(r<rmin) { rmin=r; s0 = s; }
    }
  }
  if(s0) { s0->AddElement(c); s0->SetX0(v[0]); s0->SetY0(v[1]); s0->SetZ0(c->eZ); }
  else  {
    int inds = eGr.GetEntriesFast();
    EdbSegment *s = new(eGr[inds]) EdbSegment(v[0],v[1],c->eZ,0,0);
    s->AddElement(c);
    eGMap.AddObject(v, s);
  }
  
}

CalculateCorr()

void EdbDistortionCorr::CalculateCorr

(

)

{
  int ngr = eGr.GetEntries();
  Log(2,"EdbDistortionCorr::CalculateCorr","%d grains used",ngr);
  for(int i=0; i<ngr; i++) {
    EdbSegment *s = ((EdbSegment*)eGr.UncheckedAt(i));
    int nc = s->GetNelements();                                  if(!nc) continue;
    float x0 = s->GetX0(), y0= s->GetY0();
    for( int ic=0; ic<nc; ic++ ) {
      EdbClDist *c = (EdbClDist *)(s->GetElements()->UncheckedAt(ic));
      float dx = c->eX+c->eXv - x0;
      float dy = c->eY+c->eYv - y0;
      eCorrMap.Fill(c->eX, c->eY, dx,dy);
    }
  }
  eCorrMap.Norm();
}

CalculateGrRef()

void EdbDistortionCorr::CalculateGrRef

(

)

CalculateGrRefMean()

void EdbDistortionCorr::CalculateGrRefMean

(

)

{
  // take as grain reference position the mean of grains closer then eR2CenterMax to the view center
  
  int ngr = eGr.GetEntries();
  for(int i=0; i<ngr; i++) {
    EdbSegment *s = ((EdbSegment*)eGr.UncheckedAt(i));
    s->SetSide(0);
    int nc = s->GetNelements();
    double x0=0, y0=0, r0=0;
    int n0=0;
    for( int ic=0; ic<nc; ic++ ) {
      EdbClDist *c = (EdbClDist *)(s->GetElements()->UncheckedAt(ic));
      float r = Sqrt( c->eX*c->eX + c->eY*c->eY );                                     // distance to the view center
      if(r<=eR2CenterMax) { x0 += (c->eXv+c->eX); y0+=(c->eYv+c->eY); r0+=r; n0++; }
    }
    if( n0 >= eNCenterMin)   // select as a reference
    { 
      x0 /= n0;
      y0 /= n0;
      r0 /= n0;
      s->SetX0( x0 ); s->SetY0( y0 ); s->SetDz(r0);
      s->SetSide( n0 );   // use as a counter
    }
  }
}

CutGrRef()

void EdbDistortionCorr::CutGrRef

(

)

{
  // remove marginal grains from calculation
  int ngr = eGr.GetEntries();
  for(int i=0; i<ngr; i++) {
    EdbSegment *s = ((EdbSegment*)eGr.UncheckedAt(i));
    int nc = s->GetNelements();
    if(nc<eNClMin)              s->GetElements()->Clear();
    if(s->GetSide()<1)          s->GetElements()->Clear();
  }
}

DumpGr()

TNtuple * EdbDistortionCorr::DumpGr

(

const char *

name

)

{
  TNtuple *nt = new TNtuple( name,"grains dump","ig:n:xg:yg:nc:ic:xc:yc:xcv:ycv:dx:dy:w:ncenter:iscenter");
  int ngr = eGr.GetEntries();
  for(int ig=0; ig<ngr; ig++) {
    EdbSegment *s = ((EdbSegment*)eGr.UncheckedAt(ig));
    int nc = s->GetNelements();                                  if(!nc) continue;
    float dx=0, dy=0;
    for( int ic=0; ic<nc; ic++ ) {
      EdbClDist *c = (EdbClDist *)(s->GetElements()->UncheckedAt(ic));
      int j = eCorrMap.Jcell(c->eX,c->eY);
      int w = eCorrMap.Bin(j);
      if(w) {
    dx = eCorrMap.DX(j);
    dy = eCorrMap.DY(j);
      } else {dx=dy=0;}
      nt->Fill( ig, s->GetNelements(), s->GetX0(), s->GetY0(), //s->GetDz(), 
        nc, ic, c->eX, c->eY, c->eXv, c->eYv, dx,dy,w, s->GetSide(), c->eIsCenter);
    }
  }
  return nt;
}

GenerateCorrectionMatrix()

void EdbDistortionCorr::GenerateCorrectionMatrix

(

bool

do_add

)

InitCorrMap()

void EdbDistortionCorr::InitCorrMap

(

)

{
  eCorrMap.InitMap(eNXpix, eNYpix, eXpix, eYpix, eCorrectionMatrixStepX, eCorrectionMatrixStepY);
  eCorrMap0.InitMap(eNXpix, eNYpix, eXpix, eYpix, eCorrectionMatrixStepX, eCorrectionMatrixStepY);
  eCorrMapTot.InitMap(eNXpix, eNYpix, eXpix, eYpix, eCorrectionMatrixStepX, eCorrectionMatrixStepY);
}

InitGMap()

void EdbDistortionCorr::InitGMap

(

)

{
  float bin=5;
  float  mi[2] = { -eNXpix*Abs(eXpix)/2-bin, -eNYpix*Abs(eYpix)/2-bin };
  float  ma[2] = {  1.5*eNXpix*Abs(eXpix)+bin,  1.5*eNYpix*Abs(eYpix)+bin };
  int    n[2] = { int((ma[0]-mi[0])/bin), int((ma[1]-mi[1])/bin) };
  eGMap.InitCell(250, n, mi, ma);
}

MakeDistortionMap()

void EdbDistortionCorr::MakeDistortionMap	(	const char *	fname,
		TEnv &	env,
		const char *	usefile = 0,
		const char *	addfile = 0
	)

{
  SetPar(cenv);
  
  InitGMap();
  InitCorrMap();
  
  ReadClusters( fname, eCl );
  
  if(usefile) {
    eCorrMap0.ReadMatrix2Map(usefile);
    eCorrMapTot.Add(eCorrMap0);
    int ncl = eCl.GetEntries();
    for(int i=0; i<ncl; i++) {
      eCorrMap0.ApplyCorr( *((EdbClDist*)(eCl[i])) );
    }
  }
  
  CalculateGrRefMean();
  CutGrRef();
  CalculateCorr();          // calculate the differential map eCorrMap
  eCorrMapTot.Add(eCorrMap);
  
  eOutputFile = new TFile("map.root","RECREATE");
  SaveCorrMap();
  if(eDumpGr) { TNtuple *ntgr = DumpGr("grcut"); ntgr->Write(); }
  eOutputFile->Close();
 
  //Print();
}

MakeViewDirectionList()

int EdbDistortionCorr::MakeViewDirectionList	(	EdbRun &	run,
		int	dirx,
		int	diry,
		TArrayI &	entries
	)

{
  // Select views in desired direction dirx, diry {-1,0,1}
  //    -1 negative, +1 positive, 0 any direction
  
  struct {int id; float x; float y; } sv1,sv2;
  
  float tolerance = 2; // tolerance in microns
  EdbView *v=run.GetView();
  int nentr = run.GetEntries();
  entries.Set(nentr);
  int count=0;
  for(int ie=0; ie<nentr-1; ie++ ) {
    run.GetEntry(ie  , 1,0,0,0,0);
    sv1.id = v->GetViewID();
    sv1.x  = v->GetXview();
    sv1.y  = v->GetYview();
    run.GetEntry(ie+1  , 1,0,0,0,0);
    sv2.id = v->GetViewID();
    sv2.x  = v->GetXview();
    sv2.y  = v->GetYview();
    
    float dx = sv2.x-sv1.x;
    float dy = sv2.y-sv1.y;
    if(dirx) {
      if( abs(dx)<tolerance) continue;
      else if( dirx*dx < 0 ) continue;
    }
    if(diry) {
      if( abs(dy)<tolerance) continue;
      else if( diry*dy < 0 ) continue;
    }
    //printf("%d %d   %f %f\n", sv1.id, sv2.id, sv2.x-sv1.x, sv2.y-sv1.y);
    entries[count++]=ie+1;
  }
  return count;
}

Print()

void EdbDistortionCorr::Print

(

)

{
  printf("\n-----------------------------------------------------------------------------------------------------\n");
  int ncl = eCl.GetEntries();
  int ngr = eGr.GetEntries();
  int icgr=0,  iccl=0;
  for(int i=0; i<ngr; i++) {
    int nc = ((EdbSegment*)eGr.At(i))->GetNelements();
    if(nc>=eNClMin) { icgr++;  iccl+=nc; }
  }
  printf("\n%d grains found\n",ngr);
  printf("\n%d grains selected with ncl > %d and closer then %.2f to view center \n",icgr, eNClMin, eR2CenterMax );
  printf("\n%d clusters used in selected grains, mean: %d clusters/grain \n",iccl, (int)(iccl/icgr) );
  printf("Matrix definition: %d %d  %f %f view size: %.2f %.2f\n", eNXpix, eNYpix, eXpix, eYpix, eNXpix*eXpix, eNYpix*eYpix );
  
  eGMap.PrintStat();
  //eCorrMap.PrintStat();
  printf("-----------------------------------------------------------------------------------------------------\n");
}

ReadClusters()

void EdbDistortionCorr::ReadClusters	(	const char *	fname,
		TClonesArray &	arr
	)

{
  EdbRun run(fname);
  TArrayI entries;
  int nsel = MakeViewDirectionList( run, eDirX, eDirY, entries );
  printf("nsel = %d\n", nsel);
  
  int      n = run.GetEntries();
  EdbView *v = run.GetView();
  run.GetEntry(0,1);
  int count=0;
  for(int i=0; i<nsel; i++) {
    run.GetEntry( entries[i] , 1,1);
    int ncl   = v->Nclusters();
    float xv  = v->GetXview();
    float yv  = v->GetYview();
    int view  = v->GetViewID();
    printf("%6d ", ncl);
    for(int ic=0; ic<ncl; ic++) {
      EdbCluster *c = v->GetCluster(ic);
      if(c->GetArea()>eAreaMin&&c->GetArea()<eAreaMax) {
    EdbClDist *cm = (EdbClDist*)(arr[count++]);
    cm->eX=c->eX; cm->eY=c->eY; cm->eZ=c->eZ; 
    cm->eXv=xv; cm->eYv=yv;
    cm->eView=view; cm->eFrame=c->GetFrame();
    AddCluster(cm);
      }
    }
  }
  printf("\nread %d clusters from %s\n",count,fname);
}

SaveCorrMap()

void EdbDistortionCorr::SaveCorrMap

(

)

{
  eCorrMap.Save(eOutputFile, "diff");
  eCorrMapTot.Save(eOutputFile, "tot");
 
  bool batch = gROOT->IsBatch();
  gROOT->SetBatch();
  eGMap.DrawH2("eGMap","entries/bin")->Write();
  gROOT->SetBatch(batch);
  
  eCorrMapTot.GenerateCorrectionMatrix("correction_matrix.txt");
}

SetPar()

void EdbDistortionCorr::SetPar

(

TEnv &

env

)

{
  eNClMin      = env.GetValue("viewdist.NClMin" , 20);
  eR2CenterMax = env.GetValue("viewdist.R2CenterMax" , 15.);
  eRmax        = env.GetValue("viewdist.Rmax" ,  1.);
  
  eXpix  = env.GetValue("viewdist.Xpix" , 0.); // 0.30625);
  eYpix  = env.GetValue("viewdist.Ypix" , 0.); //0.30714);
  eNXpix = env.GetValue("viewdist.NXpix", 0);  //1280);
  eNYpix = env.GetValue("viewdist.NYpix", 0);  //1024);
  eDirX  = env.GetValue("viewdist.DirX",  0);  // -1,0,1
  eDirY  = env.GetValue("viewdist.DirY",  0);  // -1,0,1
  
  eCorrectionMatrixStepX = env.GetValue("viewdist.MatrixStepX", 10);
  eCorrectionMatrixStepY = env.GetValue("viewdist.MatrixStepY", 10);
  
  eDumpGr = env.GetValue("viewdist.DumpGr", 0);
  
  sscanf( env.GetValue("viewdist.ClusterAreaLimits", "0 90000000"), "%f %f", &eAreaMin, &eAreaMax);
  sscanf( env.GetValue("viewdist.ClusterVolumeLimits", "0 90000000"), "%f %f", &eVolumeMin, &eVolumeMax);
  
  printf("\n----------------------- Processing Parameters ---------------------------\n");
  printf("eNClMin\t %d\n",eNClMin);
  printf("eR2CenterMax\t %6.2f\n",eR2CenterMax);
  printf("eRmax\t %f6.2\n",eRmax);
  printf("Pixel:  %9.7f x %9.7f \n", eXpix, eYpix );
  printf("Matrix: %d x %d pixels, \t  %15.7f x %15.7f microns", eNXpix, eNYpix, eXpix*eNXpix, eYpix*eNYpix);
  printf("Clusters Area limits: %7.0f  %7.0f \n",  eAreaMin, eAreaMax );
  printf("Clusters Volume limits: %7.0f  %7.0f \n",  eVolumeMin, eVolumeMax );
  printf("-------------------------------------------------------------------------\n\n");
  
}

SetPixelSize()

void EdbDistortionCorr::SetPixelSize ( float  xpix, float  ypix  )

inline

{ eXpix=xpix; eYpix=ypix; }

Member Data Documentation

eAreaMax

float EdbDistortionCorr::eAreaMax

eAreaMin

float EdbDistortionCorr::eAreaMin

eCl

TClonesArray EdbDistortionCorr::eCl

private

eCorrectionMatrixStepX

float EdbDistortionCorr::eCorrectionMatrixStepX

private

eCorrectionMatrixStepY

float EdbDistortionCorr::eCorrectionMatrixStepY

private

eCorrMap

EdbDistortionMap EdbDistortionCorr::eCorrMap

private

eCorrMap0

EdbDistortionMap EdbDistortionCorr::eCorrMap0

private

eCorrMapTot

EdbDistortionMap EdbDistortionCorr::eCorrMapTot

private

eDirX

int EdbDistortionCorr::eDirX

private

eDirY

int EdbDistortionCorr::eDirY

private

eDumpGr

bool EdbDistortionCorr::eDumpGr

eGMap

EdbCell2 EdbDistortionCorr::eGMap

private

eGr

TClonesArray EdbDistortionCorr::eGr

private

eNCenterMin

int EdbDistortionCorr::eNCenterMin

private

eNClMin

int EdbDistortionCorr::eNClMin

private

eNXpix

int EdbDistortionCorr::eNXpix

private

eNYpix

int EdbDistortionCorr::eNYpix

private

eOutputFile

TFile* EdbDistortionCorr::eOutputFile

eR2CenterMax

float EdbDistortionCorr::eR2CenterMax

private

eRmax

float EdbDistortionCorr::eRmax

private

eVolumeMax

float EdbDistortionCorr::eVolumeMax

eVolumeMin

float EdbDistortionCorr::eVolumeMin

eXpix

float EdbDistortionCorr::eXpix

private

eYpix

float EdbDistortionCorr::eYpix

private

---

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

• src/libEMC/EdbDistortion.h
• src/libEMC/EdbDistortion.cxx