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 547 of file reconstructor.h.


Constructor & Destructor Documentation

EMAN::WienerFourierReconstructor::WienerFourierReconstructor  )  [inline]
 

Default constructor calls load_default_settings().

Definition at line 553 of file reconstructor.h.

00553 {};

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

Deconstructor calls free_memory().

Definition at line 558 of file reconstructor.h.

00558 { }

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 1080 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.

01081 {
01082         // Are these exceptions really necessary? (d.woolford)
01083         if (!input_slice) throw NullPointerException("EMData pointer (input image) is NULL");
01084 
01085         Transform * rotation;
01086         rotation = new Transform(arg); // assignment operator
01087 
01088         EMData *slice;
01089         if (input_slice->get_attr_default("reconstruct_preproc",(int) 0)) slice=input_slice->copy();
01090         else slice = preprocess_slice( input_slice, *rotation);
01091 
01092 
01093         // We must use only the rotational component of the transform, scaling, translation and mirroring
01094         // are not implemented in Fourier space, but are in preprocess_slice
01095         rotation->set_scale(1.0);
01096         rotation->set_mirror(false);
01097         rotation->set_trans(0,0,0);
01098 
01099 //      tmp_data->write_image("dbug.hdf",0);
01100         
01101         // Remove the current slice first (not threadsafe, but otherwise performance would be awful)
01102         if (sub) do_insert_slice_work(slice, *rotation, -weight);
01103 
01104         // Compare
01105         do_compare_slice_work(slice, *rotation,weight);
01106 
01107         input_slice->set_attr("reconstruct_norm",slice->get_attr("reconstruct_norm"));
01108         input_slice->set_attr("reconstruct_absqual",slice->get_attr("reconstruct_absqual"));
01109 //      input_slice->set_attr("reconstruct_qual",slice->get_attr("reconstruct_qual"));
01110         input_slice->set_attr("reconstruct_weight",slice->get_attr("reconstruct_weight"));
01111 
01112         // Now put the slice back
01113         if (sub) do_insert_slice_work(slice, *rotation, weight);
01114 
01115 
01116         delete rotation;
01117         delete slice;
01118 
01119 //      image->update();
01120         return 0;
01121 
01122 }

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 1124 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().

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

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 1025 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().

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

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 1267 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().

01268 {
01269 
01270         bool sqrtnorm=params.set_default("sqrtnorm",false);
01271         normalize_threed(sqrtnorm,true);                // true is the wiener filter
01272 
01273         if (doift) {
01274                 image->do_ift_inplace();
01275                 image->depad();
01276                 image->process_inplace("xform.phaseorigin.tocenter");
01277         }
01278 
01279         image->update();
01280         
01281         if (params.has_key("savenorm") && strlen((const char *)params["savenorm"])>0) {
01282                 if (tmp_data->get_ysize()%2==0 && tmp_data->get_zsize()%2==0) tmp_data->process_inplace("xform.fourierorigin.tocenter");
01283                 tmp_data->write_image((const char *)params["savenorm"]);
01284         }
01285 
01286         delete tmp_data;
01287         tmp_data=0;
01288         EMData *ret=image;
01289         image=0;
01290         
01291         return ret;
01292 }

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

Get the one line description of the reconstructor.

Reimplemented from EMAN::FourierReconstructor.

Definition at line 608 of file reconstructor.h.

00609                 {
00610                         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.";
00611                 }

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

Get the unique name of the reconstructor.

Reimplemented from EMAN::FourierReconstructor.

Definition at line 601 of file reconstructor.h.

00602                 {
00603                         return NAME;
00604                 }

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 989 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.

