EMAN::FRM2DAligner Class Reference

#include <aligner.h>

Inheritance diagram for EMAN::FRM2DAligner:

Inheritance graph
[legend]
Collaboration diagram for EMAN::FRM2DAligner:

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual EMDataalign (EMData *this_img, EMData *to_img, const string &cmp_name, const Dict &cmp_params=Dict()) const
 To align 'this_img' with another image passed in through its parameters.
virtual EMDataalign (EMData *this_img, EMData *to_img) const
string get_name () const
 Get the Aligner's name.
string get_desc () const
virtual TypeDict get_param_types () const

Static Public Member Functions

static AlignerNEW ()

Static Public Attributes

static const string NAME = "frm2d"

Detailed Description

Definition at line 1246 of file aligner.h.


Member Function Documentation

virtual EMData* EMAN::FRM2DAligner::align ( EMData this_img,
EMData to_img 
) const [inline, virtual]

Implements EMAN::Aligner.

Definition at line 1252 of file aligner.h.

References align().

01253                                         {
01254                                                 return align(this_img, to_img, "frc", Dict());
01255                                         }

EMData * FRM2DAligner::align ( EMData this_img,
EMData to_img,
const string &  cmp_name,
const Dict cmp_params = Dict() 
) const [virtual]

To align 'this_img' with another image passed in through its parameters.

The alignment uses a user-given comparison method to compare the two images. If none is given, a default one is used.

Parameters:
this_img The image to be compared.
to_img 'this_img" is aligned with 'to_img'.
cmp_name The comparison method to compare the two images.
cmp_params The parameter dictionary for comparison method.
Returns:
The aligned image.

Implements EMAN::Aligner.

Definition at line 2486 of file aligner.cpp.

References EMAN::Util::calc_best_fft_size(), EMAN::EMData::calc_center_of_mass(), EMAN::EMData::copy(), EMAN::EMData::do_fft(), frm_2d_Align(), EMAN::EMData::get_data(), ImageDimensionException, EMAN::EMUtil::is_same_size(), nx, EMAN::EMData::oneDfftPolar(), EMAN::EMData::set_complex(), EMAN::EMData::set_ri(), EMAN::EMData::set_size(), sqrt(), EMAN::EMData::translate(), and EMAN::EMData::unwrap_largerR().

Referenced by align().

