#include <aligner.h>
Inheritance diagram for EMAN::RT3DGridAligner:


Public Member Functions | |
| virtual EMData * | align (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 EMData * | align (EMData *this_img, EMData *to_img) const |
| See Aligner comments for more details. | |
| virtual vector< Dict > | xform_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 | |
| Aligner * | NEW () |
Static Public Attributes | |
| const string | NAME = "rotate_translate_3d_grid" |
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.
| 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 |
Definition at line 1051 of file aligner.h.
|
||||||||||||
|
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 }
|
|
||||||||||||||||||||
|
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(). 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 }
|
|
|
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 }
|
|
|
Get the Aligner's name. Each Aligner is identified by a unique name.
Implements EMAN::Aligner. Definition at line 1070 of file aligner.h. 01071 {
01072 return NAME;
01073 }
|
|
|
Implements EMAN::Aligner. Definition at line 1085 of file aligner.h. References 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 }
|
|
|
Definition at line 1080 of file aligner.h. 01081 {
01082 return new RT3DGridAligner();
01083 }
|
|
||||||||||||||||||||||||
|
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::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(). 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 }
|
|
|
Definition at line 76 of file aligner.cpp. |
1.3.9.1