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

EMAN::RTFSlowExhaustiveAligner Class Reference

rotational, translational and flip alignment using exhaustive search. More...

#include <aligner.h>

Inheritance diagram for EMAN::RTFSlowExhaustiveAligner:

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

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) 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 = "rtf_slow_exhaustive"

Detailed Description

rotational, translational and flip alignment using exhaustive search.

This is very slow but can ensure localization of the global maximum

Parameters:
flip Optional. This is the flipped version of the images that is being aligned. If specified it will be used for the handedness check, if not a flipped copy of the image will be made
maxshift The maximum length of the detectable translational shift
transtep The translation step to take when honing the alignment, which occurs after coarse alignment
angstep The angular step (in degrees) to take in the exhaustive search for the solution angle. Typically very small i.e. 3 or smaller

Definition at line 814 of file aligner.h.


Member Function Documentation

virtual EMData* EMAN::RTFSlowExhaustiveAligner::align EMData this_img,
EMData to_img
const [inline, virtual]
 

Implements EMAN::Aligner.

Definition at line 819 of file aligner.h.

References align().

00820                 {
00821                         return align(this_img, to_img, "sqeuclidean", Dict());
00822                 }

EMData * RTFSlowExhaustiveAligner::align EMData this_img,
EMData to_img,
const string &  cmp_name,
const Dict cmp_params
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 1151 of file aligner.cpp.

References EMAN::EMData::cmp(), EMAN::EMData::get_xsize(), InvalidParameterException, nx, EMAN::EMData::process(), EMAN::EMData::set_attr(), EMAN::Dict::set_default(), EMAN::Transform::set_mirror(), EMAN::Transform::set_trans(), t, EMAN::EMData::transform(), and v.