02488 {
02489         if (!this_img) {
02490                 return 0;
02491         }
02492         if (to && !EMUtil::is_same_size(this_img, to))
02493                 throw ImageDimensionException("Images must be the same size to perform translational alignment");
02494 
02495         int nx=this_img->get_xsize();
02496         int ny=this_img->get_ysize();
02497         int size =(int)floor(M_PI*ny/4.0);
02498         size =Util::calc_best_fft_size(size);//ming   bestfftsize(size);
02499         int MAXR=ny/2;
02500         //int MAXR=size;
02501         EMData *this_temp=this_img->copy(); // ming change avg to to
02502         FloatPoint com_test,com_test1;
02503         com_test=this_temp->calc_center_of_mass();//ming add
02504         float com_this_x=com_test[0];
02505         float com_this_y=com_test[1];
02506         delete this_temp;
02507 
02508 
02509         EMData *that_temp=to->copy();
02510         com_test1=that_temp->calc_center_of_mass();
02511         float com_with_x=com_test1[0];
02512         float com_with_y=com_test1[1];
02513         delete that_temp;
02514 
02515         EMData *avg_frm=to->copy();
02516         float dx,dy;
02517         //float dx=-(com_with_x-nx/2); //ming
02518         //float dy=-(com_with_y-ny/2); //ming
02519         //avg_frm->translate(dx,dy,0.0);
02520         EMData *withpcs=avg_frm->unwrap_largerR(0,MAXR,size,float(MAXR)); // ming, something wrong inside this subroutine
02521         //EMData *withpcs=avg_frm->unwrap(-1,-1,-1,0,0,1);
02522         EMData *withpcsfft=withpcs->oneDfftPolar(size, float(MAXR), float(MAXR));
02523 
02524         float *sampl_fft=withpcsfft->get_data(); //
02525         delete avg_frm;
02526         delete withpcs;
02527 
02528         int bw=size/2;
02529         unsigned long ind1=0, ind2=0, ind3=0, ind4=0, ind41=0;
02530         float pi2=2.0*M_PI, r2;
02531 
02532         EMData *data_in=new EMData;
02533         data_in->set_complex(true);
02534         data_in->set_ri(1);
02535         data_in->set_size(2*size,1,1);
02536         float * comp_in=data_in->get_data();
02537 
02538         int p_max=3;
02539         float *frm2dhhat=0;
02540 
02541         if( (frm2dhhat=(float *)malloc((p_max+1)*(size+2)*bw*size*2* sizeof(float)))==NULL){
02542                 cout <<"Error in allocating memory 13. \n";
02543                 exit(1);
02544         }
02545         //printf("p_max=%d\n",p_max);
02546         float *sb=0, *cb=0;             // sin(beta) and cos(beta) for get h_hat, 300>size
02547         if((sb=new float[size])==NULL||(cb=new float[size])==NULL) {
02548                 cout <<"can't allocate more memory, terminating. \n";
02549                 exit(1);
02550         }
02551         for(int i=0;i<size;++i) {        // beta sampling, to calculate beta' and r'
02552                 float beta=i*M_PI/bw;
02553                 sb[i]=sin(beta);
02554                 cb[i]=cos(beta);
02555         }
02556 
02557         for(int p=0; p<=p_max; ++p){
02558                 ind1=p*size*bw;
02559         float pp2=(float)(p*p);
02560                 for(int n=0;n<bw;++n){         /* loop for n */
02561                 ind2=ind1+n;
02562                 for(int r=0;r<=MAXR;++r) {
02563                                 ind3=(ind2+r*bw)*size;
02564                         float rr2=(float)(r*r);
02565                                 float rp2=(float)(r*p);
02566                         for(int i=0;i<size;++i){                            // beta sampling, to get beta' and r'
02567                                 r2=std::sqrt((float)(rr2+pp2-2.0*rp2*cb[i]));   // r2->r'
02568                                 int r1=(int)floor(r2+0.5f);                        // for computing gn(r')
02569                                 if(r1>MAXR){
02570                                         comp_in[2*i]=0.0f;
02571                                         comp_in[2*i+1]=0.0f;
02572                                 }
02573                                 else{
02574                                         float gn_r=sampl_fft[2*n+r1*(size+2)];           // real part of gn(r')
02575                                         float gn_i=sampl_fft[2*n+1+r1*(size+2)];           // imaginary part of gn(r')
02576                                                 float sb2, cb2, cn, sn;
02577                                                 if(n!=0){
02578                                                         if(r2 != 0.0){
02579                                                                 sb2=r*sb[i]/r2;
02580                                                                 cb2=(r*cb[i]-p)/r2;
02581                                                         }
02582                                                 else{
02583                                                                 sb2=0.0;
02584                                                                 cb2=1.0;
02585                                                         }
02586                                                 if(sb2>1.0) sb2= 1.0f;
02587                                                 if(sb2<-1.0)sb2=-1.0f;
02588                                                 if(cb2>1.0) cb2= 1.0f;
02589                                                 if(cb2<-1.0)cb2=-1.0f;
02590                                                 float beta2=atan2(sb2,cb2);
02591                                                 if(beta2<0.0) beta2+=pi2;
02592                                                 float nb2=n*beta2;
02593                                                 cn=cos(nb2);
02594                                                         sn=sin(nb2);
02595                                                 }
02596                                         else{
02597                                                         cn=1.0f; sn=0.0f;
02598                                                 }
02599                                                 comp_in[2*i]=cn*gn_r-sn*gn_i;
02600                                                 comp_in[2*i+1]=-(cn*gn_i+sn*gn_r);
02601                                 }
02602                         }
02603                         EMData *data_out;
02604                         data_out=data_in->do_fft();
02605                         float * comp_out=data_out->get_data();
02606                         for(int m=0;m<size;m++){                                     // store hat{h(n,r,p)}(m)
02607                                         ind4=(ind3+m)*2;
02608                                         ind41=ind4+1;
02609                                         frm2dhhat[ind4]=comp_out[2*m];
02610                                         frm2dhhat[ind41]=comp_out[2*m+1];
02611                                 }
02612                         delete data_out;
02613                         }
02614                 }
02615         }
02616 
02617         delete[] sb;
02618         delete[] cb;
02619         delete data_in;
02620         delete withpcsfft;
02621 
02622         float dot_frm0=0.0f, dot_frm1=0.0f;
02623         EMData *da_nFlip=0, *da_yFlip=0, *dr_frm=0;
02624         //dr_frm=this_img->copy();
02625         for (int iFlip=0;iFlip<=1;++iFlip){
02626                 if (iFlip==0){dr_frm=this_img->copy();  da_nFlip=this_img->copy();}
02627                 else {dr_frm=this_img->copy(); da_yFlip=this_img->copy();}
02628                 if(iFlip==1) {com_this_x=nx-com_this_x; } //ming   // image mirror about Y axis, so y keeps the same
02629 
02630                 dx=-(com_this_x-nx/2); //ming
02631                 dy=-(com_this_y-ny/2); //ming
02632                 dr_frm->translate(dx,dy,0.0); // this
02633                 EMData *selfpcs = dr_frm->unwrap_largerR(0,MAXR,size, (float)MAXR);
02634                 //EMData *selfpcs=dr_frm->unwrap(-1,-1,-1,0,0,1);
02635                 EMData *selfpcsfft = selfpcs->oneDfftPolar(size, (float)MAXR, (float)MAXR);
02636                 delete selfpcs;
02637                 delete dr_frm;
02638                 if(iFlip==0)
02639                         dot_frm0=frm_2d_Align(da_nFlip,to, frm2dhhat, selfpcsfft, p_max, size, com_this_x, com_this_y, com_with_x, com_with_y,cmp_name,cmp_params);
02640                 else
02641                         dot_frm1=frm_2d_Align(da_yFlip,to, frm2dhhat, selfpcsfft, p_max, size, com_this_x, com_this_y, com_with_x, com_with_y,cmp_name,cmp_params);
02642                 delete selfpcsfft;
02643         }
02644 
02645         delete[] frm2dhhat;
02646         if(dot_frm0 <=dot_frm1) {
02647 #ifdef DEBUG
02648                 printf("best_corre=%f, no flip\n",dot_frm0);
02649 #endif
02650                 delete da_yFlip;
02651                 return da_nFlip;
02652         }
02653         else {
02654 #ifdef DEBUG
02655                 printf("best_corre=%f, flipped\n",dot_frm1);
02656 #endif
02657                 delete da_nFlip;
02658                 return da_yFlip;
02659         }
02660 }

