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

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

AlignerNEW ()

Static Public Attributes

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 1524 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 1533 of file aligner.h.

References align().

01534                         {
01535                                 return align(this_img, to_img, "ccc.tomo", Dict());
01536                         }

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

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

02430 {
02431 
02432         vector<Dict> alis = xform_align_nbest(this_img,to,1,cmp_name,cmp_params);
02433 
02434         Dict t;
02435         Transform* tr = (Transform*) alis[0]["xform.align3d"];
02436         t["transform"] = tr;
02437         EMData* soln = this_img->process("xform",t);
02438         soln->set_attr("xform.align3d",tr);
02439         delete tr; tr = 0;
02440 
02441         return soln;
02442 
02443 }

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

Implements EMAN::Aligner.

Definition at line 1548 of file aligner.h.

01549                         {
01550                                 return "3D rotational and translational alignment using specified ranges and maximum shifts";
01551                         }

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

01544                         {
01545                                 return NAME;
01546                         }

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

Implements EMAN::Aligner.

Definition at line 1558 of file aligner.h.

References EMAN::TypeDict::put().

01559                         {
01560                                 TypeDict d;
01561                                 d.put("daz", EMObject::FLOAT,"The angle increment in the azimuth direction. Default is 10");
01562                                 d.put("az0", EMObject::FLOAT,"Lower bound for the azimuth direction. Default it 0");
01563                                 d.put("az1", EMObject::FLOAT,"Upper bound for the azimuth direction. Default it 180.0");
01564                                 d.put("dphi", EMObject::FLOAT,"The angle increment in the phi direction. Default is 10");
01565                                 d.put("phi0", EMObject::FLOAT,"Lower bound for the phi direction. Default it 0");
01566                                 d.put("phi1", EMObject::FLOAT,"Upper bound for the phi direction. Default it 360.0");
01567                                 d.put("dalt", EMObject::FLOAT,"The angle increment in the altitude direction. Default is 10");
01568                                 d.put("alt0", EMObject::FLOAT,"Lower bound for the altitude direction. Default it 0");
01569                                 d.put("alt1", EMObject::FLOAT,"Upper bound for the altitude direction. Default it 360.0");
01570                                 d.put("dotrans", EMObject::BOOL,"Do a translational search. Default is True(1)");
01571                                 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.");
01572                                 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.");
01573                                 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.");
01574                                 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");
01575                                 d.put("initxform", EMObject::TRANSFORM,"The Transform storing the starting position. If unspecified the identity matrix is used");
01576                                 d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
01577                                 return d;
01578                         }

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

Definition at line 1553 of file aligner.h.

01554                         {
01555                                 return new RT3DGridAligner();
01556                         }

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

References EMAN::EMData::calc_ccf(), EMAN::EMData::calc_max_location_wrap(), calc_max_location_wrap_cuda(), EMAN::Cmp::cmp(), copy(), data, EMAN::EMData::do_fft(), EMAN::Dict::end(), 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, CudaPeakInfo::peak, phi, EMAN::EMData::process(), EMAN::EMData::process_inplace(), CudaPeakInfo::px, CudaPeakInfo::py, CudaPeakInfo::pz, EMAN::Dict::set_default(), EMAN::Transform::set_trans(), sqrt(), and t.

Referenced by align().