01153 {
01154 
01155         EMData *flip = params.set_default("flip", (EMData *) 0);
01156         int maxshift = params.set_default("maxshift", -1);
01157 
01158         EMData *flipped = 0;
01159 
01160         bool delete_flipped = true;
01161         if (flip) {
01162                 delete_flipped = false;
01163                 flipped = flip;
01164         }
01165         else {
01166                 flipped = to->process("xform.flip", Dict("axis", "x"));
01167         }
01168 
01169         int nx = this_img->get_xsize();
01170 
01171         if (maxshift < 0) {
01172                 maxshift = nx / 10;
01173         }
01174 
01175         float angle_step =  params.set_default("angstep", 0.0f);
01176         if ( angle_step == 0 ) angle_step = atan2(2.0f, (float)nx);
01177         else {
01178                 angle_step *= (float)EMConsts::deg2rad; //convert to radians
01179         }
01180         float trans_step =  params.set_default("transtep",1.0f);
01181 
01182         if (trans_step <= 0) throw InvalidParameterException("transstep must be greater than 0");
01183         if (angle_step <= 0) throw InvalidParameterException("angstep must be greater than 0");
01184 
01185 
01186         Dict shrinkfactor("n",2);
01187         EMData *this_img_shrink = this_img->process("math.medianshrink",shrinkfactor);
01188         EMData *to_shrunk = to->process("math.medianshrink",shrinkfactor);
01189         EMData *flipped_shrunk = flipped->process("math.medianshrink",shrinkfactor);
01190 
01191         int bestflip = 0;
01192         float bestdx = 0;
01193         float bestdy = 0;
01194 
01195         float bestang = 0;
01196         float bestval = FLT_MAX;
01197 
01198         int half_maxshift = maxshift / 2;
01199 
01200 
01201         for (int dy = -half_maxshift; dy <= half_maxshift; ++dy) {
01202                 for (int dx = -half_maxshift; dx <= half_maxshift; ++dx) {
01203                         if (hypot(dx, dy) <= maxshift) {
01204                                 for (float ang = -angle_step * 2.0f; ang <= (float)2 * M_PI; ang += angle_step * 4.0f) {
01205                                         EMData v(*this_img_shrink);
01206                                         Transform t(Dict("type","2d","alpha",static_cast<float>(ang*EMConsts::rad2deg)));
01207                                         t.set_trans((float)dx,(float)dy);
01208                                         v.transform(t);
01209 //                                      v.rotate_translate(ang*EMConsts::rad2deg, 0.0f, 0.0f, (float)dx, (float)dy, 0.0f);
01210 
01211                                         float lc = v.cmp(cmp_name, to_shrunk, cmp_params);
01212 
01213                                         if (lc < bestval) {
01214                                                 bestval = lc;
01215                                                 bestang = ang;
01216                                                 bestdx = (float)dx;
01217                                                 bestdy = (float)dy;
01218                                                 bestflip = 0;
01219                                         }
01220 
01221                                         lc = v.cmp(cmp_name,flipped_shrunk , cmp_params);
01222                                         if (lc < bestval) {
01223                                                 bestval = lc;
01224                                                 bestang = ang;
01225                                                 bestdx = (float)dx;
01226                                                 bestdy = (float)dy;
01227                                                 bestflip = 1;
01228                                         }
01229                                 }
01230                         }
01231                 }
01232         }
01233 
01234         if( to_shrunk )
01235         {
01236                 delete to_shrunk;
01237                 to_shrunk = 0;
01238         }
01239         if( flipped_shrunk )
01240         {
01241                 delete flipped_shrunk;
01242                 flipped_shrunk = 0;
01243         }
01244         if( this_img_shrink )
01245         {
01246                 delete this_img_shrink;
01247                 this_img_shrink = 0;
01248         }
01249 
01250         bestdx *= 2;
01251         bestdy *= 2;
01252         bestval = FLT_MAX;
01253 
01254         float bestdx2 = bestdx;
01255         float bestdy2 = bestdy;
01256         float bestang2 = bestang;
01257 
01258         for (float dy = bestdy2 - 3; dy <= bestdy2 + 3; dy += trans_step) {
01259                 for (float dx = bestdx2 - 3; dx <= bestdx2 + 3; dx += trans_step) {
01260                         if (hypot(dx, dy) <= maxshift) {
01261                                 for (float ang = bestang2 - angle_step * 6.0f; ang <= bestang2 + angle_step * 6.0f; ang += angle_step) {
01262                                         EMData v(*this_img);
01263                                         Transform t(Dict("type","2d","alpha",static_cast<float>(ang*EMConsts::rad2deg)));
01264                                         t.set_trans(dx,dy);
01265                                         v.transform(t);
01266 //                                      v.rotate_translate(ang*EMConsts::rad2deg, 0.0f, 0.0f, (float)dx, (float)dy, 0.0f);
01267 
01268                                         float lc = v.cmp(cmp_name, to, cmp_params);
01269 
01270                                         if (lc < bestval) {
01271                                                 bestval = lc;
01272                                                 bestang = ang;
01273                                                 bestdx = dx;
01274                                                 bestdy = dy;
01275                                                 bestflip = 0;
01276                                         }
01277 
01278                                         lc = v.cmp(cmp_name, flipped, cmp_params);
01279 
01280                                         if (lc < bestval) {
01281                                                 bestval = lc;
01282                                                 bestang = ang;
01283                                                 bestdx = dx;
01284                                                 bestdy = dy;
01285                                                 bestflip = 1;
01286                                         }
01287                                 }
01288                         }
01289                 }
01290         }
01291 
01292         if (delete_flipped) { delete flipped; flipped = 0; }
01293 
01294         bestang *= (float)EMConsts::rad2deg;
01295         Transform t(Dict("type","2d","alpha",(float)bestang));
01296         t.set_trans(bestdx,bestdy);
01297 
01298         if (bestflip) {
01299                 t.set_mirror(true);
01300         }
01301 
01302         EMData* rslt = this_img->process("xform",Dict("transform",&t));
01303         rslt->set_attr("xform.align2d",&t);
01304 
01305         return rslt;
01306 }

virtual string EMAN::RTFSlowExhaustiveAligner::get_desc  )  const [inline, virtual]
 

Implements EMAN::Aligner.

Definition at line 828 of file aligner.h.

00829                 {
00830                         return "Experimental full 2D alignment with handedness check using more exhaustive search (not necessarily better than RTFBest)";
00831                 }

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

00824                 {
00825                         return NAME;
00826                 }

virtual TypeDict EMAN::RTFSlowExhaustiveAligner::get_param_types  )  const [inline, virtual]
 

Implements EMAN::Aligner.

Definition at line 838 of file aligner.h.

References EMAN::TypeDict::put().

00839                 {
00840                         TypeDict d;
00841                         d.put("flip", EMObject::EMDATA,"Optional. This is the flipped version of the images that is being aligned. If specified it will be used for the handedness check, if not a flipped copy of the image will be made");
00842                         d.put("maxshift", EMObject::INT,"The maximum length of the detectable translational shift");
00843                         d.put("transtep", EMObject::FLOAT,"The translation step to take when honing the alignment, which occurs after coarse alignment");
00844                         d.put("angstep", EMObject::FLOAT,"The angular step (in degrees) to take in the exhaustive search for the solution angle. Typically very small i.e. 3 or smaller.");
00845                         return d;
00846                 }

Aligner* EMAN::RTFSlowExhaustiveAligner::NEW  )  [inline, static]
 

Definition at line 833 of file aligner.h.

00834                 {
00835                         return new RTFSlowExhaustiveAligner();
00836                 }


Member Data Documentation

const string RTFSlowExhaustiveAligner::NAME = "rtf_slow_exhaustive" [static]
 

Definition at line 72 of file aligner.cpp.


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