Fourier space 3D reconstruction The Fourier reconstructor is designed to work in an iterative fashion, where similarity ("quality") metrics are used to determine if a slice should be inserted into the 3D in each subsequent iteration. More...

#include <reconstructor.h>

Inheritance diagram for EMAN::FourierIterReconstructor:

[legend]

Collaboration diagram for EMAN::FourierIterReconstructor:

[legend]

Public Member Functions
	FourierIterReconstructor ()
	Default constructor. More...

virtual	~FourierIterReconstructor ()
	Deconstructor calls free_memory() More...

virtual void	setup ()
	Setup the Fourier reconstructor. More...

virtual void	setup_seed (EMData *seed, float seed_weight)
	Initialize the reconstructor with a seed volume. More...

virtual void	setup_seedandweights (EMData seed, EMData weight)
	Initialize the reconstructor with a seed volume, as above. More...

virtual EMData *	preprocess_slice (const EMData *const slice, const Transform &t=Transform())
	Preprocess the slice prior to insertion into the 3D volume this Fourier tranforms the slice and make sure all the pixels are in the right position it always returns a copy of the provided slice, so it should be deleted by someone eventually. More...

virtual int	insert_slice (const EMData *const slice, const Transform &euler, const float weight)
	Insert a slice into a 3D volume, in a given orientation. More...

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

virtual EMData *	finish (bool doift=true)
	Get the reconstructed volume Normally will return the volume in real-space with the requested size. More...

virtual void	clear ()
	clear the volume and tmp_data for use in Monte Carlo reconstructions More...

virtual string	get_name () const
	Get the unique name of the reconstructor. More...

virtual string	get_desc () const
	Get the one line description of the reconstructor. More...

virtual TypeDict	get_param_types () const
	Get the parameter types of this object. More...

Public Member Functions inherited from EMAN::Reconstructor
	Reconstructor ()

virtual	~Reconstructor ()

int	insert_slice (const EMData *const slice, const Transform &euler)

virtual EMData *	projection (const Transform &euler, int ret_fourier=1)
	This will create a projection from the current reconstruction. More...

void	print_params () const
	Print the current parameters to std::out. More...

EMObject &	operator[] (const string &key)

Public Member Functions inherited from EMAN::FactoryBase
	FactoryBase ()

virtual	~FactoryBase ()

Dict	get_params () const
	get a copy of the parameters of this class More...

void	set_params (const Dict &new_params)
	Set new parameters. More...

void	set_param (const string key, const EMObject val)

void	insert_params (const Dict &new_params)
	Insert parameters. More...

Dict	copy_relevant_params (const FactoryBase *const that) const

Public Member Functions inherited from EMAN::ReconstructorVolumeData
	ReconstructorVolumeData ()
	Only constructor All member variables are zeroed. More...

virtual	~ReconstructorVolumeData ()
	Destructor safely frees memory. More...

const EMData *	get_emdata ()
	Get the main image pointer, probably redundant (not used) More...

Static Public Member Functions
static Reconstructor *	NEW ()
	Factory incorporation uses the pointer of this function. More...

Static Public Attributes
static const string	NAME = "fourier_iter"

Protected Member Functions
virtual void	free_memory ()
	Frees the memory owned by this object (but not parent objects) Deletes the FourierPixelInserter3D pointer. More...

Protected Member Functions inherited from EMAN::ReconstructorVolumeData
void	free_memory ()
	Free allocated memorys The inherited class may have allocated image of tmp_data In either case you can safely call this function to delete either of those pointers, even if they bdb:refine_03::threed_00are NULL. More...

virtual void	normalize_threed (const bool sqrt_damp=false, const bool wiener=false)
	Normalize on the assumption that image is a Fourier volume and that tmp_data is a volume of weights corresponding in size to this Fourier volume. More...

virtual void	zero_memory ()
	Sends the pixels in tmp_data and image to zero Convenience only. More...

Protected Attributes
EMData *	ref_vol

Protected Attributes inherited from EMAN::FactoryBase
Dict	params
	This is the dictionary the stores the parameters of the object. More...

