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

rotational and translational alignment using a square qrid of Altitude and Azimuth values (the phi range is specifiable) This aligner is ported from the original tomohunter.py - it is less efficient than searching on the sphere (RT3DSphereAligner). More...

#include <aligner.h>

Inheritance diagram for EMAN::RT3DGridAligner:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual EMDataalign (EMData *this_img, EMData *to_img, const string &cmp_name="ccc.tomo", const Dict &cmp_params=Dict()) const
 See Aligner comments for more details.
virtual EMDataalign (EMData *this_img, EMData *to_img) const
 See Aligner comments for more details.
virtual vector< Dictxform_align_nbest (EMData *this_img, EMData *to_img, const unsigned int nsoln, const string &cmp_name, const Dict &cmp_params) const
 See Aligner comments for more details.
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 = "rotate_translate_3d_grid"

Detailed Description

rotational and translational alignment using a square qrid of Altitude and Azimuth values (the phi range is specifiable) This aligner is ported from the original tomohunter.py - it is less efficient than searching on the sphere (RT3DSphereAligner).

This is for use as a course aligner. For refineing alignments, use the refine_3d_grid aligner. In general this aligner is not used much and is mostly depreciated.

Parameters:
daz The angle increment in the azimuth direction
laz Lower bound for the azimuth direction
uaz Upper bound for the azimuth direction
dphi The angle increment in the phi direction
lphi Lower bound for the phi direction
uphi Upper bound for the phi direction
dalt The angle increment in the altitude direction
lalt Lower bound for the altitude direction
ualt Upper bound for the altitude direction
dotrans Do a translational search
search The maximum length of the detectable translational shift - if you supply this parameter you can not supply the maxshiftx, maxshifty or maxshiftz parameters. Each approach is mutually exclusive
searchx The maximum length of the detectable translational shift in the x direction- if you supply this parameter you can not supply the maxshift parameters
searchy The maximum length of the detectable translational shift in the y direction- if you supply this parameter you can not supply the maxshift parameters
searchz The maximum length of the detectable translational shift in the z direction- if you supply this parameter you can not supply the maxshift parameters
verbose Turn this on to have useful information printed to standard out
Author:
John Flanagan and David Woolford (ported from Mike Schmid's e2tomohuntThis is the increment applied to the inplane rotationer code - Mike Schmid is the intellectual author)
Date:
Feb 2011

Definition at line 1051 of file aligner.h.


Member Function Documentation

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

See Aligner comments for more details.

Implements EMAN::Aligner.

Definition at line 1060 of file aligner.h.

References align().

01061                         {
01062                                 return align(this_img, to_img, "ccc.tomo", Dict());
01063                         }

EMData * RT3DGridAligner::align ( EMData this_img,
EMData to_img,
const string &  cmp_name = "ccc.tomo",
const Dict cmp_params = Dict() 
) const [virtual]

See Aligner comments for more details.

Implements EMAN::Aligner.

Definition at line 1890 of file aligner.cpp.

References EMAN::EMData::process(), EMAN::EMData::set_attr(), t, and xform_align_nbest().

Referenced by align().

01891 {
01892 
01893         vector<Dict> alis = xform_align_nbest(this_img,to,1,cmp_name,cmp_params);
01894 
01895         Dict t;
01896         Transform* tr = (Transform*) alis[0]["xform.align3d"];
01897         t["transform"] = tr;
01898         EMData* soln = this_img->process("xform",t);
01899         soln->set_attr("xform.align3d",tr);
01900         delete tr; tr = 0;
01901 
01902         return soln;
01903 
01904 }

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

Implements EMAN::Aligner.

Definition at line 1075 of file aligner.h.

01076                         {
01077                                 return "3D rotational and translational alignment using specified ranges and maximum shifts";
01078                         }

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

References NAME.

01071                         {
01072                                 return NAME;
01073                         }

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

Implements EMAN::Aligner.

Definition at line 1085 of file aligner.h.

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

01086                         {
01087                                 TypeDict d;
01088                                 d.put("daz", EMObject::FLOAT,"The angle increment in the azimuth direction. Default is 10");
01089                                 d.put("az0", EMObject::FLOAT,"Lower bound for the azimuth direction. Default it 0");
01090                                 d.put("az1", EMObject::FLOAT,"Upper bound for the azimuth direction. Default it 180.0");
01091                                 d.put("dphi", EMObject::FLOAT,"The angle increment in the phi direction. Default is 10");
01092                                 d.put("phi0", EMObject::FLOAT,"Lower bound for the phi direction. Default it 0");
01093                                 d.put("phi1", EMObject::FLOAT,"Upper bound for the phi direction. Default it 360.0");
01094                                 d.put("dalt", EMObject::FLOAT,"The angle increment in the altitude direction. Default is 10");
01095                                 d.put("alt0", EMObject::FLOAT,"Lower bound for the altitude direction. Default it 0");
01096                                 d.put("alt1", EMObject::FLOAT,"Upper bound for the altitude direction. Default it 360.0");
01097                                 d.put("dotrans", EMObject::BOOL,"Do a translational search. Default is True(1)");
01098                                 d.put("search", EMObject::INT,"The maximum length of the detectable translational shift - if you supply this parameter you can not supply the maxshiftx, maxshifty or maxshiftz parameters. Each approach is mutually exclusive.");
01099                                 d.put("searchx", EMObject::INT,"The maximum length of the detectable translational shift in the x direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
01100                                 d.put("searchy", EMObject::INT,"The maximum length of the detectable translational shift in the y direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
01101                                 d.put("searchz", EMObject::INT,"The maximum length of the detectable translational shift in the z direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3");
01102                                 d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
01103                                 return d;
01104                         }

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

Definition at line 1080 of file aligner.h.

01081                         {
01082                                 return new RT3DGridAligner();
01083                         }

vector< Dict > RT3DGridAligner::xform_align_nbest ( EMData this_img,
EMData to_img,
const unsigned int  nsoln,
const string &  cmp_name,
const Dict cmp_params 
) const [virtual]

See Aligner comments for more details.

Reimplemented from EMAN::Aligner.

Definition at line 1906 of file aligner.cpp.

References EMAN::EMData::calc_ccf(), EMAN::EMData::calc_max_location_wrap(), calc_max_location_wrap_cuda(), EMAN::EMData::cmp(), copy(), data, EMAN::EMData::do_fft(), EMAN::EMData::get_ndim(), get_stats_cuda(), EMAN::EMData::get_value_at_wrap(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::Dict::has_key(), ImageDimensionException, InvalidParameterException, EMAN::Aligner::params, phi, EMAN::EMData::process(), EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::Transform::set_trans(), sqrt(), and t.

Referenced by align().

01906                                                                                                                                                                {
01907 
01908         if ( this_img->get_ndim() != 3 || to->get_ndim() != 3 ) {
01909                 throw ImageDimensionException("This aligner only works for 3D images");
01910         }
01911 
01912         int searchx = 0;
01913         int searchy = 0;
01914         int searchz = 0;
01915         
01916         bool dotrans = params.set_default("dotrans",1);
01917         if (params.has_key("search")) {
01918                 vector<string> check;
01919                 check.push_back("searchx");
01920                 check.push_back("searchy");
01921                 check.push_back("searchz");
01922                 for(vector<string>::const_iterator cit = check.begin(); cit != check.end(); ++cit) {
01923                         if (params.has_key(*cit)) throw InvalidParameterException("The search parameter is mutually exclusive of the searchx, searchy, and searchz parameters");
01924                 }
01925                 int search  = params["search"];
01926                 searchx = search;
01927                 searchy = search;
01928                 searchz = search;
01929         } else {
01930                 searchx = params.set_default("searchx",3);
01931                 searchy = params.set_default("searchy",3);
01932                 searchz = params.set_default("searchz",3);
01933         }
01934 
01935         float lalt = params.set_default("alt0",0.0f);
01936         float laz = params.set_default("az0",0.0f);
01937         float lphi = params.set_default("phi0",0.0f);
01938         float ualt = params.set_default("alt1",180.0f); // I am using 179.9 rather than 180 to avoid resampling
01939         float uphi = params.set_default("phi1",360.0f); // I am using 359.9 rather than 180 to avoid resampling 0 = 360 (for perodic functions)
01940         float uaz = params.set_default("az1",360.0f);   // I am using 359.9 rather than 180 to avoid resampling 0 = 360 (for perodic functions)
01941         float dalt = params.set_default("dalt",10.f);
01942         float daz = params.set_default("daz",10.f);
01943         float dphi = params.set_default("dphi",10.f);
01944         bool verbose = params.set_default("verbose",false);
01945         
01946         //in case we arre aligning tomos
01947         Dict altered_cmp_params(cmp_params);
01948         if (cmp_name == "ccc.tomo") {
01949                 altered_cmp_params.set_default("searchx", searchx);
01950                 altered_cmp_params.set_default("searchy", searchy);
01951                 altered_cmp_params.set_default("searchz", searchz);
01952                 altered_cmp_params.set_default("norm", true);
01953         }
01954 
01955         vector<Dict> solns;
01956         if (nsoln == 0) return solns; // What was the user thinking?
01957         for (unsigned int i = 0; i < nsoln; ++i ) {
01958                 Dict d;
01959                 d["score"] = 1.e24;
01960                 Transform t; // identity by default
01961                 d["xform.align3d"] = &t; // deep copy is going on here
01962                 solns.push_back(d);
01963         }
01964         
01965         bool tomography = (cmp_name == "ccc.tomo") ? 1 : 0;
01966         EMData * tofft = 0;
01967         if(dotrans || tomography){
01968                 tofft = to->do_fft();
01969         }
01970         
01971 #ifdef EMAN2_USING_CUDA 
01972         if(EMData::usecuda == 1) {
01973                 if(!this_img->getcudarodata()) this_img->copy_to_cudaro();  // safer call
01974                 if(!to->getcudarwdata()) to->copy_to_cuda();
01975                 if(to->getcudarwdata()){if(tofft) tofft->copy_to_cuda();}
01976         }
01977 #endif
01978 
01979         Dict d;
01980         d["type"] = "eman"; // d is used in the loop below
01981         Transform trans = Transform();
01982         bool use_cpu = true;
01983         for ( float alt = lalt; alt <= ualt; alt += dalt) {
01984                 // An optimization for the range of az is made at the top of the sphere
01985                 // If you think about it, this is just a coarse way of making this approach slightly more efficient
01986                 for ( float az = laz; az < uaz; az += daz ){
01987                         if (verbose) {
01988                                 cout << "Trying angle alt " << alt << " az " << az << endl;
01989                         }
01990                         for( float phi = lphi; phi < uphi; phi += dphi ) {
01991                                 d["alt"] = alt;
01992                                 d["phi"] = phi; 
01993                                 d["az"] = az;
01994                                 Transform t(d);
01995                                 EMData* transformed = this_img->process("xform",Dict("transform",&t));
01996                                 
01997                                 //need to do things a bit diffrent if we want to compare two tomos
01998                                 float best_score = 0.0f;
01999                                 if(dotrans || tomography){
02000                                         EMData* ccf = transformed->calc_ccf(tofft);
02001 #ifdef EMAN2_USING_CUDA 
02002                                         if(to->getcudarwdata()){
02003                                                 use_cpu = false;;
02004                                                 CudaPeakInfo* data = calc_max_location_wrap_cuda(ccf->getcudarwdata(), ccf->get_xsize(), ccf->get_ysize(), ccf->get_zsize(), searchx, searchy, searchz);
02005                                                 trans.set_trans((float)-data->px, (float)-data->py, (float)-data->pz);
02006                                                 t = trans*t;    //composite transfrom to reflect the fact that we have done a rotation first and THEN a transformation
02007                                                 if (tomography) {
02008                                                         float2 stats = get_stats_cuda(ccf->getcudarwdata(), ccf->get_xsize(), ccf->get_ysize(), ccf->get_zsize());
02009                                                         best_score = -(data->peak - stats.x)/sqrt(stats.y); // Normalize, this is better than calling the norm processor since we only need to normalize one point
02010                                                 } else {
02011                                                         best_score = -data->peak;
02012                                                 }
02013                                                 delete data;
02014                                         }
02015 #endif
02016                                         if(use_cpu){
02017                                                 if(tomography) ccf->process_inplace("normalize");       
02018                                                 IntPoint point = ccf->calc_max_location_wrap(searchx,searchy,searchz);
02019                                                 trans.set_trans((float)-point[0], (float)-point[1], (float)-point[2]);
02020                                                 t = trans*t;    //composite transfrom to reflect the fact that we have done a rotation first and THEN a transformation
02021                                                 best_score = -ccf->get_value_at_wrap(point[0], point[1], point[2]);
02022                                         }
02023                                         delete ccf; ccf =0;
02024                                         delete transformed; transformed = 0;
02025                                 }
02026 
02027                                 if(!tomography){
02028                                         if(!transformed) transformed = this_img->process("xform",Dict("transform",&t));
02029                                         best_score = transformed->cmp(cmp_name,to,cmp_params); //this is not very efficient as it creates a new cmp object for each iteration
02030                                         delete transformed; transformed = 0;
02031                                 }
02032                                 
02033                                 unsigned int j = 0;
02034                                 for ( vector<Dict>::iterator it = solns.begin(); it != solns.end(); ++it, ++j ) {
02035                                         if ( (float)(*it)["score"] > best_score ) {  // Note greater than - EMAN2 preferes minimums as a matter of policy
02036                                                 vector<Dict>::reverse_iterator rit = solns.rbegin();
02037                                                 copy(rit+1,solns.rend()-j,rit);
02038                                                 Dict& d = (*it);
02039                                                 d["score"] = best_score;
02040                                                 d["xform.align3d"] = &t;
02041                                                 break;
02042                                         }
02043                                 }
02044                         }
02045                 }
02046         }
02047 
02048         //Free up resources (for an expensive opperation like this move data to and from device is a small % of time)
02049         #ifdef EMAN2_USING_CUDA
02050                 to->copy_from_device();
02051                 this_img->ro_free();
02052         #endif
02053         
02054         if(tofft) {delete tofft; tofft = 0;}
02055         return solns;
02056 
02057 }


Member Data Documentation

const string RT3DGridAligner::NAME = "rotate_translate_3d_grid" [static]

Definition at line 1106 of file aligner.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue Jul 12 13:47:57 2011 for EMAN2 by  doxygen 1.4.7