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

EMAN::WienerFourierReconstructor Class Reference

Fourier space 3D reconstruction This is a modified version of the normal FourierReconstructor which is aware of the SSNR information stored in individual class-average headers as "ctf_snr_total" and "ctf_wiener_filtered". More...

#include <reconstructor.h>

Inheritance diagram for EMAN::WienerFourierReconstructor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

 WienerFourierReconstructor ()
 Default constructor calls load_default_settings().
virtual ~WienerFourierReconstructor ()
 Deconstructor calls free_memory().
virtual int insert_slice (const EMData *const slice, const Transform &euler, const float weight=1.0)
 Insert a slice into a 3D volume, in a given orientation.
virtual int determine_slice_agreement (EMData *slice, const Transform &euler, const float weight=1.0, bool sub=true)
 Compares a slice to the current reconstruction volume and computes a normalization factor and quality.
virtual EMDatafinish (bool doift=true)
 Get the reconstructed volume Normally will return the volume in real-space with the requested size.
virtual string get_name () const
 Get the unique name of the reconstructor.
virtual string get_desc () const
 Get the one line description of the reconstructor.

Static Public Member Functions

ReconstructorNEW ()
 Factory incorporation uses the pointer of this function.

Static Public Attributes

const string NAME = "wiener_fourier"

Protected Member Functions

virtual void do_insert_slice_work (const EMData *const input_slice, const Transform &euler, const float weight)
 A function to perform the nuts and bolts of inserting an image slice.
virtual void do_compare_slice_work (EMData *input_slice, const Transform &euler, float weight)
 A function to perform the nuts and bolts of comparing an image slice.
virtual bool pixel_at (const float &xx, const float &yy, const float &zz, float *dt)
 This is a mode-2 pixel extractor.

Private Member Functions

 WienerFourierReconstructor (const WienerFourierReconstructor &that)
 Disallow copy construction.
WienerFourierReconstructoroperator= (const WienerFourierReconstructor &)
 Disallow assignment.

Detailed Description

Fourier space 3D reconstruction This is a modified version of the normal FourierReconstructor which is aware of the SSNR information stored in individual class-average headers as "ctf_snr_total" and "ctf_wiener_filtered".

It will perform a reconstruction with a nonisotropic Wiener filter applied to the final reconstruction, and will 'undo' the Wiener filter on the individual class-averages if ctf_wiener_filtered is set. This represents something which was not possible to accomplish in EMAN1, and should produce superior results, with proper anisotropic filtering. Still, the filtration makes the assumption that the original SNR estimates were accurate, and that the data will average completely coherently, which is not truly the case. This may produce models which are somewhat underfiltered in the Wiener sense, but since B-factor corrections are not applied in the ctf.auto averager, this effect is likely already more than compensated for.

Definition at line 546 of file reconstructor.h.


Constructor & Destructor Documentation

EMAN::WienerFourierReconstructor::WienerFourierReconstructor  )  [inline]
 

Default constructor calls load_default_settings().

Definition at line 552 of file reconstructor.h.

00552 {};

virtual EMAN::WienerFourierReconstructor::~WienerFourierReconstructor  )  [inline, virtual]
 

Deconstructor calls free_memory().

Definition at line 557 of file reconstructor.h.

00557 { }

EMAN::WienerFourierReconstructor::WienerFourierReconstructor const WienerFourierReconstructor that  )  [private]
 

Disallow copy construction.


Member Function Documentation

int WienerFourierReconstructor::determine_slice_agreement EMData slice,
const Transform euler,
const float  weight = 1.0,
bool  sub = true
[virtual]
 

Compares a slice to the current reconstruction volume and computes a normalization factor and quality.

Normalization and quality are returned via attributes set in the passed slice. You may freely mix calls to determine_slice_agreement with calls to insert_slice, but note that determine_slice_agreement can only use information from slices that have already been inserted. Attributes set in the slice are: reconstruct_norm the relative normalization factor which should be applied before inserting the slice reconstruct_qual a scaled quality factor (larger better) for this slice as compared to the existing reconstruction reconstruct_absqual the absolute (not scaled based on weight) quality factor comparing this slice to the existing reconstruction reconstruct_weight the summed weights from all voxels intersecting with the inserted slice, larger -> more overlap with other slices