Protected Attributes inherited from EMAN::ReconstructorVolumeData
EMData *	image
	Inheriting class allocates this, probably in setup(). More...

EMData *	tmp_data
	Inheriting class may allocate this, probably in setup() More...

int	nx

int	nx2

int	ny

int	ny2

int	nz

int	nz2

int	subnx

int	subny

int	subnz

int	subx0

int	suby0

int	subz0

Private Member Functions
	FourierIterReconstructor (const FourierIterReconstructor &that)
	Disallow copy construction. More...

FourierIterReconstructor &	operator= (const FourierIterReconstructor &)
	Disallow assignment. More...

Detailed Description

Fourier space 3D reconstruction The Fourier reconstructor is designed to work in an iterative fashion, where similarity ("quality") metrics are used to determine if a slice should be inserted into the 3D in each subsequent iteration.

The client creates a Fourier reconstructor to insert real images into a 3D volume. The return image is a real space image

This reconstructor works in Fourier space using a hardcoded 5x5x5 interpolation kernel based on the local environment from a previous iteration. That is, it uses interpolation, not gridding, but rather than using a fixed interpolation kernel, it bases the kernel on a previous estimate of the Fourier volume. It is designed to be used iteratively, being passed the results of the previous round as a starting volume in each pass. The starting volume does not get directly incorporated into the result, but is only used to define the local interpolation kernel.

Fourier reconstructor usage

Definition at line 698 of file reconstructor.h.

Constructor & Destructor Documentation

◆ FourierIterReconstructor() [1/2]

EMAN::FourierIterReconstructor::FourierIterReconstructor ( )

inline

Default constructor.

Definition at line 703 of file reconstructor.h.

703: ref_vol(0) { }

EMAN::FourierIterReconstructor::ref_vol

EMData * ref_vol

Definition: reconstructor.h:821

Referenced by NEW().

◆ ~FourierIterReconstructor()

virtual EMAN::FourierIterReconstructor::~FourierIterReconstructor ( )

inlinevirtual

Deconstructor calls free_memory()

Definition at line 708 of file reconstructor.h.

708{ free_memory(); }

EMAN::FourierIterReconstructor::free_memory

virtual void free_memory()

Frees the memory owned by this object (but not parent objects) Deletes the FourierPixelInserter3D poi...

Definition: reconstructor.cpp:677

References free_memory().

◆ FourierIterReconstructor() [2/2]

EMAN::FourierIterReconstructor::FourierIterReconstructor ( const FourierIterReconstructor & that )

private

Disallow copy construction.

Member Function Documentation

◆ clear()

void FourierIterReconstructor::clear ( )

virtual

clear the volume and tmp_data for use in Monte Carlo reconstructions

Reimplemented from EMAN::Reconstructor.

Definition at line 501 of file reconstructor.cpp.

                                     {
        setup();
}

References setup().

◆ determine_slice_agreement()

int FourierIterReconstructor::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	A weighting factor for this slice, generally the number of particles in a class-average. May be ignored by some reconstructors
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::Reconstructor.

Definition at line 651 of file reconstructor.cpp.

651{ return 0; }

◆ finish()

EMData * FourierIterReconstructor::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::Reconstructor.

Definition at line 653 of file reconstructor.cpp.

                                                   {
        normalize_threed(0);
        
        if (doift) {
                image->do_ift_inplace();
                image->depad();
                image->process_inplace("xform.phaseorigin.tocenter");
        }
 
        image->update();
        
        if (params.has_key("savenorm") && strlen((const char *)params["savenorm"])>0) {
                if (tmp_data->get_ysize()%2==0 && tmp_data->get_zsize()%2==0) tmp_data->process_inplace("xform.fourierorigin.tocenter");
                tmp_data->write_image((const char *)params["savenorm"]);
        }
 
        //Since we give up the ownership of the pointer to-be-returned, it's caller's responsibility to delete the returned image.
        //So we wrap this function with return_value_policy< manage_new_object >() in libpyReconstructor2.cpp to hand over ownership to Python.
        EMData *ret=image;
        image=0;
        
        return ret;
}