00990 {
00991         // Are these exceptions really necessary? (d.woolford)
00992         if (!input_slice) throw NullPointerException("EMData pointer (input image) is NULL");
00993 
00994         Transform * rotation;
00995 /*      if ( input_slice->has_attr("xform.projection") ) {
00996                 rotation = (Transform*) (input_slice->get_attr("xform.projection")); // assignment operator
00997         } else {*/
00998         rotation = new Transform(arg); // assignment operator
00999 //      }
01000 
01001         if (!input_slice->has_attr("ctf_snr_total")) 
01002                 throw NotExistingObjectException("ctf_snr_total","No SNR information present in class-average. Must use the ctf.auto or ctfw.auto averager.");
01003 
01004         EMData *slice;
01005         if (input_slice->get_attr_default("reconstruct_preproc",(int) 0)) slice=input_slice->copy();
01006         else slice = preprocess_slice( input_slice, *rotation);
01007 
01008 
01009         // We must use only the rotational component of the transform, scaling, translation and mirroring
01010         // are not implemented in Fourier space, but are in preprocess_slice
01011         rotation->set_scale(1.0);
01012         rotation->set_mirror(false);
01013         rotation->set_trans(0,0,0);
01014 
01015         // Finally to the pixel wise slice insertion
01016         do_insert_slice_work(slice, *rotation, weight);
01017 
01018         delete rotation; rotation=0;
01019         delete slice;
01020 
01021 //      image->update();
01022         return 0;
01023 }

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 616 of file reconstructor.h.

00617                 {
00618                         return new WienerFourierReconstructor();
00619                 }

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 1193 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().

01194 {
01195         int x0 = (int) floor(xx);
01196         int y0 = (int) floor(yy);
01197         int z0 = (int) floor(zz);
01198         
01199         float *rdata=image->get_data();
01200         float *norm=tmp_data->get_data();
01201         float normsum=0,normsum2=0;
01202 
01203         dt[0]=dt[1]=dt[2]=0.0;
01204 
01205         if (nx==subnx) {                        // normal full reconstruction
01206                 if (x0<-nx2-1 || y0<-ny2-1 || z0<-nz2-1 || x0>nx2 || y0>ny2 || z0>nz2 ) return false;
01207 
01208                 // no error checking on add_complex_fast, so we need to be careful here
01209                 int x1=x0+1;
01210                 int y1=y0+1;
01211                 int z1=z0+1;
01212                 if (x0<-nx2) x0=-nx2;
01213                 if (x1>nx2) x1=nx2;
01214                 if (y0<-ny2) y0=-ny2;
01215                 if (y1>ny2) y1=ny2;
01216                 if (z0<-nz2) z0=-nz2;
01217                 if (z1>nz2) z1=nz2;
01218                 
01219                 size_t idx=0;
01220                 float r, gg;
01221                 for (int k = z0 ; k <= z1; k++) {
01222                         for (int j = y0 ; j <= y1; j++) {
01223                                 for (int i = x0; i <= x1; i ++) {
01224                                         r = Util::hypot3sq((float) i - xx, j - yy, k - zz);
01225                                         idx=image->get_complex_index_fast(i,j,k);
01226                                         gg = Util::fast_exp(-r / EMConsts::I2G);
01227                                         
01228                                         dt[0]+=gg*rdata[idx];
01229                                         dt[1]+=(i<0?-1.0f:1.0f)*gg*rdata[idx+1];
01230                                         dt[2]+=norm[idx/2]*gg;
01231                                         normsum2+=gg;
01232                                         normsum+=gg*norm[idx/2];                                
01233                                 }
01234                         }
01235                 }
01236                 if (normsum==0) return false;
01237                 dt[0]/=normsum;
01238                 dt[1]/=normsum;
01239                 dt[2]/=normsum2;
01240 //              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]);
01241                 return true;
01242         } 
01243         else {                                  // for subvolumes, not optimized yet
01244                 size_t idx;
01245                 float r, gg;
01246                 for (int k = z0 ; k <= z0 + 1; k++) {
01247                         for (int j = y0 ; j <= y0 + 1; j++) {
01248                                 for (int i = x0; i <= x0 + 1; i ++) {
01249                                         r = Util::hypot3sq((float) i - xx, j - yy, k - zz);
01250                                         idx=image->get_complex_index(i,j,k,subx0,suby0,subz0,nx,ny,nz);
01251                                         gg = Util::fast_exp(-r / EMConsts::I2G)*norm[idx/2];
01252                                         
01253                                         dt[0]+=gg*rdata[idx];
01254                                         dt[1]+=(i<0?-1.0f:1.0f)*gg*rdata[idx+1];
01255                                         dt[2]+=norm[idx/2];
01256                                         normsum+=gg;                            
01257                                 }
01258                         }
01259                 }
01260                 
01261                 if (normsum==0)  return false;
01262                 return true;
01263         }
01264 }


Member Data Documentation

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

Reimplemented from EMAN::FourierReconstructor.

Definition at line 80 of file reconstructor.cpp.


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