Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

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

AlignerNEW ()

Static Public Attributes

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 116 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(), CudaPeakInfo::px, CudaPeakInfo::py, CudaPeakInfo::pz, EMAN::EMData::set_attr(), EMAN::Dict::set_default(), EMAN::Transform::set_trans(), t, UnexpectedBehaviorException, EMAN::EMData::update(), EMAN::Vec3f, and EMAN::EMData::zero_corner_circulant().

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

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.

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

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 58 of file aligner.cpp.


The documentation for this class was generated from the following files:
Generated on Mon Mar 7 18:19:56 2011 for EMAN2 by  doxygen 1.3.9.1