References EMAN::Dict::has_key(), EMAN::ReconstructorVolumeData::image, EMAN::ReconstructorVolumeData::normalize_threed(), EMAN::FactoryBase::params, and EMAN::ReconstructorVolumeData::tmp_data.

◆ free_memory()

void FourierIterReconstructor::free_memory ( )

protectedvirtual

Frees the memory owned by this object (but not parent objects) Deletes the FourierPixelInserter3D pointer.

Definition at line 677 of file reconstructor.cpp.

                                           {
        if (image) delete image;
        if (tmp_data) delete tmp_data;
        if (ref_vol) delete ref_vol;
        image=tmp_data=ref_vol=0;
}

References EMAN::ReconstructorVolumeData::image, ref_vol, and EMAN::ReconstructorVolumeData::tmp_data.

Referenced by ~FourierIterReconstructor().

◆ get_desc()

virtual string EMAN::FourierIterReconstructor::get_desc ( ) const

inlinevirtual

Get the one line description of the reconstructor.

Implements EMAN::FactoryBase.

Definition at line 787 of file reconstructor.h.

                {
                        return "Reconstruction via Fourier interpolation using an iterative strategy to define the interpolation kernel";
                }

◆ get_name()

virtual string EMAN::FourierIterReconstructor::get_name ( ) const

inlinevirtual

Get the unique name of the reconstructor.

Implements EMAN::FactoryBase.

Definition at line 780 of file reconstructor.h.

                {
                        return NAME;
                }

References NAME.

◆ get_param_types()

virtual TypeDict EMAN::FourierIterReconstructor::get_param_types ( ) const

inlinevirtual

Get the parameter types of this object.

Returns: a TypeDict detailing all of the acceptable (and necessary) parameters

Implements EMAN::FactoryBase.

Definition at line 803 of file reconstructor.h.

                {
                        TypeDict d;
                        d.put("size", EMObject::INTARRAY, "Required. The dimensions of the real-space output volume, including any padding (must be handled by the calling application). Assumed that apix x/y/z identical.");
                        d.put("sym", EMObject::STRING, "Optional. The symmetry of the reconstructed volume, c?, d?, oct, tet, icos, h?. Default is c1, ie - an asymmetric object");
                        d.put("verbose", EMObject::BOOL, "Optional. Toggles writing useful information to standard out. Default is false.");
                        return d;
                }

References EMAN::EMObject::BOOL, EMAN::EMObject::INTARRAY, EMAN::TypeDict::put(), and EMAN::EMObject::STRING.

◆ insert_slice()

int FourierIterReconstructor::insert_slice	(	const EMData *const	slice,
		const Transform &	euler,
		const float	weight
	)

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	A weighting factor for this slice, generally the number of particles in a class-average. 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::Reconstructor.