Parameters:
input_slice The EMData slice to be compared
euler The orientation of the slice as a Transform object
weight This is ignored except for it's sign, since the SSNR from the particle header is used instead
sub Flag indicating whether to subtract the slice from the volume before comparing. May be ignored by some reconstructors
Returns:
0 if OK. 1 if error.
Exceptions:
NullPointerException if the input EMData pointer is null
ImageFormatException if the image is complex as opposed to real

Reimplemented from EMAN::FourierReconstructor.

Definition at line 1060 of file reconstructor.cpp.

References EMAN::EMData::copy(), do_compare_slice_work(), do_insert_slice_work(), EMAN::EMData::get_attr(), EMAN::EMData::get_attr_default(), NullPointerException, EMAN::FourierReconstructor::preprocess_slice(), EMAN::EMData::set_attr(), EMAN::Transform::set_mirror(), EMAN::Transform::set_scale(), EMAN::Transform::set_trans(), and weight.

01061 {
01062         // Are these exceptions really necessary? (d.woolford)
01063         if (!input_slice) throw NullPointerException("EMData pointer (input image) is NULL");
01064 
01065         Transform * rotation;
01066         rotation = new Transform(arg); // assignment operator
01067 
01068         EMData *slice;
01069         if (input_slice->get_attr_default("reconstruct_preproc",(int) 0)) slice=input_slice->copy();
01070         else slice = preprocess_slice( input_slice, *rotation);
01071 
01072 
01073         // We must use only the rotational component of the transform, scaling, translation and mirroring
01074         // are not implemented in Fourier space, but are in preprocess_slice
01075         rotation->set_scale(1.0);
01076         rotation->set_mirror(false);
01077         rotation->set_trans(0,0,0);
01078 
01079 //      tmp_data->write_image("dbug.hdf",0);
01080         
01081         // Remove the current slice first (not threadsafe, but otherwise performance would be awful)
01082         if (sub) do_insert_slice_work(slice, *rotation, -weight);
01083 
01084         // Compare
01085         do_compare_slice_work(slice, *rotation,weight);
01086 
01087         input_slice->set_attr("reconstruct_norm",slice->get_attr("reconstruct_norm"));
01088         input_slice->set_attr("reconstruct_absqual",slice->get_attr("reconstruct_absqual"));
01089 //      input_slice->set_attr("reconstruct_qual",slice->get_attr("reconstruct_qual"));
01090         input_slice->set_attr("reconstruct_weight",slice->get_attr("reconstruct_weight"));
01091 
01092         // Now put the slice back
01093         if (sub) do_insert_slice_work(slice, *rotation, weight);
01094 
01095 
01096         delete rotation;
01097         delete slice;
01098 
01099 //      image->update();
01100         return 0;
01101 
01102 }

void WienerFourierReconstructor::do_compare_slice_work EMData input_slice,
const Transform euler,
float  weight
[protected, virtual]
 

A function to perform the nuts and bolts of comparing an image slice.

Parameters:
input_slice the slice to insert into the 3D volume
euler a transform storing the slice euler angle

Reimplemented from EMAN::FourierReconstructor.

Definition at line 1104 of file reconstructor.cpp.

References dot(), dt, EMAN::EMData::get_data(), EMAN::Symmetry3D::get_symmetries(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), pixel_at(), power(), EMAN::EMData::set_attr(), sqrt(), EMAN::Vec3f, weight, x, and y.

Referenced by determine_slice_agreement().