02445                                                                                                                                                                {
02446 
02447         if ( this_img->get_ndim() != 3 || to->get_ndim() != 3 ) {
02448                 throw ImageDimensionException("This aligner only works for 3D images");
02449         }
02450 
02451         int searchx = 0;
02452         int searchy = 0;
02453         int searchz = 0;
02454         
02455         bool dotrans = params.set_default("dotrans",1);
02456         if (params.has_key("search")) {
02457                 vector<string> check;
02458                 check.push_back("searchx");
02459                 check.push_back("searchy");
02460                 check.push_back("searchz");
02461                 for(vector<string>::const_iterator cit = check.begin(); cit != check.end(); ++cit) {
02462                         if (params.has_key(*cit)) throw InvalidParameterException("The search parameter is mutually exclusive of the searchx, searchy, and searchz parameters");
02463                 }
02464                 int search  = params["search"];
02465                 searchx = search;
02466                 searchy = search;
02467                 searchz = search;
02468         } else {
02469                 searchx = params.set_default("searchx",3);
02470                 searchy = params.set_default("searchy",3);
02471                 searchz = params.set_default("searchz",3);
02472         }
02473         
02474         Transform* initxform;
02475         if (params.has_key("initxform") ) {
02476                 // Unlike the 2d refine aligner, this class doesn't require the starting transform's
02477                 // parameters to form the starting guess. Instead the Transform itself
02478                 // is perturbed carefully (using quaternion rotation) to overcome problems that arise
02479                 // when you use orthogonally-based Euler angles
02480                 initxform = params["initxform"];
02481         }else {
02482                 initxform = new Transform(); // is the identity
02483         }
02484         
02485         float lalt = params.set_default("alt0",0.0f);
02486         float laz = params.set_default("az0",0.0f);
02487         float lphi = params.set_default("phi0",0.0f);
02488         float ualt = params.set_default("alt1",180.0f); // I am using 179.9 rather than 180 to avoid resampling
02489         float uphi = params.set_default("phi1",360.0f); // I am using 359.9 rather than 180 to avoid resampling 0 = 360 (for perodic functions)
02490         float uaz = params.set_default("az1",360.0f);   // I am using 359.9 rather than 180 to avoid resampling 0 = 360 (for perodic functions)
02491         float dalt = params.set_default("dalt",10.f);
02492         float daz = params.set_default("daz",10.f);
02493         float dphi = params.set_default("dphi",10.f);
02494         bool verbose = params.set_default("verbose",false);
02495         
02496         //in case we arre aligning tomos
02497         Dict altered_cmp_params(cmp_params);
02498         if (cmp_name == "ccc.tomo") {
02499                 altered_cmp_params.set_default("searchx", searchx);
02500                 altered_cmp_params.set_default("searchy", searchy);
02501                 altered_cmp_params.set_default("searchz", searchz);
02502                 altered_cmp_params.set_default("norm", true);
02503         }
02504 
02505         vector<Dict> solns;
02506         if (nsoln == 0) return solns; // What was the user thinking?
02507         for (unsigned int i = 0; i < nsoln; ++i ) {
02508                 Dict d;
02509                 d["score"] = 1.e24;
02510                 Transform t; // identity by default
02511                 d["xform.align3d"] = &t; // deep copy is going on here
02512                 solns.push_back(d);
02513         }
02514         
02515         bool tomography = (cmp_name == "ccc.tomo") ? 1 : 0;
02516         EMData * tofft = 0;
02517         if(dotrans || tomography){
02518                 tofft = to->do_fft();
02519         }
02520         
02521 #ifdef EMAN2_USING_CUDA 
02522         if(EMData::usecuda == 1) {
02523                 if(!this_img->getcudarodata()) this_img->copy_to_cudaro();  // safer call
02524                 if(!to->getcudarwdata()) to->copy_to_cuda();
02525                 if(to->getcudarwdata()){if(tofft) tofft->copy_to_cuda();}
02526         }
02527 #endif
02528 
02529         Dict d;
02530         d["type"] = "eman"; // d is used in the loop below
02531         Transform trans = Transform();
02532         Cmp* c = Factory <Cmp>::get(cmp_name, cmp_params);
02533         bool use_cpu = true;
02534         for ( float alt = lalt; alt <= ualt; alt += dalt) {
02535                 // An optimization for the range of az is made at the top of the sphere
02536                 // If you think about it, this is just a coarse way of making this approach slightly more efficient
02537                 for ( float az = laz; az < uaz; az += daz ){
02538                         if (verbose) {
02539                                 cout << "Trying angle alt " << alt << " az " << az << endl;
02540                         }
02541                         for( float phi = lphi; phi < uphi; phi += dphi ) {
02542                                 d["alt"] = alt;
02543                                 d["phi"] = phi; 
02544                                 d["az"] = az;
02545                                 Transform t(d);
02546                                 t = t*(*initxform);
02547                                 EMData* transformed = this_img->process("xform",Dict("transform",&t));
02548                         
02549                                 //need to do things a bit diffrent if we want to compare two tomos
02550                                 float best_score = 0.0f;
02551                                 if(dotrans || tomography){
02552                                         EMData* ccf = transformed->calc_ccf(tofft);
02553 #ifdef EMAN2_USING_CUDA 
02554                                         if(EMData::usecuda == 1){
02555                                                 use_cpu = false;;
02556                                                 CudaPeakInfo* data = calc_max_location_wrap_cuda(ccf->getcudarwdata(), ccf->get_xsize(), ccf->get_ysize(), ccf->get_zsize(), searchx, searchy, searchz);
02557                                                 trans.set_trans((float)-data->px, (float)-data->py, (float)-data->pz);
02558                                                 t = trans*t;    //composite transfrom to reflect the fact that we have done a rotation first and THEN a transformation
02559                                                 if (tomography) {
02560                                                         float2 stats = get_stats_cuda(ccf->getcudarwdata(), ccf->get_xsize(), ccf->get_ysize(), ccf->get_zsize());
02561                                                         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
02562                                                 } else {
02563                                                         best_score = -data->peak;
02564                                                 }
02565                                                 delete data;
02566                                         }
02567 #endif
02568                                         if(use_cpu){
02569                                                 if(tomography) ccf->process_inplace("normalize");       
02570                                                 IntPoint point = ccf->calc_max_location_wrap(searchx,searchy,searchz);
02571                                                 trans.set_trans((float)-point[0], (float)-point[1], (float)-point[2]);
02572                                                 t = trans*t;    //composite transfrom to reflect the fact that we have done a rotation first and THEN a transformation
02573                                                 best_score = -ccf->get_value_at_wrap(point[0], point[1], point[2]);
02574                                         }
02575                                         delete ccf; ccf =0;
02576                                         delete transformed; transformed = 0;
02577                                 }
02578 
02579                                 if(!tomography){
02580                                         if(!transformed) transformed = this_img->process("xform",Dict("transform",&t));
02581                                         best_score = c->cmp(to,transformed);
02582                                         delete transformed; transformed = 0;
02583                                 }
02584                                 
02585                                 unsigned int j = 0;
02586                                 for ( vector<Dict>::iterator it = solns.begin(); it != solns.end(); ++it, ++j ) {
02587                                         if ( (float)(*it)["score"] > best_score ) {  // Note greater than - EMAN2 preferes minimums as a matter of policy
02588                                                 vector<Dict>::reverse_iterator rit = solns.rbegin();
02589                                                 copy(rit+1,solns.rend()-j,rit);
02590                                                 Dict& d = (*it);
02591                                                 d["score"] = best_score;
02592                                                 d["xform.align3d"] = &t;
02593                                                 break;
02594                                         }
02595                                 }
02596                         }
02597                 }
02598         }
02599         
02600         if(tofft) {delete tofft; tofft = 0;}
02601         if (c != 0) delete c;
02602         
02603         return solns;
02604 
02605 }


Member Data Documentation

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

Definition at line 84 of file aligner.cpp.


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 13:47:49 2013 for EMAN2 by  doxygen 1.3.9.1