Definition at line 522 of file reconstructor.cpp.

                                                                                                               { 
        Transform * rotation;
        rotation = new Transform(arg); // assignment operator
        // We must use only the rotational component of the transform, scaling, translation and mirroring
        // are not implemented in Fourier space, but are in preprocess_slice
        rotation->set_scale(1.0);
        rotation->set_mirror(false);
        rotation->set_trans(0,0,0);
 
//      if (slice->get_attr_default("reconstruct_preproc",(int) 0)) throw ImageDimensionException("ERROR: FourierIterReconstructor requires preprocess_slice() to be called in advance");
 
        vector<Transform> syms = Symmetry3D::get_symmetries((string)params["sym"]);
 
        float inx=(float)(slice->get_xsize());          // x/y dimensions of the input image
        float iny=(float)(slice->get_ysize());
        size_t ny2sq=ny*ny/4;
        
        for ( vector<Transform>::const_iterator it = syms.begin(); it != syms.end(); ++it ) {
                Transform t3d = (*rotation)*(*it);
                for (int y = -iny/2; y < iny/2; y++) {
                        for (int x = 0; x < inx/2; x++) {
 
                                float rx = (float) x/(inx-2.0f);        // coords relative to Nyquist=.5
                                float ry = (float) y/iny;
                                int r=Util::hypot_fast_int(x,y);
                                if (r>iny/2+3 && abs(inx-iny)<3) continue;      // no filling in Fourier corners...
 
                                Vec3f coord(rx,ry,0);
                                coord = coord*t3d; // transpose multiplication
                                float xx = coord[0]; // transformed coordinates in terms of Nyquist
                                float yy = coord[1];
                                float zz = coord[2];
 
                                // Map back to real pixel coordinates in output volume
                                xx=xx*(nx-2);
                                yy=yy*ny;
                                zz=zz*nz;
                                
                                
                                int x0 = (int) floor(xx-2.5);
                                int y0 = (int) floor(yy-2.5);
                                int z0 = (int) floor(zz-2.5);
 
                                std::complex<float>dt=slice->get_complex_at(x,y);                       // The data value we want to insert
 
                                if (x0<-nx2-4 || y0<-ny2-4 || z0<-nz2-4 || x0>nx2+3 || y0>ny2+3 || z0>nz2+3 ) continue;
 
                                // no error checking on add_complex_fast, so we need to be careful here
                                int x1=x0+5;
                                int y1=y0+5;
                                int z1=z0+5;
                                if (x0<-nx2) x0=-nx2;
                                if (x1>nx2) x1=nx2;
                                if (y0<-ny2) y0=-ny2;
                                if (y1>ny2) y1=ny2;
                                if (z0<-nz2) z0=-nz2;
                                if (z1>nz2) z1=nz2;
 
                                if (ref_vol) {
                                        // The value in the reference volume at the center insertion location (nearest voxel)
//                                      std::complex<float>nodt=ref_vol->get_complex_at(Util::round(xx),Util::round(yy),Util::round(zz));               
 
                                        // Here we trilinear interpolate the point value from the reference volume
                                        float xx0=floor(xx);
                                        float yy0=floor(yy);
                                        float zz0=floor(zz);
                                        std::complex<float>nodt=Util::trilinear_interpolate_complex(
                                                ref_vol->get_complex_at(xx0,yy0,zz0),
                                                ref_vol->get_complex_at(xx0+1,yy0,zz0),
                                                ref_vol->get_complex_at(xx0,yy0+1,zz0),
                                                ref_vol->get_complex_at(xx0+1,yy0+1,zz0),
                                                ref_vol->get_complex_at(xx0,yy0,zz0+1),
                                                ref_vol->get_complex_at(xx0+1,yy0,zz0+1),
                                                ref_vol->get_complex_at(xx0,yy0+1,zz0+1),
                                                ref_vol->get_complex_at(xx0+1,yy0+1,zz0+1),
                                                xx-xx0,yy-yy0,zz-zz0);
                                        
//                                      float h=1.0f/EMConsts::I5G;
                                        float h=1.0f/2.0f;              // This value was optimized empirically for a specific test case
                                        float gg=1.0;   //default no radial weight
                                        for (int k = z0 ; k <= z1; k++) {
                                                for (int j = y0 ; j <= y1; j++) {
                                                        for (int i = x0; i <= x1; i ++) {
                                                                if ((size_t)i*i+j*j+k*k>ny2sq) continue;
                                                                std::complex<float>ntdt=ref_vol->get_complex_at(i,j,k);
                                                                //gg=abs(nodt);                 // we use this as a weight
                                                                //if (gg==0) continue;
                                                                //gg=1.0;                       // turn off local weight
                                                                //std::complex<float>updt=dt*ntdt/nodt;         // This is the unweighted target value for i,j,k
                                                                std::complex<float>updt=dt+ntdt-nodt;
                                                                
                                                                float rl = Util::hypot3sq((float) i - xx, j - yy, k - zz);
                                                                gg = Util::fast_exp(-rl *h);
                                                                
                                                                size_t off;
                                                                off=image->add_complex_at_fast(i,j,k,updt*gg*weight);
                                                                tmp_data->get_data()[off/2]+=gg*weight;
                                                        }
                                                }
                                        }
                                } else {
                                        float h=1.0f/((Util::hypot3sq(xx,yy,zz)/4000)+.15);             // gaussian kernel is used as a weight not a kernel. We increase radius of integration with resolution. Changed away from this on 11/10/17
                                        h=h<0.1?0.1:h;  // new formula has h from 0.2 to 5
 
                                        float rl, gg;
                                        for (int k = z0 ; k <= z1; k++) {
                                                for (int j = y0 ; j <= y1; j++) {
                                                        for (int i = x0; i <= x1; i ++) {
                                                                rl = Util::hypot3sq((float) i - xx, j - yy, k - zz);
                                                                gg = Util::fast_exp(-rl *h);
 
                                                                size_t off;
                                                                off=image->add_complex_at_fast(i,j,k,dt*gg*weight);
                                                                //if (off==image->get_size()) 
                                                                //printf("%d %d %d\t%g %g %g %g\t%ld\n",i,j,k,dt.real(),dt.imag(),gg,weight,off);
                                                                tmp_data->get_data()[off/2]+=gg*weight;         // This is for interpolation rather than gridding
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }
        
        
        delete rotation; rotation=0;
        return 0;
}

◆ NEW()

static Reconstructor * EMAN::FourierIterReconstructor::NEW ( )

inlinestatic

Factory incorporation uses the pointer of this function.

Returns: a Reconstructor pointer to a newly allocated FourierReconstructor

Definition at line 795 of file reconstructor.h.

                {
                        return new FourierIterReconstructor();
                }

References FourierIterReconstructor().

◆ operator=()

FourierIterReconstructor & EMAN::FourierIterReconstructor::operator= ( const FourierIterReconstructor & )

private

Disallow assignment.

◆ preprocess_slice()

EMData * FourierIterReconstructor::preprocess_slice	(	const EMData *const	slice,
		const Transform &	t = `Transform()`
	)

virtual

Preprocess the slice prior to insertion into the 3D volume this Fourier tranforms the slice and make sure all the pixels are in the right position it always returns a copy of the provided slice, so it should be deleted by someone eventually.

Returns: the processed slice

Parameters

slice	the slice to be prepocessed
t	transform to be used for insertion

Exceptions

InvalidValueException when the specified padding value is less than the size of the images

Reimplemented from EMAN::Reconstructor.

Definition at line 505 of file reconstructor.cpp.

                                                                                                   { 
        // Shift the image pixels so the real space origin is now located at the phase origin (at the bottom left of the image)
        EMData* return_slice = 0;
        Transform tmp(t);
        tmp.set_rotation(Dict("type","eman")); // resets the rotation to 0 implicitly, this way we only do 2d translation,scaling and mirroring
 
        if (tmp.is_identity()) return_slice=slice->copy();
        else return_slice = slice->process("xform",Dict("transform",&tmp));
 
        return_slice->process_inplace("xform.phaseorigin.tocorner");
        return_slice->do_fft_inplace();
        return_slice->mult((float)sqrt(1.0f/(return_slice->get_ysize())*return_slice->get_xsize()));
 
        return_slice->set_attr("reconstruct_preproc",(int)1);
        return return_slice;
}

References EMAN::Transform::is_identity(), EMAN::Transform::set_rotation(), and sqrt().

◆ setup()

void FourierIterReconstructor::setup ( )

virtual

Setup the Fourier reconstructor.

Exceptions

InvalidValueException When one of the input parameters is invalid

Implements EMAN::Reconstructor.

Definition at line 430 of file reconstructor.cpp.

                                     {
        // default setting behavior - does not override if the parameter is already set
        params.set_default("verbose",(int)0);
        
        vector<int> size=params["size"];
 
        nx = size[0]+2;
        ny = size[1];
        nz = size[2];
        nx2=nx/2-2;
        ny2=ny/2;
        nz2=nz/2;
        
        subnx=nx; subny=ny; subnz=nz;
        subx0=suby0=subz0=0;
 
        if (nx%2==1) throw ImageDimensionException("ERROR: FourierIterReconstructor only supports even box sizes");
 
        // The fourier volume where the reconstruction lives
        if (image) delete image;
        image = new EMData(nx,ny,nz);
        image->set_complex(true);
        image->set_fftodd(false);
        image->set_ri(true);
        image->to_zero();
        
        // This is the normalization volume
        if (tmp_data) delete tmp_data;
        tmp_data = new EMData(nx/2,ny,nz);
        tmp_data->to_zero();
        
        // this is the reference volume used to define the interpolation kernel
        // regular "setup" doesn't have one, in which case we default to a local gaussian kernel
        // This should only happen during the first iteration
        if (ref_vol) { delete ref_vol; ref_vol=0; }
//      ref_vol = new EMData(nx,ny,nz);
//      ref_vol->set_complex(true);
//      ref_vol->set_fftodd(false);
//      ref_vol->set_ri(true);
//      ref_vol->to_one();
        
        
        
        if ( (bool) params["verbose"] )
        {
                cout << "3D Fourier dimensions are " << nx << " " << ny << " " << nz << endl;
                cout << "3D Fourier subvolume is " << subnx << " " << subny << " " << subnz << endl;
                printf ("You will require approximately %1.3g GB of memory to reconstruct this volume\n",((float)subnx*subny*subnz*sizeof(float)*2.5)/1000000000.0);
        }
        
}

Referenced by clear(), setup_seed(), and setup_seedandweights().

◆ setup_seed()

void FourierIterReconstructor::setup_seed	(	EMData *	seed,
		float	seed_weight
	)

virtual

Initialize the reconstructor with a seed volume.

This can be used to provide some 'default' value when there is missing data in Fourier space. The passed 'seed' must be of the appropriate padded size, must be in Fourier space, and the same EMData* object will be returned by finish(), meaning the Reconstructor is implicitly taking ownership of the object. However, in Python, this means the seed may be passed in without copying, as the same EMData will be coming back out at the end. The seed_weight determines how 'strong' the seed volume should be as compared to other inserted slices in Fourier space.

Exceptions

InvalidValueException When one of the input parameters is invalid

Reimplemented from EMAN::Reconstructor.

Definition at line 481 of file reconstructor.cpp.

                                                                        {
        setup();                // ok, a little dumb to initialize ref_vol then immediately delete it
        if (seed->is_complex()) ref_vol=seed->copy();   // we assume tocorner was called properly and dimensions are correct
        else {
                ref_vol=seed->do_fft();
                ref_vol->process_inplace("xform.phaseorigin.tocorner");
        }
}

References ref_vol, and setup().

◆ setup_seedandweights()

void FourierIterReconstructor::setup_seedandweights	(	EMData *	seed,
		EMData *	weight
	)

virtual

Initialize the reconstructor with a seed volume, as above.

In this case the initial weight map is also provided explicitly, rather than a single weight value.

Reimplemented from EMAN::Reconstructor.

Definition at line 490 of file reconstructor.cpp.

                                                                               {
        setup();                // ok, a little dumb to initialize ref_vol then immediately delete it
        if (seed->is_complex()) ref_vol=seed->copy();   // we assume tocorner was called properly and dimensions are correct
        else {
                ref_vol=seed->do_fft();
                ref_vol->process_inplace("xform.phaseorigin.tocorner");
        }
        printf("Warning: FourierIterReconstructor ignores seed weights");
}

References ref_vol, and setup().

Member Data Documentation

◆ NAME

const string FourierIterReconstructor::NAME = "fourier_iter"

static

Definition at line 812 of file reconstructor.h.

Referenced by get_name().

◆ ref_vol

EMData* EMAN::FourierIterReconstructor::ref_vol

protected

Definition at line 821 of file reconstructor.h.

Referenced by free_memory(), insert_slice(), setup(), setup_seed(), and setup_seedandweights().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ FourierIterReconstructor() [1/2]

◆ ~FourierIterReconstructor()

◆ FourierIterReconstructor() [2/2]

Member Function Documentation

◆ clear()

◆ determine_slice_agreement()

◆ finish()

◆ free_memory()

◆ get_desc()

◆ get_name()

◆ get_param_types()

◆ insert_slice()

◆ NEW()

◆ operator=()

◆ preprocess_slice()

◆ setup()

◆ setup_seed()

◆ setup_seedandweights()

Member Data Documentation

◆ NAME

◆ ref_vol