01105 {
01106 
01107         float dt[3];    // This stores the complex and weight from the volume
01108         float dt2[2];   // This stores the local image complex
01109         float *dat = input_slice->get_data();
01110         vector<Transform> syms = Symmetry3D::get_symmetries((string)params["sym"]);
01111 
01112         float inx=(float)(input_slice->get_xsize());            // x/y dimensions of the input image
01113         float iny=(float)(input_slice->get_ysize());
01114 
01115         double dot=0;           // summed pixel*weight dot product
01116         double vweight=0;               // sum of weights
01117         double power=0;         // sum of inten*weight from volume
01118         double power2=0;                // sum of inten*weight from image
01119         for ( vector<Transform>::const_iterator it = syms.begin(); it != syms.end(); ++it ) {
01120                 Transform t3d = arg*(*it);
01121                 for (int y = -iny/2; y < iny/2; y++) {
01122                         for (int x = 0; x <=  inx/2; x++) {
01123                                 if (x==0 && y==0) continue;             // We don't want to use the Fourier origin
01124 
01125                                 float rx = (float) x/(inx-2);   // coords relative to Nyquist=.5
01126                                 float ry = (float) y/iny;
01127 
01128 //                              if ((rx * rx + Util::square(ry - max_input_dim / 2)) > rl)
01129 //                                      continue;
01130 
01131                                 Vec3f coord(rx,ry,0);
01132                                 coord = coord*t3d; // transpose multiplication
01133                                 float xx = coord[0]; // transformed coordinates in terms of Nyquist
01134                                 float yy = coord[1];
01135                                 float zz = coord[2];
01136 
01137 
01138                                 if (fabs(xx)>0.5 || fabs(yy)>=0.5 || fabs(zz)>=0.5) continue;
01139 
01140                                 // Map back to actual pixel coordinates in output volume
01141                                 xx=xx*(nx-2);
01142                                 yy=yy*ny;
01143                                 zz=zz*nz;
01144 
01145 
01146                                 int idx = (int)(x * 2 + inx*(y<0?iny+y:y));
01147                                 dt2[0] = dat[idx];
01148                                 dt2[1] = dat[idx+1];
01149 
01150                                 // value returned indirectly in dt
01151                                 if (!pixel_at(xx,yy,zz,dt) || dt[2]<=0) continue;
01152 
01153 //                              printf("%f\t%f\t%f\t%f\t%f\n",dt[0],dt[1],dt[2],dt2[0],dt2[1]);
01154                                 dot+=(dt[0]*dt2[0]+dt[1]*dt2[1])*dt[2];
01155                                 vweight+=dt[2];
01156                                 power+=(dt[0]*dt[0]+dt[1]*dt[1])*dt[2];
01157                                 power2+=(dt2[0]*dt2[0]+dt2[1]*dt2[1])*dt[2];
01158                         }
01159                 }
01160         }
01161 
01162         dot/=sqrt(power*power2);                // normalize the dot product
01163 //      input_slice->set_attr("reconstruct_norm",(float)(power2<=0?1.0:sqrt(power/power2)/(inx*iny)));
01164         input_slice->set_attr("reconstruct_norm",(float)(power2<=0?1.0:sqrt(power/power2)));
01165         input_slice->set_attr("reconstruct_absqual",(float)dot);
01166         float rw=weight<=0?1.0f:1.0f/weight;
01167         input_slice->set_attr("reconstruct_qual",(float)(dot*rw/((rw-1.0)*dot+1.0)));   // here weight is a proxy for SNR
01168         input_slice->set_attr("reconstruct_weight",(float)vweight/(float)(subnx*subny*subnz));
01169 //      printf("** %g\t%g\t%g\t%g ##\n",dot,vweight,power,power2);
01170         //printf("** %f %f %f ##\n",(float)(power2<=0?1.0:sqrt(power/power2)/(inx*iny)),(float)dot,(float)(dot*weight/((weight-1.0)*dot+1.0)));
01171 }

void WienerFourierReconstructor::do_insert_slice_work const EMData *const   input_slice,
const Transform euler,
const float  weight
[protected, virtual]
 

A function to perform the nuts and bolts of inserting an image slice.

Parameters:
input_slice the slice to insert into the 3D volume
euler a transform storing the slice euler angle
weight weighting factor for this slice (usually number of particles in a class-average)

Reimplemented from EMAN::FourierReconstructor.

Definition at line 1005 of file reconstructor.cpp.