string EMAN::FRM2DAligner::get_desc (  )  const [inline, virtual]

Implements EMAN::Aligner.

Definition at line 1262 of file aligner.h.

01263                                         {
01264                                                 return "FRM2D uses two rotational parameters and one translational parameter";
01265                                         }

string EMAN::FRM2DAligner::get_name (  )  const [inline, virtual]

Get the Aligner's name.

Each Aligner is identified by a unique name.

Returns:
The Aligner's name.

Implements EMAN::Aligner.

Definition at line 1257 of file aligner.h.

References NAME.

01258                                         {
01259                                                 return NAME;
01260                                         }

virtual TypeDict EMAN::FRM2DAligner::get_param_types (  )  const [inline, virtual]

Implements EMAN::Aligner.

Definition at line 1271 of file aligner.h.

References EMAN::EMObject::INT, and EMAN::TypeDict::put().

01272                                         {
01273                                                         TypeDict d;
01274                                                         d.put("maxshift", EMObject::INT,"Maximum translation in pixels in any direction. If the solution yields a shift beyond this value in any direction, then the refinement is judged a failure and the original alignment is used as the solution.");
01275 
01276                                                         //d.put("p_max", EMObject::FLOAT,"p_max is");
01277                                                         return d;
01278                                         }

static Aligner* EMAN::FRM2DAligner::NEW (  )  [inline, static]

Definition at line 1267 of file aligner.h.

01268                                         {
01269                                                 return new FRM2DAligner();
01270                                         }


Member Data Documentation

const string FRM2DAligner::NAME = "frm2d" [static]

Definition at line 1280 of file aligner.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue Jul 12 13:47:59 2011 for EMAN2 by  doxygen 1.4.7