#include <ctf.h>
Inheritance diagram for EMAN::EMAN2Ctf:


Public Member Functions | |
| vector< float > | get_snr () |
| void | set_snr (const vector< float > &vf) |
| vector< float > | get_background () |
| void | set_background (const vector< float > &vf) |
| EMAN2Ctf () | |
| EMAN2Ctf (const vector< float > &vf) | |
| ~EMAN2Ctf () | |
| vector< float > | compute_1d (int size, float ds, CtfType type, XYData *struct_factor=0) |
| void | compute_2d_real (EMData *image, CtfType type, XYData *struct_factor=0) |
| void | compute_2d_complex (EMData *image, CtfType type, XYData *struct_factor=0) |
| int | from_string (const string &ctf) |
| string | to_string () const |
| void | from_dict (const Dict &dict) |
| Dict | to_dict () const |
| void | from_vector (const vector< float > &vctf) |
| vector< float > | to_vector () const |
| void | copy_from (const Ctf *new_ctf) |
| bool | equal (const Ctf *ctf1) const |
Public Attributes | |
| float | dfdiff |
| float | dfang |
| float | ampcont |
| float | dsbg |
| vector< float > | background |
| vector< float > | snr |
Private Member Functions | |
| float | calc_amp1 () |
| float | calc_lambda () |
| float | calc_g1 () |
| float | calc_g2 () |
| float | calc_gamma (float g1, float g2, float s) |
| float | calc_ctf1 (float g, float gamma, float s) |
| float | calc_amplitude (float gamma) |
| float | calc_noise (float s) |
Definition at line 222 of file ctf.h.
|
|
Definition at line 470 of file ctf.cpp. References ampcont, background, dfang, dfdiff, dsbg, and snr. 00471 {
00472 defocus = 0;
00473 dfdiff = 0;
00474 dfang = 0;
00475 bfactor = 0;
00476 ampcont = 0;
00477 voltage = 0;
00478 cs = 0;
00479 apix = 1.0;
00480 dsbg=-1;
00481 background.clear();
00482 snr.clear();
00483 }
|
|
|
Definition at line 244 of file ctf.h. 00244 {from_vector(vf);} //for unpickling
|
|
|
Definition at line 486 of file ctf.cpp. 00487 {
00488 }
|
|
|
Definition at line 264 of file ctf.h. References sqrt(). Referenced by compute_1d(), and compute_2d_complex(). 00265 {
00266 return (sqrt(1 - ampcont * ampcont/10000.0f));
00267 }
|
|
|
Definition at line 302 of file ctf.h. Referenced by compute_2d_complex(). 00303 {
00304 float t1 = sqrt(1.0f - ampcont * ampcont/10000.0f) * sin(gamma);
00305 float v = (t1 + ampcont/100.0f * cos(gamma));
00306 return v;
00307 }
|
|
||||||||||||||||
|
Definition at line 296 of file ctf.h. Referenced by compute_1d(), and compute_2d_complex(). 00297 {
00298 float r = exp(-(bfactor/4.0f * s * s)) * (g * sin(gamma) + ampcont/100.0f * cos(gamma));
00299 return r;
00300 }
|
|
|
Definition at line 275 of file ctf.h. Referenced by compute_1d(), and compute_2d_complex(). 00276 {
00277 float lambda = calc_lambda();
00278 float g1 = 2.5e6f * cs * lambda * lambda * lambda;
00279 return g1;
00280 }
|
|
|
Definition at line 282 of file ctf.h. Referenced by compute_1d(), and compute_2d_complex(). 00283 {
00284 float lambda = calc_lambda();
00285 float g2 = 5000.0f * -defocus * lambda;
00286 return g2;
00287 }
|
|
||||||||||||||||
|
Definition at line 289 of file ctf.h. Referenced by compute_1d(), and compute_2d_complex(). 00290 {
00291 float s2 = s * s;
00292 float gamma = (float) (-2 * M_PI * (g1 * s2 * s2 + g2 * s2));
00293 return gamma;
00294 }
|
|
|
Definition at line 269 of file ctf.h. References sqrt(). 00270 {
00271 float lambda = 12.2639f / sqrt(voltage * 1000.0f + 0.97845f * voltage * voltage);
00272 return lambda;
00273 }
|
|
|
Definition at line 309 of file ctf.h. Referenced by compute_1d(), and compute_2d_complex(). 00310 {
00311 int si=(int)(s/dsbg);
00312 if (si>(int)background.size()||si<0) return background.back();
00313 return background[si];
00314 }
|
|
||||||||||||||||||||
|
Implements EMAN::Ctf. Definition at line 643 of file ctf.cpp. References Assert, background, calc_amp1(), calc_ctf1(), calc_g1(), calc_g2(), calc_gamma(), calc_noise(), div(), EMAN::XYData::get_yatx(), max_int(), min_int(), snr, x, and y. 00644 {
00645 Assert(size > 0);
00646
00647 // float tmp_f1 = sqrt((float) 2) * size / 2;
00648 // int np = (int) ceil(tmp_f1) + 2;
00649 int np=size/2;
00650 vector < float >r;
00651
00652 r.resize(np);
00653
00654 // float ds = 1 / (apix * size);
00655 float s = 0;
00656 float g1 = calc_g1();
00657 float g2 = calc_g2();
00658 float amp1 = calc_amp1();
00659
00660 switch (type) {
00661 case CTF_AMP:
00662 for (int i = 0; i < np; i++) {
00663 float gamma = calc_gamma(g1, g2, s);
00664 r[i] = calc_ctf1(amp1, gamma, s);
00665 s += ds;
00666 }
00667 break;
00668
00669 case CTF_SIGN:
00670 for (int i = 0; i < np; i++) {
00671 float gamma = calc_gamma(g1, g2, s);
00672 r[i] = calc_ctf1(amp1, gamma, s)>=0?1.0f:-1.0f;
00673 s += ds;
00674 }
00675 break;
00676
00677 case CTF_BACKGROUND:
00678 for (int i = 0; i < np; i++) {
00679 float f = s/dsbg;
00680 int j = (int)floor(f);
00681 f-=j;
00682 if (j>(int)background.size()-2) r[i]=background.back();
00683 else r[i]=background[j]*(1.0f-f)+background[j+1]*f;
00684 s+=ds;
00685 }
00686 break;
00687
00688 case CTF_SNR:
00689 for (int i = 0; i < np; i++) {
00690 float f = s/dsbg;
00691 int j = (int)floor(f);
00692 f-=j;
00693 if (j>(int)snr.size()-2) r[i]=snr.back();
00694 else r[i]=snr[j]*(1.0f-f)+snr[j+1]*f;
00695 // printf("%d\t%f\n",j,snr[j]);
00696 s+=ds;
00697 }
00698 break;
00699 case CTF_SNR_SMOOTH:
00700 // This apparently complicated routine tries to make a nice smooth and accurate SNR curve. It does this
00701 // by fitting local regions of the SNR vs the theoretical SNR (theoretical CTF^2/measured background),
00702 // then taking the slope of the result times the theoretical SNR to produce a local SNR estimate
00703
00704 { // <- is to permit new temporary value allocation
00705 vector < float >tsnr; // theoretical SNR
00706 tsnr.resize(np);
00707 vector < float >dsnr; // data SNR
00708 dsnr.resize(np);
00709
00710 float s0=s;
00711
00712 for (int i = 0; i < np; i++) {
00713 float gamma = calc_gamma(g1, g2, s);
00714 tsnr[i] = calc_ctf1(amp1, gamma, s); // ctf amp
00715
00716 // background value
00717 float f = s/dsbg;
00718 int j = (int)floor(f);
00719 f-=j;
00720 float bg;
00721 if (j>(int)background.size()-2) bg=background.back();
00722 else bg=background[j]*(1.0f-f)+background[j+1]*f;
00723 if (bg <=0) bg=.001f;
00724
00725 tsnr[i] = tsnr[i]*tsnr[i]/bg; // This is now a SNR curve
00726 if (sf && s) {
00727 tsnr[i] *= sf->get_yatx(s);
00728 }
00729
00730
00731 // This is the SNR computed from the data without fitting
00732 if (j>(int)snr.size()-2) dsnr[i]=snr.back();
00733 else dsnr[i]=snr[j]*(1.0f-f)+snr[j+1]*f;
00734
00735 s+=ds;
00736 }
00737
00738 int npsm=np/25; // 1/2 number of points to smooth over, 25 is arbitrary
00739 if (npsm<2) npsm=2;
00740
00741 s=s0;
00742 for (int i = 1; i < np; i++) {
00743 // simple linear regression embedded here
00744 double sum = 0;
00745 double sum_x = 0;
00746 double sum_y = 0;
00747 double sum_xx = 0;
00748 double sum_xy = 0;
00749
00750 for (int k=max_int(i-npsm,1); k<=min_int(i+npsm,np); k++) {
00751 double y = dsnr[k];
00752 double x = tsnr[k];
00753
00754 sum_x += x;
00755 sum_y += y;
00756 sum_xx += x * x;
00757 sum_xy += x * y;
00758 sum++;
00759 }
00760
00761 double div = sum * sum_xx - sum_x * sum_x;
00762 // if (div == 0) {
00763 // div = 0.0000001f;
00764 // }
00765
00766 // *intercept = (float) ((sum_xx * sum_y - sum_x * sum_xy) / div);
00767 // *slope = (float) ((sum * sum_xy - sum_x * sum_y) / div);
00768
00769 if (div!=0.0) r[i]=(float) ((sum * sum_xy - sum_x * sum_y) / div)*tsnr[i];
00770 else r[i]=0.0;
00771 if (r[i]<0) r[i]=0;
00772
00773 s+=ds;
00774 }
00775 r[0]=0;
00776 }
00777 break;
00778
00779 case CTF_WIENER_FILTER:
00780 // if (!sf) {
00781 // LOGERR("CTF computation error, no SF found\n");
00782 // return r;
00783 // }
00784
00785 for (int i = 0; i < np; i++) {
00786 float f = s/dsbg;
00787 int j = (int)floor(f);
00788 float bg;
00789 f-=j;
00790 if (j>(int)snr.size()-2) {
00791 /* r[i]=snr.back();
00792 bg=background.back();*/
00793 r[i]=0;
00794 }
00795 else {
00796 r[i]=snr[j]*(1.0f-f)+snr[j+1]*f;
00797 bg=background[j]*(1.0f-f)+background[j+1]*f;
00798 }
00799 if (r[i]<0) r[i]=0;
00800 r[i]=r[i]/(r[i]+1.0f); // Full Wiener filter assuming perfect image with noise
00801 // r[i]=sqrt(r[i]/bg)/(r[i]+1.0); // Wiener filter with 1/CTF term (sort of) to restore image then filter
00802 s+=ds;
00803 }
00804 r[0]=0;
00805 break;
00806
00807 case CTF_TOTAL:
00808
00809 for (int i = 0; i < np; i++) {
00810 float gamma = calc_gamma(g1, g2, s);
00811 if (sf) {
00812 r[i] = calc_ctf1(amp1, gamma, s);
00813 r[i] = r[i] * r[i] * sf->get_yatx(s) + calc_noise(s);
00814 }
00815 else {
00816 r[i] = calc_ctf1(amp1, gamma, s);
00817 r[i] = r[i] * r[i] + calc_noise(s);
00818 }
00819 s += ds;
00820 }
00821 break;
00822 default:
00823 break;
00824 }
00825
00826 return r;
00827 }
|
|
||||||||||||||||
|
Implements EMAN::Ctf. Definition at line 838 of file ctf.cpp. References background, calc_amp1(), calc_amplitude(), calc_ctf1(), calc_g1(), calc_g2(), calc_gamma(), calc_noise(), dsbg, EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::XYData::get_yatx(), EMAN::EMData::get_ysize(), EMAN::Util::hypot_fast(), EMAN::EMData::is_complex(), LOGERR, nx, ny, snr, EMAN::EMData::to_one(), EMAN::EMData::update(), v, x, and y. 00839 {
00840 if (!image) {
00841 LOGERR("image is null. cannot computer 2D complex CTF");
00842 return;
00843 }
00844
00845 if (image->is_complex() == false) {
00846 LOGERR("compute_2d_complex can only work on complex images");
00847 return;
00848 }
00849
00850 int nx = image->get_xsize();
00851 int ny = image->get_ysize();
00852
00853 if ((ny%2==1 && nx!=ny+1) || (ny%2==0 && nx != ny + 2)) {
00854 printf("nx=%d ny=%d\n",nx,ny);
00855 LOGERR("compute_2d_complex only works on (nx, nx-2) images");
00856 return;
00857 }
00858
00859 float ds = 1.0f / (apix * ny);
00860 image->to_one();
00861
00862 float *d = image->get_data();
00863 float g1 = calc_g1();
00864 float g2 = calc_g2();
00865 float amp1 = calc_amp1();
00866
00867 if (type == CTF_BACKGROUND) {
00868 for (int y = -ny/2; y < ny/2; y++) {
00869 int y2=(y+ny)%ny;
00870 int ynx = y2 * nx;
00871
00872 for (int x = 0; x < nx / 2; x++) {
00873 float s = (float) Util::hypot_fast(x, y ) * ds;
00874 d[x * 2 + ynx] = calc_noise(s);
00875 d[x * 2 + ynx + 1] = 0; // The phase is somewhat arbitrary
00876 }
00877 }
00878 }
00879 else if (type == CTF_AMP) {
00880 for (int y = -ny/2; y < ny/2; y++) {
00881 int y2=(y+ny)%ny;
00882 int ynx = y2 * nx;
00883
00884 for (int x = 0; x < nx / 2; x++) {
00885 float s = (float)Util::hypot_fast(x,y ) * ds;
00886 float gamma = calc_gamma(g1, g2, s);
00887 float v = calc_ctf1(amp1, gamma, s);
00888 // float v = calc_amplitude(gamma);
00889 d[x * 2 + ynx] = v;
00890 d[x * 2 + ynx + 1] = 0;
00891 }
00892 }
00893 }
00894 else if (type == CTF_SIGN) {
00895 for (int y = -ny/2; y < ny/2; y++) {
00896 int y2=(y+ny)%ny;
00897 int ynx = y2 * nx;
00898 for (int x = 0; x < nx / 2; x++) {
00899 float s = (float)Util::hypot_fast(x,y ) * ds;
00900 float gamma = calc_gamma(g1, g2, s);
00901 float v = calc_amplitude(gamma);
00902 d[x * 2 + ynx] = v >= 0 ? 1.0f : -1.0f;
00903 d[x * 2 + ynx + 1] = 0;
00904 }
00905 }
00906 }
00907 else if (type == CTF_SNR) {
00908
00909 for (int y = -ny/2; y < ny/2; y++) {
00910 int y2=(y+ny)%ny;
00911 int ynx = y2 * nx;
00912
00913 for (int x = 0; x < nx / 2; x++) {
00914
00915 float s = (float)Util::hypot_fast(x,y ) * ds;
00916 float f = s/dsbg;
00917 int j = (int)floor(f);
00918 f-=j;
00919 if (j>(int)snr.size()-2) d[x*2+ynx]=snr.back();
00920 else d[x*2+ynx]=snr[j]*(1.0f-f)+snr[j+1]*f;
00921 d[x * 2 + ynx + 1] = 0;
00922 }
00923 }
00924 d[0]=0;
00925 }
00926 else if (type == CTF_SNR_SMOOTH) {
00927 for (int y = -ny/2; y < ny/2; y++) {
00928 int y2=(y+ny)%ny;
00929 int ynx = y2 * nx;
00930
00931 for (int x = 0; x < nx / 2; x++) {
00932
00933 float s = (float)Util::hypot_fast(x,y ) * ds;
00934 float f = s/dsbg;
00935 int j = (int)floor(f);
00936 f-=j;
00937 if (j>(int)snr.size()-2) d[x*2+ynx]=snr.back();
00938 else d[x*2+ynx]=snr[j]*(1.0f-f)+snr[j+1]*f;
00939 d[x * 2 + ynx + 1] = 0;
00940 }
00941 }
00942 d[0]=0;
00943 }
00944 else if (type == CTF_WIENER_FILTER) {
00945 if (dsbg==0) printf("Warning, DSBG set to 0\n");
00946 for (int y = -ny/2; y < ny/2; y++) {
00947 int y2=(y+ny)%ny;
00948 int ynx = y2 * nx;
00949
00950 for (int x = 0; x < nx / 2; x++) {
00951
00952 float s = (float)Util::hypot_fast(x,y ) * ds;
00953 float f = s/dsbg;
00954 int j = (int)floor(f);
00955 float bg,snrf;
00956 f-=j;
00957 if (j>(int)snr.size()-2) {
00958 /* bg=background.back();
00959 d[x*2+ynx]=snr.back()/(snr.back()+1.0);*/
00960 d[x*2+ynx]=0;
00961 }
00962 else {
00963 bg=background[j]*(1.0f-f)+background[j+1]*f;
00964 snrf=snr[j]*(1.0f-f)+snr[j+1]*f;
00965
00966 // printf("%d\t%f\n",x,sqrt(snrf/bg)/(snrf+1.0));
00967 if (snrf<0) snrf=0.0;
00968 // d[x*2+ynx]=sqrt(snrf/bg)/(snrf+1.0); // Note that this is a Wiener filter with a 1/CTF term to compensate for the filtration already applied, but needs to be multiplied by the structure factor
00969 d[x*2+ynx]=snrf/(snrf+1); // This is just the simple Wiener filter
00970
00971 }
00972 d[x * 2 + ynx + 1] = 0;
00973 }
00974 }
00975 d[0]=0;
00976 }
00977 else if (type == CTF_TOTAL) {
00978 float amp1 = calc_amp1();
00979
00980 for (int y = -ny/2; y < ny/2; y++) {
00981 int y2=(y+ny)%ny;
00982 int ynx = y2 * nx;
00983
00984 for (int x = 0; x < nx / 2; x++) {
00985
00986 float s = (float)Util::hypot_fast(x,y ) * ds;
00987 float gamma = calc_gamma(g1, g2, s);
00988 float f = calc_ctf1(amp1, gamma, s);
00989 float noise = 0;
00990 f = f * f;
00991
00992 if (sf && s) {
00993 f *= sf->get_yatx(s);
00994 }
00995 f+=noise;
00996
00997 d[x * 2 + ynx] *= f;
00998 d[x * 2 + ynx + 1] = 0;
00999 }
01000 }
01001 }
01002 else printf("Unknown CTF image mode\n");
01003
01004 image->update();
01005 }
|
|
||||||||||||||||
|
Implements EMAN::Ctf. Definition at line 830 of file ctf.cpp. 00831 {
00832
00833
00834 }
|
|
|
Implements EMAN::Ctf. Definition at line 622 of file ctf.cpp. References ampcont, EMAN::Ctf::apix, background, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, dfang, dfdiff, dsbg, snr, and EMAN::Ctf::voltage. 00623 {
00624 if (new_ctf) {
00625 const EMAN2Ctf *c = static_cast<const EMAN2Ctf *>(new_ctf);
00626 defocus = c->defocus;
00627 dfdiff = c->dfdiff;
00628 dfang = c->dfang;
00629 bfactor = c->bfactor;
00630 ampcont = c->ampcont;
00631 voltage = c->voltage;
00632 cs = c->cs;
00633 apix = c->apix;
00634 dsbg = c->dsbg;
00635 background = c->background;
00636 snr = c->snr;
00637 }
00638 }
|
|
|
Implements EMAN::Ctf. Definition at line 1009 of file ctf.cpp. References ampcont, EMAN::Ctf::apix, background, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, dfang, dfdiff, dsbg, snr, and EMAN::Ctf::voltage. 01010 {
01011 if (ctf1) {
01012 const EMAN2Ctf *c = static_cast<const EMAN2Ctf *>(ctf1);
01013 if (defocus != c->defocus ||
01014 dfdiff != c->dfdiff ||
01015 dfang != c->dfang ||
01016 bfactor != c->bfactor ||
01017 ampcont != c->ampcont ||
01018 voltage != c->voltage ||
01019 cs != c->cs ||
01020 apix != c->apix ||
01021 dsbg != c->dsbg ||
01022 background.size() != c->background.size() ||
01023 snr.size() != c->snr.size()
01024 ) return false;
01025
01026 for (unsigned int i=0; i<background.size(); i++) {
01027 if (background[i]!=c->background[i]) return false;
01028 }
01029 for (unsigned int i=0; i<snr.size(); i++) {
01030 if (snr[i]!=c->snr[i]) return false;
01031 }
01032 return true;
01033 }
01034 return false;
01035 }
|
|
|
Implements EMAN::Ctf. Definition at line 548 of file ctf.cpp. References ampcont, background, dfang, dfdiff, dsbg, and snr. 00549 {
00550 defocus = (float)dict["defocus"];
00551 dfdiff = (float)dict["dfdiff"];
00552 dfang = (float)dict["dfang"];
00553 bfactor = (float)dict["bfactor"];
00554 ampcont = (float)dict["ampcont"];
00555 voltage = (float)dict["voltage"];
00556 cs = (float)dict["cs"];
00557 apix = (float)dict["apix"];
00558 dsbg = (float)dict["dsbg"];
00559 background = dict["background"];
00560 snr = dict["snr"];
00561 }
|
|
|
Implements EMAN::Ctf. Definition at line 491 of file ctf.cpp. References ampcont, Assert, background, dfang, dfdiff, dsbg, InvalidValueException, snr, and v. 00492 {
00493 Assert(ctf != "");
00494 char type=' ';
00495 int pos,i,j;
00496 int bglen=0,snrlen=0;
00497 float v;
00498 const char *s=ctf.c_str();
00499
00500 sscanf(s, "%c%f %f %f %f %f %f %f %f %f %d%n",
00501 &type,&defocus, &dfdiff,&dfang,&bfactor,&cont,&voltage, &cs, &apix,&dsbg,&bglen,&pos);
00502 if (type!='E') throw InvalidValueException(type,"Trying to initialize Ctf object with bad string");
00503
00504
00505 background.resize(bglen);
00506 for (i=0; i<bglen; i++) {
00507 if (sscanf(s+pos,",%f%n",&v,&j)<1) return(1);
00508 background[i]=v;
00509 pos+=j;
00510 }
00511
00512 sscanf(s+pos," %d%n",&snrlen,&j);
00513 pos+=j;
00514 snr.resize(snrlen);
00515 for (i=0; i<snrlen; i++) {
00516 if (sscanf(s+pos,",%f%n",&v,&j)<1) return(1);
00517 snr[i]=v;
00518 pos+=j;
00519 }
00520
00521 return 0;
00522
00523 }
|
|
|
Implements EMAN::Ctf. Definition at line 581 of file ctf.cpp. References ampcont, background, dfang, dfdiff, dsbg, and snr. 00582 {
00583 int i;
00584 defocus = vctf[0];
00585 dfdiff = vctf[1];
00586 dfang = vctf[2];
00587 bfactor = vctf[3];
00588 ampcont = vctf[4];
00589 voltage = vctf[5];
00590 cs = vctf[6];
00591 apix = vctf[7];
00592 dsbg = vctf[8];
00593 background.resize((int)vctf[9]);
00594 for (i=0; i<(int)vctf[9]; i++) background[i]=vctf[i+10];
00595 snr.resize((int)vctf[i+10]);
00596 for (int j=0; j<(int)vctf[i+10]; j++) snr[j]=vctf[i+j+11];
00597 }
|
|
|
Definition at line 239 of file ctf.h. 00239 { return background;}
|
|
|
Definition at line 237 of file ctf.h. 00237 { return snr;}
|
|
|
Definition at line 240 of file ctf.h. 00240 {background = vf;}
|
|
|
Definition at line 238 of file ctf.h. 00238 {snr = vf;}
|
|
|
Implements EMAN::Ctf. Definition at line 563 of file ctf.cpp. 00564 {
00565 Dict dict;
00566 dict["defocus"] = defocus;
00567 dict["dfdiff"] = dfdiff;
00568 dict["dfang"] = dfang;
00569 dict["bfactor"] = bfactor;
00570 dict["ampcont"] = ampcont;
00571 dict["voltage"] = voltage;
00572 dict["cs"] = cs;
00573 dict["apix"] = apix;
00574 dict["dsbg"] = dsbg;
00575 dict["background"] = background;
00576 dict["snr"] = snr;
00577
00578 return dict;
00579 }
|
|
|
Implements EMAN::Ctf. Definition at line 525 of file ctf.cpp. References ampcont, background, dfang, dfdiff, dsbg, and snr. 00526 {
00527 char ctf[256];
00528 sprintf(ctf, "E%1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %d",
00529 defocus, dfdiff, dfang, bfactor, ampcont, voltage, cs, apix, dsbg,(int)background.size());
00530
00531 string ret=ctf;
00532 for (int i=0; i<(int)background.size(); i++) {
00533 sprintf(ctf,",%1.3g",background[i]);
00534 ret+=ctf;
00535 }
00536
00537 sprintf(ctf, " %d",(int)snr.size());
00538 ret+=ctf;
00539 for (int i=0; i<(int)snr.size(); i++) {
00540 sprintf(ctf,",%1.3g",snr[i]);
00541 ret+=ctf;
00542 }
00543
00544
00545 return ret;
00546 }
|
|
|
Implements EMAN::Ctf. Definition at line 599 of file ctf.cpp. References ampcont, background, dfang, dfdiff, dsbg, and snr. 00600 {
00601 vector<float> vctf;
00602
00603 vctf.push_back(defocus);
00604 vctf.push_back(dfdiff);
00605 vctf.push_back(dfang);
00606 vctf.push_back(bfactor);
00607 vctf.push_back(ampcont);
00608 vctf.push_back(voltage);
00609 vctf.push_back(cs);
00610 vctf.push_back(apix);
00611 vctf.push_back(dsbg);
00612 vctf.push_back((float)background.size());
00613 for (unsigned int i=0; i<background.size(); i++) vctf.push_back(background[i]);
00614 vctf.push_back((float)snr.size());
00615 for (unsigned int j=0; j<snr.size(); j++) vctf.push_back(snr[j]);
00616
00617 return vctf;
00618 }
|
|
|
Definition at line 229 of file ctf.h. Referenced by copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector(). |
|
|
Definition at line 234 of file ctf.h. Referenced by compute_1d(), compute_2d_complex(), copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector(). |
|
|
Definition at line 227 of file ctf.h. Referenced by copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector(). |
|
|
Definition at line 226 of file ctf.h. Referenced by copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector(). |
|
|
Definition at line 233 of file ctf.h. Referenced by compute_2d_complex(), copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector(). |
|
|
Definition at line 235 of file ctf.h. Referenced by compute_1d(), compute_2d_complex(), copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector(). |
1.3.9.1