References EMAN::EMData::get_attr(), EMAN::EMData::get_attr_default(), EMAN::EMData::get_complex_at(), EMAN::Symmetry3D::get_symmetries(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::FourierPixelInserter3D::insert_pixel(), EMAN::Util::linear_interpolate(), sub(), EMAN::Vec3f, weight, x, and y.

Referenced by determine_slice_agreement(), and insert_slice().

01006 {
01007 
01008         vector<Transform> syms = Symmetry3D::get_symmetries((string)params["sym"]);
01009 
01010         float inx=(float)(input_slice->get_xsize());            // x/y dimensions of the input image
01011         float iny=(float)(input_slice->get_ysize());
01012         
01013         int undo_wiener=(int)input_slice->get_attr_default("ctf_wiener_filtered",0);    // indicates whether we need to undo a wiener filter before insertion
01014 //      if (undo_wiener) throw UnexpectedBehaviorException("wiener_fourier does not yet accept already Wiener filtered class-averages. Suggest using ctf.auto averager for now.");
01015         
01016         vector<float> snr=input_slice->get_attr("ctf_snr_total");
01017         float sub=1.0;
01018         if (inweight<0) sub=-1.0;
01019         float weight;
01020         
01021         for ( vector<Transform>::const_iterator it = syms.begin(); it != syms.end(); ++it ) {
01022                 Transform t3d = arg*(*it);
01023                 for (int y = -iny/2; y < iny/2; y++) {
01024                         for (int x = 0; x <=  inx/2; x++) {
01025 
01026                                 float rx = (float) x/(inx-2.0f);        // coords relative to Nyquist=.5
01027                                 float ry = (float) y/iny;
01028 
01029                                 // This deals with the SNR weight
01030                                 float rn = (float)hypot(rx,ry);
01031                                 if (rn>=.5) continue;           // no SNR in the corners, and we're going to mask them later anyway
01032                                 rn*=snr.size()*2.0f;
01033                                 int rni=(int)floor(rn);
01034                                 if ((unsigned int)rni>=snr.size()-1) weight=snr[snr.size()-1]*sub;
01035                                 else {
01036                                         rn-=rni;
01037                                         weight=Util::linear_interpolate(snr[rni],snr[rni+1],rn);
01038                                 }
01039 //                              if (weight>500.0) printf("%f %d %d %f %f %d %f\n",weight,x,y,rx,ry,rni);
01040                                 
01041                                 Vec3f coord(rx,ry,0);
01042                                 coord = coord*t3d; // transpose multiplication
01043                                 float xx = coord[0]; // transformed coordinates in terms of Nyquist
01044                                 float yy = coord[1];
01045                                 float zz = coord[2];
01046 
01047                                 // Map back to real pixel coordinates in output volume
01048                                 xx=xx*(nx-2);
01049                                 yy=yy*ny;
01050                                 zz=zz*nz;
01051 
01052 //                              printf("%f\n",weight);
01053                                 if (undo_wiener) inserter->insert_pixel(xx,yy,zz,(input_slice->get_complex_at(x,y))*((weight+1.0f)/weight),weight*sub);
01054                                 else inserter->insert_pixel(xx,yy,zz,input_slice->get_complex_at(x,y),weight*sub);
01055                         }
01056                 }
01057         }
01058 }

EMData * WienerFourierReconstructor::finish bool  doift = true  )  [virtual]
 

Get the reconstructed volume Normally will return the volume in real-space with the requested size.

The calling application is responsible for removing any padding.

Parameters:
doift A flag indicating whether the returned object should be guaranteed to be in real-space (true) or should be left in whatever space the reconstructor generated
Returns:
The real space reconstructed volume

Reimplemented from EMAN::FourierReconstructor.

Definition at line 1247 of file reconstructor.cpp.

References EMAN::EMData::depad(), EMAN::EMData::do_ift_inplace(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::Dict::has_key(), EMAN::ReconstructorVolumeData::normalize_threed(), EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::update(), and EMAN::EMData::write_image().

01248 {
01249 
01250         bool sqrtnorm=params.set_default("sqrtnorm",false);
01251         normalize_threed(sqrtnorm,true);                // true is the wiener filter
01252 
01253         if (doift) {
01254                 image->do_ift_inplace();
01255                 image->depad();
01256                 image->process_inplace("xform.phaseorigin.tocenter");
01257         }
01258 
01259         image->update();
01260         
01261         if (params.has_key("savenorm") && strlen((const char *)params["savenorm"])>0) {
01262                 if (tmp_data->get_ysize()%2==0 && tmp_data->get_zsize()%2==0) tmp_data->process_inplace("xform.fourierorigin.tocenter");
01263                 tmp_data->write_image((const char *)params["savenorm"]);
01264         }
01265 
01266         delete tmp_data;
01267         tmp_data=0;
01268         EMData *ret=image;
01269         image=0;
01270         
01271         return ret;
01272 }

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

Get the one line description of the reconstructor.

Reimplemented from EMAN::FourierReconstructor.

Definition at line 607 of file reconstructor.h.

00608                 {
00609                         return "Reconstruction via direct Fourier methods using one of a variety of different kernels, most of which are Gaussian based. This version also incorporates a nonisotropic Wiener filter based on SNR estimates stored in the class-average headers by the ctf.auto averager.";
00610                 }

virtual string EMAN::WienerFourierReconstructor::get_name  )  const [inline, virtual]
 

