#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 1524 of file aligner.h.
|
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 }
|
|
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 }
|
|
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 }
|
|
Get the Aligner's name. Each Aligner is identified by a unique name.
Implements EMAN::Aligner. Definition at line 1543 of file aligner.h. 01544 {
01545 return NAME;
01546 }
|
|
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 }
|
|
Definition at line 1553 of file aligner.h. 01554 { 01555 return new RT3DGridAligner(); 01556 }
|
|
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 }
|
|
Definition at line 84 of file aligner.cpp. |