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 1169 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().

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

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 Thu Nov 17 12:45:10 2011 for EMAN2 by  doxygen 1.4.7