Get the unique name of the reconstructor.

Reimplemented from EMAN::FourierReconstructor.

Definition at line 600 of file reconstructor.h.

00601                 {
00602                         return NAME;
00603                 }

int WienerFourierReconstructor::insert_slice const EMData *const   slice,
const Transform euler,
const float  weight = 1.0
[virtual]
 

Insert a slice into a 3D volume, in a given orientation.

Returns:
0 if successful, 1 otherwise
Parameters:
slice the image slice to be inserted into the 3D volume
euler Euler angle of this image slice.
weight This is ignored in this reconstructor, since the SSNR from the particle header is used instead
Returns:
0 if OK. 1 if error.
Exceptions:
NullPointerException if the input EMData pointer is null
ImageFormatException if the image is complex as opposed to real

Reimplemented from EMAN::FourierReconstructor.

Definition at line 969 of file reconstructor.cpp.

References EMAN::EMData::copy(), do_insert_slice_work(), EMAN::EMData::get_attr_default(), EMAN::EMData::has_attr(), NotExistingObjectException, NullPointerException, EMAN::FourierReconstructor::preprocess_slice(), EMAN::Transform::set_mirror(), EMAN::Transform::set_scale(), EMAN::Transform::set_trans(), and weight.

00970 {
00971         // Are these exceptions really necessary? (d.woolford)
00972         if (!input_slice) throw NullPointerException("EMData pointer (input image) is NULL");
00973 
00974         Transform * rotation;
00975 /*      if ( input_slice->has_attr("xform.projection") ) {
00976                 rotation = (Transform*) (input_slice->get_attr("xform.projection")); // assignment operator
00977         } else {*/
00978         rotation = new Transform(arg); // assignment operator
00979 //      }
00980 
00981         if (!input_slice->has_attr("ctf_snr_total")) 
00982                 throw NotExistingObjectException("ctf_snr_total","No SNR information present in class-average. Must use the ctf.auto or ctfw.auto averager.");
00983 
00984         EMData *slice;
00985         if (input_slice->get_attr_default("reconstruct_preproc",(int) 0)) slice=input_slice->copy();
00986         else slice = preprocess_slice( input_slice, *rotation);
00987 
00988 
00989         // We must use only the rotational component of the transform, scaling, translation and mirroring
00990         // are not implemented in Fourier space, but are in preprocess_slice
00991         rotation->set_scale(1.0);
00992         rotation->set_mirror(false);
00993         rotation->set_trans(0,0,0);
00994 
00995         // Finally to the pixel wise slice insertion
00996         do_insert_slice_work(slice, *rotation, weight);
00997 
00998         delete rotation; rotation=0;
00999         delete slice;
01000 
01001 //      image->update();
01002         return 0;
01003 }

Reconstructor* EMAN::WienerFourierReconstructor::NEW  )  [inline, static]
 

Factory incorporation uses the pointer of this function.

Returns:
a Reconstructor pointer to a newly allocated WienerFourierReconstructor

Reimplemented from EMAN::FourierReconstructor.

Definition at line 615 of file reconstructor.h.

00616                 {
00617                         return new WienerFourierReconstructor();
00618                 }

WienerFourierReconstructor& EMAN::WienerFourierReconstructor::operator= const WienerFourierReconstructor  )  [private]
 

Disallow assignment.

bool WienerFourierReconstructor::pixel_at const float &  xx,
const float &  yy,
const float &  zz,
float *  dt
[protected, virtual]
 

This is a mode-2 pixel extractor.

Parameters:
xx,yy,zz voxel coordinates (need not be integers)
dt float pointer with 3 floats allocated for returned complex value and weight sum

Reimplemented from EMAN::FourierReconstructor.

