EMAN::TranslationalAligner Class Reference
[a function or class that is CUDA enabled]

Translational 2D Alignment using cross correlation. More...

#include <aligner.h>

Inheritance diagram for EMAN::TranslationalAligner:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual EMDataalign (EMData *this_img, EMData *to_img, const string &cmp_name="dot", 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
virtual string get_name () const
 Get the Aligner's name.
virtual string get_desc () const
virtual TypeDict get_param_types () const

Static Public Member Functions

static AlignerNEW ()

Static Public Attributes

static const string NAME = "translational"

Detailed Description

Translational 2D Alignment using cross correlation.

It calculates the shift for a translational alignment, then do the translation.

Parameters:
intonly Integer pixel translations only
maxshift Maximum translation in pixels
nozero Zero translation not permitted (useful for CCD images)

Definition at line 174 of file aligner.h.


Member Function Documentation

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

Implements EMAN::Aligner.

Definition at line 180 of file aligner.h.

References align().

00181                 {
00182                         return align(this_img, to_img, "dot", Dict());
00183                 }

EMData * TranslationalAligner::align ( EMData this_img,
EMData to_img,
const string &  cmp_name = "dot",
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 123 of file aligner.cpp.

References EMAN::EMData::calc_ccf(), EMAN::EMData::calc_flcf(), EMAN::EMData::calc_max_location_wrap(), calc_max_location_wrap_cuda(), data, EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, EMAN::EMUtil::is_same_size(), nx, ny, EMAN::Aligner::params, EMAN::EMData::process(), EMAN::EMData::process_inplace(), EMAN::EMData::set_attr(), EMAN::Dict::set_default(), t, UnexpectedBehaviorException, EMAN::EMData::update(), and EMAN::EMData::zero_corner_circulant().

Referenced by align().

00125 {
00126         if (!this_img) {
00127                 return 0;
00128         }
00129 
00130         if (to && !EMUtil::is_same_size(this_img, to))
00131                 throw ImageDimensionException("Images must be the same size to perform translational alignment");
00132 
00133         EMData *cf = 0;
00134         int nx = this_img->get_xsize();
00135         int ny = this_img->get_ysize();
00136         int nz = this_img->get_zsize();
00137 
00138         int masked = params.set_default("masked",0);
00139         int useflcf = params.set_default("useflcf",0);
00140         bool use_cpu = true;
00141 
00142 #ifdef EMAN2_USING_CUDA
00143         if(EMData::usecuda == 1) {
00144                 //if(!this_img->getcudarwdata()) this_img->copy_to_cuda();
00145                 //if(to && !to->getcudarwdata()) to->copy_to_cuda();
00146                 //if (masked) throw UnexpectedBehaviorException("Masked is not yet supported in CUDA");
00147                 //if (useflcf) throw UnexpectedBehaviorException("Useflcf is not yet supported in CUDA");
00148                 //cout << "Translate on GPU" << endl;
00149                 //use_cpu = false;
00150                 //cf = this_img->calc_ccf(to);
00151         }
00152 #endif // EMAN2_USING_CUDA
00153         
00154         if (use_cpu) {
00155                 if (useflcf) cf = this_img->calc_flcf(to);
00156                 else cf = this_img->calc_ccf(to);
00157         }
00158         //return cf;
00159         // This is too expensive, esp for CUDA(we we can fix later
00160         if (masked) {
00161                 EMData *msk=this_img->process("threshold.notzero");
00162                 EMData *sqr=to->process("math.squared");
00163                 EMData *cfn=msk->calc_ccf(sqr);
00164                 cfn->process_inplace("math.sqrt");
00165                 float *d1=cf->get_data();
00166                 float *d2=cfn->get_data();
00167                 for (size_t i=0; i<(size_t)nx*ny*nz; ++i) {
00168                         if (d2[i]!=0) d1[i]/=d2[i];
00169                 }
00170                 cf->update();
00171                 delete msk;
00172                 delete sqr;
00173                 delete cfn;
00174         }
00175 
00176         int maxshiftx = params.set_default("maxshift",-1);
00177         int maxshifty = params["maxshift"];
00178         int maxshiftz = params["maxshift"];
00179         int nozero = params["nozero"];
00180 
00181         if (maxshiftx <= 0) {
00182                 maxshiftx = nx / 4;
00183                 maxshifty = ny / 4;
00184                 maxshiftz = nz / 4;
00185         }
00186 
00187         if (maxshiftx > nx / 2 - 1) maxshiftx = nx / 2 - 1;
00188         if (maxshifty > ny / 2 - 1)     maxshifty = ny / 2 - 1;
00189         if (maxshiftz > nz / 2 - 1) maxshiftz = nz / 2 - 1;
00190 
00191         if (nx == 1) maxshiftx = 0; // This is justhere for completeness really... plus it saves errors
00192         if (ny == 1) maxshifty = 0;
00193         if (nz == 1) maxshiftz = 0;
00194 
00195         // If nozero the portion of the image in the center (and its 8-connected neighborhood) is zeroed
00196         if (nozero) {
00197                 cf->zero_corner_circulant(1);
00198         }
00199         
00200         IntPoint peak;
00201 #ifdef EMAN2_USING_CUDA
00202         if (!use_cpu) {
00203                 cout << "USe CUDA TA 2" << endl;
00204                 if (nozero) throw UnexpectedBehaviorException("Nozero is not yet supported in CUDA");
00205                 CudaPeakInfo* data = calc_max_location_wrap_cuda(cf->getcudarwdata(), cf->get_xsize(), cf->get_ysize(), cf->get_zsize(), maxshiftx, maxshifty, maxshiftz);
00206                 peak = IntPoint(data->px,data->py,data->pz);
00207                 free(data);
00208         }
00209 #endif // EMAN2_USING_CUDA
00210         
00211         if (use_cpu) {
00212                 peak = cf->calc_max_location_wrap(maxshiftx, maxshifty, maxshiftz);
00213         }
00214         //cout << -peak[0] << " " << -peak[1] << " " << -peak[2] << endl;
00215         Vec3f cur_trans = Vec3f ( (float)-peak[0], (float)-peak[1], (float)-peak[2]);
00216         //cout << peak[0] << " " << peak[1] << endl;
00217 
00218         if (!to) {
00219                 cur_trans /= 2.0f; // If aligning theimage to itself then only go half way -
00220                 int intonly = params.set_default("intonly",false);
00221                 if (intonly) {
00222                         cur_trans[0] = floor(cur_trans[0] + 0.5f);
00223                         cur_trans[1] = floor(cur_trans[1] + 0.5f);
00224                         cur_trans[2] = floor(cur_trans[2] + 0.5f);
00225                 }
00226         }
00227 
00228         if( cf ){
00229                 delete cf;
00230                 cf = 0;
00231         }
00232         
00233         Dict params("trans",static_cast< vector<int> >(cur_trans));
00234         if (use_cpu){
00235                 cf=this_img->process("math.translate.int",params);
00236         }
00237         Transform t;
00238         t.set_trans(cur_trans);
00239         
00240 #ifdef EMAN2_USING_CUDA
00241         if (!use_cpu) {
00242                 cout << "USe CUDA TA 3" << endl;
00243                 //this will work just fine....
00244                 cf = this_img->process("xform",Dict("transform",&t));
00245         }
00246 #endif // EMAN2_USING_CUDA
00247 
00248         if ( nz != 1 ) {
00249 //              Transform* t = get_set_align_attr("xform.align3d",cf,this_img);
00250 //              t->set_trans(cur_trans);
00251                 cf->set_attr("xform.align3d",&t);
00252         } else if ( ny != 1 ) {
00253                 //Transform* t = get_set_align_attr("xform.align2d",cf,this_img);
00254                 cur_trans[2] = 0; // just make sure of it
00255                 t.set_trans(cur_trans);
00256                 cf->set_attr("xform.align2d",&t);
00257         }
00258         return cf;
00259 }

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

Implements EMAN::Aligner.

Definition at line 190 of file aligner.h.

00191                 {
00192                         return "Translational 2D and 3D alignment by cross-correlation";
00193                 }

virtual string EMAN::TranslationalAligner::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 185 of file aligner.h.

References NAME.

00186                 {
00187                         return NAME;
00188                 }

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

Implements EMAN::Aligner.

Definition at line 200 of file aligner.h.

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

00201                 {
00202                         TypeDict d;
00203                         d.put("intonly", EMObject::INT,"Integer pixel translations only");
00204                         d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF");
00205                         d.put("maxshift", EMObject::INT,"Maximum translation in pixels");
00206                         d.put("masked", EMObject::INT,"Treat zero pixels in 'this' as a mask for normalization (default false)");
00207                         d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
00208                         return d;
00209                 }

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

Definition at line 195 of file aligner.h.

00196                 {
00197                         return new TranslationalAligner();
00198                 }


Member Data Documentation

const string TranslationalAligner::NAME = "translational" [static]

Definition at line 211 of file aligner.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Thu Nov 17 12:45:04 2011 for EMAN2 by  doxygen 1.4.7