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

static AlignerNEW ()

Static Public Attributes

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

References EMAN::EMConsts::deg2rad, EMAN::EMData::get_xsize(), InvalidParameterException, nx, EMAN::Aligner::params, EMAN::EMData::process(), EMAN::EMConsts::rad2deg, EMAN::EMData::set_attr(), EMAN::Dict::set_default(), t, and v.

Referenced by align().

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

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.

References NAME.

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::EMObject::EMDATA, EMAN::EMObject::FLOAT, EMAN::EMObject::INT, and 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                 }

static 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 848 of file aligner.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Mon May 2 13:29:10 2011 for EMAN2 by  doxygen 1.4.7