Definition at line 1173 of file reconstructor.cpp.

References dt, EMAN::Util::fast_exp(), EMAN::EMData::get_complex_index(), EMAN::EMData::get_complex_index_fast(), EMAN::EMData::get_data(), EMAN::Util::hypot3sq(), norm(), and rdata.

Referenced by do_compare_slice_work().

01174 {
01175         int x0 = (int) floor(xx);
01176         int y0 = (int) floor(yy);
01177         int z0 = (int) floor(zz);
01178         
01179         float *rdata=image->get_data();
01180         float *norm=tmp_data->get_data();
01181         float normsum=0,normsum2=0;
01182 
01183         dt[0]=dt[1]=dt[2]=0.0;
01184 
01185         if (nx==subnx) {                        // normal full reconstruction
01186                 if (x0<-nx2-1 || y0<-ny2-1 || z0<-nz2-1 || x0>nx2 || y0>ny2 || z0>nz2 ) return false;
01187 
01188                 // no error checking on add_complex_fast, so we need to be careful here
01189                 int x1=x0+1;
01190                 int y1=y0+1;
01191                 int z1=z0+1;
01192                 if (x0<-nx2) x0=-nx2;
01193                 if (x1>nx2) x1=nx2;
01194                 if (y0<-ny2) y0=-ny2;
01195                 if (y1>ny2) y1=ny2;
01196                 if (z0<-nz2) z0=-nz2;
01197                 if (z1>nz2) z1=nz2;
01198                 
01199                 size_t idx=0;
01200                 float r, gg;
01201                 for (int k = z0 ; k <= z1; k++) {
01202                         for (int j = y0 ; j <= y1; j++) {
01203                                 for (int i = x0; i <= x1; i ++) {
01204                                         r = Util::hypot3sq((float) i - xx, j - yy, k - zz);
01205                                         idx=image->get_complex_index_fast(i,j,k);
01206                                         gg = Util::fast_exp(-r / EMConsts::I2G);
01207                                         
01208                                         dt[0]+=gg*rdata[idx];
01209                                         dt[1]+=(i<0?-1.0f:1.0f)*gg*rdata[idx+1];
01210                                         dt[2]+=norm[idx/2]*gg;
01211                                         normsum2+=gg;
01212                                         normsum+=gg*norm[idx/2];                                
01213                                 }
01214                         }
01215                 }
01216                 if (normsum==0) return false;
01217                 dt[0]/=normsum;
01218                 dt[1]/=normsum;
01219                 dt[2]/=normsum2;
01220 //              printf("%1.2f,%1.2f,%1.2f\t%1.3f\t%1.3f\t%1.3f\t%1.3f\t%1.3f\n",xx,yy,zz,dt[0],dt[1],dt[2],rdata[idx],rdata[idx+1]);
01221                 return true;
01222         } 
01223         else {                                  // for subvolumes, not optimized yet
01224                 size_t idx;
01225                 float r, gg;
01226                 for (int k = z0 ; k <= z0 + 1; k++) {
01227                         for (int j = y0 ; j <= y0 + 1; j++) {
01228                                 for (int i = x0; i <= x0 + 1; i ++) {
01229                                         r = Util::hypot3sq((float) i - xx, j - yy, k - zz);
01230                                         idx=image->get_complex_index(i,j,k,subx0,suby0,subz0,nx,ny,nz);
01231                                         gg = Util::fast_exp(-r / EMConsts::I2G)*norm[idx/2];
01232                                         
01233                                         dt[0]+=gg*rdata[idx];
01234                                         dt[1]+=(i<0?-1.0f:1.0f)*gg*rdata[idx+1];
01235                                         dt[2]+=norm[idx/2];
01236                                         normsum+=gg;                            
01237                                 }
01238                         }
01239                 }
01240                 
01241                 if (normsum==0)  return false;
01242                 return true;
01243         }
01244 }


Member Data Documentation

const string WienerFourierReconstructor::NAME = "wiener_fourier" [static]
 

Reimplemented from EMAN::FourierReconstructor.

Definition at line 79 of file reconstructor.cpp.


The documentation for this class was generated from the following files:
Generated on Mon Mar 7 18:21:33 2011 for EMAN2 by  doxygen 1.3.9.1