Direct Fourier inversion Reconstructor for extremly rectangular object. More...

#include <reconstructor.h>

Inheritance diagram for EMAN::nn4_rectReconstructor:

Collaboration diagram for EMAN::nn4_rectReconstructor:

[legend]

Public Member Functions
	nn4_rectReconstructor ()

	nn4_rectReconstructor (const string &symmetry, int size, int npad)

virtual	~nn4_rectReconstructor ()

virtual void	setup ()
	Initialize the reconstructor. More...

virtual int	insert_slice (const EMData *const slice, const Transform &euler, const float weight)
	Insert an image slice to the reconstructor. More...

virtual EMData *	finish (bool doift=true)
	Finish reconstruction and return the complete model. More...

virtual string	get_name () const
	Get the unique name of this class (especially for factory based instantiation access) More...

virtual string	get_desc () const
	Get a clear, concise description of this class. More...

virtual TypeDict	get_param_types () const

void	setup (const string &symmetry, int size, int npad)

int	insert_padfft_slice (EMData *padded, const Transform &trans, float mult=1)

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

virtual	~Reconstructor ()

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())
	While you can just insert unprocessed slices, if you call preprocess_slice yourself, and insert the returned slice instead, repeatedly, it can save a fair bit of computation. More...

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

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 *	projection (const Transform &euler, int ret_fourier=1)
	This will create a projection from the current reconstruction. More...

virtual void	clear ()
	set the volume and tmp_volume data to zero, for use in Monte Carlo reconstructors 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

Static Public Member Functions
static Reconstructor *	NEW ()

Static Public Attributes
static const string	NAME = "nn4_rect"

Private Member Functions
void	buildFFTVolume ()

void	buildNormVolume ()

void	load_default_settings ()

Private Attributes
EMData *	m_volume

EMData *	m_wptr

string	m_symmetry

int	m_weighting

int	m_vnx

int	m_vny

int	m_vnz

int	m_npad

int	m_nsym

int	m_ndim

int	m_vnzp

int	m_vnyp

int	m_vnxp

int	m_vnzc

int	m_vnyc

int	m_vnxc

int	m_count

float	m_xratio

float	m_yratio

float	m_zratio

float	m_xscale

float	m_yscale

int	m_sizeofprojection

float	m_wghta

float	m_wghtb

float	m_osnr

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

Detailed Description

Direct Fourier inversion Reconstructor for extremly rectangular object.

Definition at line 1100 of file reconstructor.h.

Constructor & Destructor Documentation

◆ nn4_rectReconstructor() [1/2]

nn4_rectReconstructor::nn4_rectReconstructor ( )

Definition at line 3451 of file reconstructor.cpp.

{
        m_volume = NULL;
        m_wptr   = NULL;
}

References m_volume, and m_wptr.

Referenced by NEW().

◆ nn4_rectReconstructor() [2/2]

nn4_rectReconstructor::nn4_rectReconstructor	(	const string &	symmetry,
		int	size,
		int	npad
	)

Definition at line 3457 of file reconstructor.cpp.

{
        m_volume = NULL;
        m_wptr   = NULL;
        setup( symmetry, size, npad );
        load_default_settings();
        print_params();
}

References load_default_settings(), m_volume, m_wptr, EMAN::Reconstructor::print_params(), and setup().

◆ ~nn4_rectReconstructor()

nn4_rectReconstructor::~nn4_rectReconstructor ( )

virtual

Definition at line 3466 of file reconstructor.cpp.

{
        //if( m_delete_volume ) checked_delete(m_volume);
 
        //if( m_delete_weight ) checked_delete( m_wptr );
 
        //checked_delete( m_result );
}

Member Function Documentation

◆ buildFFTVolume()

void nn4_rectReconstructor::buildFFTVolume ( )

private

Definition at line 3547 of file reconstructor.cpp.

                                           {
        int offset = 2 - m_vnxp%2;
 
        m_volume = params["fftvol"];
 
        if( m_volume->get_xsize() != m_vnxp+offset && m_volume->get_ysize() != m_vnyp && m_volume->get_zsize() != m_vnzp ) {
                m_volume->set_size(m_vnxp+offset,m_vnyp,m_vnzp);
                m_volume->to_zero();
        }
        // ----------------------------------------------------------------
        // Added by Zhengfan Yang on 03/15/07
        // Original author: please check whether my revision is correct and
        // other Reconstructor need similiar revision.
        if ( m_vnxp % 2 == 0 )  m_volume->set_fftodd(0);
        else                    m_volume->set_fftodd(1);
        // ----------------------------------------------------------------
 
        m_volume->set_nxc(m_vnxp/2);
        m_volume->set_complex(true);
        m_volume->set_ri(true);
        m_volume->set_fftpad(true);
        m_volume->set_attr("npad", m_npad);
        m_volume->set_array_offsets(0,1,1);
}

References m_npad, m_vnxp, m_vnyp, m_vnzp, m_volume, and EMAN::FactoryBase::params.

Referenced by setup().

◆ buildNormVolume()

void nn4_rectReconstructor::buildNormVolume ( )

private

Definition at line 3572 of file reconstructor.cpp.

                                            {
 
        m_wptr = params["weight"];
 
        if( m_wptr->get_xsize() != m_vnxc+1 &&
                m_wptr->get_ysize() != m_vnyp &&
                m_wptr->get_zsize() != m_vnzp ) {
                m_wptr->set_size(m_vnxc+1,m_vnyp,m_vnzp);
                m_wptr->to_zero();
        }
 
        m_wptr->set_array_offsets(0,1,1);
}

References m_vnxc, m_vnyp, m_vnzp, m_wptr, and EMAN::FactoryBase::params.

Referenced by setup().

◆ finish()

EMData * nn4_rectReconstructor::finish ( bool doift = true )

virtual

Finish reconstruction and return the complete model.

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 result 3D model.

Reimplemented from EMAN::Reconstructor.

Definition at line 3774 of file reconstructor.cpp.

{
        
        if( m_ndim==3 ) {
                m_volume->symplane0_rect(m_wptr);
        } else {
                for( int i=1; i <= m_vnyp; ++i ) {
 
                        if( (*m_wptr)(0, i, 1)==0.0 ) {
                                int j = m_vnyp + 1 - i;
                                (*m_wptr)(0, i, 1) = (*m_wptr)(0, j, 1);
                                (*m_volume)(0, i, 1) = (*m_volume)(0, j, 1);
                                (*m_volume)(1, i, 1) = (*m_volume)(1, j, 1);
                        }
                }
        }
 
 
        int box = 7;
        int kc = (box-1)/2;
        vector< float > pow_a( m_ndim*kc+1, 1.0 );
        for( unsigned int i=1; i < pow_a.size(); ++i ) pow_a[i] = pow_a[i-1] * exp(m_wghta);
        pow_a.back()=0.0;
 
        float alpha = 0.0;
        if( m_ndim==3) {
                int vol = box*box*box;
                float max = max3d( kc, pow_a );
                alpha = ( 1.0f - 1.0f/(float)vol ) / max;
        } else {
                int ara = box*box;
                float max = max2d( kc, pow_a );
                alpha = ( 1.0f - 1.0f/(float)ara ) / max;
        }
 
        int ix,iy,iz;
        for (iz = 1; iz <= m_vnzp; iz++) {
                for (iy = 1; iy <= m_vnyp; iy++) {
                        for (ix = 0; ix <= m_vnxc; ix++) {
                                if ( (*m_wptr)(ix,iy,iz) > 0) {//(*v) should be treated as complex!!
                                        float tmp;
                                        tmp = (-2*((ix+iy+iz)%2)+1)/((*m_wptr)(ix,iy,iz)+m_osnr);
                                        
                                        if( m_weighting == ESTIMATE ) {
                                                int cx = ix;
                                                int cy = (iy<=m_vnyc) ? iy - 1 : iy - 1 - m_vnyp;
                                                int cz = (iz<=m_vnzc) ? iz - 1 : iz - 1 - m_vnzp;
                                                float sum = 0.0;
                                                for( int ii = -kc; ii <= kc; ++ii ) {
                                                        int nbrcx = cx + ii;
                                                        if( nbrcx >= m_vnxc ) continue;
                                                        for( int jj= -kc; jj <= kc; ++jj ) {
                                                                int nbrcy = cy + jj;
                                                                if( nbrcy <= -m_vnyc || nbrcy >= m_vnyc ) continue;
 
                                                                int kcz = (m_ndim==3) ? kc : 0;
                                                                for( int kk = -kcz; kk <= kcz; ++kk ) {
                                                                        int nbrcz = cz + kk;
                                                                        if( nbrcz <= -m_vnyc || nbrcz >= m_vnyc ) continue;
                                                                        if( nbrcx < 0 ) {
                                                                                nbrcx = -nbrcx;
                                                                                nbrcy = -nbrcy;
                                                                                nbrcz = -nbrcz;
                                                                        }
                                                                        int nbrix = nbrcx;
                                                                        int nbriy = nbrcy >= 0 ? nbrcy + 1 : nbrcy + 1 + m_vnyp;
                                                                        int nbriz = nbrcz >= 0 ? nbrcz + 1 : nbrcz + 1 + m_vnzp;
                                                                        if( (*m_wptr)( nbrix, nbriy, nbriz ) == 0 ) {
                                                                                int c = m_ndim*kc+1 - std::abs(ii) - std::abs(jj) - std::abs(kk);
                                                                                sum = sum + pow_a[c];
                                                                        }
                                                                }
                                                        }
                                                }
                                                float wght = 1.0f / ( 1.0f - alpha * sum );
                                                tmp = tmp * wght;
                                        }
                                        (*m_volume)(2*ix,iy,iz)   *= tmp;
                                        (*m_volume)(2*ix+1,iy,iz) *= tmp;
                                }
                        }
                }
        }
 
        //if(m_ndim==2) printImage( m_volume );
 
        // back fft
        m_volume->do_ift_inplace();
 
        
        int npad = m_volume->get_attr("npad");
        m_volume->depad();
        circumfnn_rect( m_volume, npad );
        m_volume->set_array_offsets( 0, 0, 0 );
 
        return 0;
}

References circumfnn_rect(), ESTIMATE, m_ndim, m_osnr, m_vnxc, m_vnyc, m_vnyp, m_vnzc, m_vnzp, m_volume, m_weighting, m_wghta, m_wptr, max2d(), and max3d().

◆ get_desc()

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

inlinevirtual

Get a clear, concise description of this class.

Returns: a clear, concise description of this class

Implements EMAN::FactoryBase.

Definition at line 1128 of file reconstructor.h.

                {
                        return "Direct Fourier inversion routine";
                }

◆ get_name()

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

inlinevirtual

Get the unique name of this class (especially for factory based instantiation access)

Returns: the unique name of this class

Implements EMAN::FactoryBase.

Definition at line 1123 of file reconstructor.h.

                {
                        return NAME;
                }

References NAME.

◆ get_param_types()

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

inlinevirtual

Returns: a TypeDict defining and describing the feasible parameters of this class

Implements EMAN::FactoryBase.

Definition at line 1138 of file reconstructor.h.

                {
                        TypeDict d;
                        d.put("sizeprojection", EMObject::INT);
                        d.put("sizex",          EMObject::INT);
                        d.put("sizey",          EMObject::INT);
                        d.put("sizez",          EMObject::INT);
                        d.put("xratio",         EMObject::FLOAT);
                        d.put("yratio",         EMObject::FLOAT);
                        d.put("zratio",         EMObject::FLOAT);
                        d.put("npad",           EMObject::INT);
                        d.put("sign",           EMObject::INT);
                        d.put("ndim",           EMObject::INT);
                        d.put("snr",            EMObject::FLOAT);
                        d.put("symmetry",       EMObject::STRING);
                        d.put("snr",            EMObject::FLOAT);
                        d.put("fftvol",         EMObject::EMDATA);
                        d.put("weight",         EMObject::EMDATA);
                        d.put("weighting",  EMObject::INT);
                        return d;
                }

References EMAN::EMObject::EMDATA, EMAN::EMObject::FLOAT, EMAN::EMObject::INT, EMAN::TypeDict::put(), and EMAN::EMObject::STRING.

◆ insert_padfft_slice()

int nn4_rectReconstructor::insert_padfft_slice	(	EMData *	padded,
		const Transform &	trans,
		float	mult = `1`
	)

Definition at line 3682 of file reconstructor.cpp.

{
        Assert( padded != NULL );
                
        vector<Transform> tsym = t.get_sym_proj(m_symmetry);
        for (unsigned int isym=0; isym < tsym.size(); isym++)
                m_volume->insert_rect_slice(m_wptr, padded, tsym[isym], m_sizeofprojection, m_xratio, m_yratio, m_zratio, m_npad, weight);
 
        return 0;
 
}

References Assert, EMAN::Transform::get_sym_proj(), m_npad, m_sizeofprojection, m_symmetry, m_volume, m_wptr, m_xratio, m_yratio, and m_zratio.

Referenced by insert_slice().

◆ insert_slice()

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

virtual

Insert an image slice to the reconstructor.

To insert multiple image slices, call this function multiple times.

Parameters

slice	Image slice.
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.

Reimplemented from EMAN::Reconstructor.

Definition at line 3586 of file reconstructor.cpp.

                                                                                                         {
        // sanity checks
 
 
        if (!slice) {
                LOGERR("try to insert NULL slice");
                return 1;
        }
 
        int padffted= slice->get_attr_default( "padffted", 0 );
        if( m_ndim==3 ) {
                if ( padffted==0 && (slice->get_xsize()!=slice->get_ysize() || slice->get_xsize()!=m_sizeofprojection)  ) {
                        // FIXME: Why doesn't this throw an exception?
                        LOGERR("Tried to insert a slice that is the wrong size.");
                        return 1;
                }
        } 
        if (m_ndim==2) {
                if( slice->get_ysize() !=1 ) {
                        LOGERR( "for 2D reconstruction, a line is excepted" );
                        return 1;
                }
        }
        if( weight > 0.0f )  {
 
                EMData* padfft = padfft_slice( slice, t,  m_npad );
                
                //Assert( mult > 0 );
 
                if( m_ndim==3 ) {
                        insert_padfft_slice( padfft, t, weight );               
                } else {
                        float ellipse_length,ellipse_step,cos_alpha,sin_alpha;
                        int ellipse_length_int;
                        float alpha = padfft->get_attr( "alpha" );
                        alpha = alpha/180.0f*M_PI;
                        int loop_range;
                        float temp1,temp2;
                                        temp1=m_xratio*cos(alpha)*float(m_sizeofprojection*m_npad)/2;
                        temp2=m_yratio*sin(alpha)*float(m_sizeofprojection*m_npad)/2;
                        ellipse_length=sqrt(temp1*temp1+temp2*temp2);
                        ellipse_length_int=int(ellipse_length);
                        ellipse_step=0.5f*(m_sizeofprojection*m_npad)/float(ellipse_length_int);
                        loop_range=ellipse_length_int;
                        cos_alpha=temp1/ellipse_length;
                        sin_alpha=temp2/ellipse_length;
                        if(m_count%100==0) {
                                std::cout<<"#############################################################"<<std::endl;
                                std::cout<<"line insert start=="<<m_count<<std::endl;
                                std::cout<<"ellipse length=="<<ellipse_length_int<<"ellips step=="<<ellipse_step<<std::endl;
                                std::cout<<"loop_range"<<loop_range<<std::endl;
                                                        std::cout<<"x and y ratio=="<<m_xratio<<"  "<<m_yratio<<std::endl;
                                std::cout<<"cos sin of alpha=="<<cos(alpha)<<"   "<<sin(alpha)<<std::endl;
                                std::cout<<"cos sin of alpha_new==="<<cos_alpha<<sin_alpha<<std::endl;
                                std::cout<<"alpah dig==="<<cos_alpha<<sin_alpha<<std::endl;
                                std::cout<<"prjection maximum==="<<loop_range*ellipse_step<<"ideal maximum"<<m_sizeofprojection*m_npad/2<<std::endl;
                                std::cout<<"x_size=="<<m_volume->get_xsize()<<"y_size=="<<m_volume->get_ysize()<<std::endl;
                                std::cout<<"#############################################################"<<std::endl;
                        }
                        for(int i=0; i <=loop_range; ++i ) {
                                float xnew = i*cos_alpha;
                                float ynew = -i*sin_alpha;
                                if(m_count%100==0&&i==loop_range)
                                        std::cout<<"x_new=="<<xnew<<"Y_new=="<<ynew<<std::endl;
                                float btqr=0,btqi=0;
                                float xprj=i*ellipse_step;
                                float t=xprj-int(xprj);
                                btqr = (1-t)*padfft->get_value_at( 2*int(xprj), 0, 0 )+t*padfft->get_value_at( 2*(1+int(xprj)), 0, 0 );
                                btqi = (1-t)*padfft->get_value_at( 2*int(xprj)+1, 0, 0 )+t*padfft->get_value_at( 2*(1+int(xprj))+1, 0, 0 );
                                if( xnew < 0.0 ) {
                                        xnew *= -1;
                                        ynew *= -1;
                                        btqi *= -1;
                                }
 
                                int ixn = int(xnew+0.5+m_vnxp) - m_vnxp;
                                int iyn = int(ynew+0.5+m_vnyp) - m_vnyp;
 
                                if(iyn < 0 ) iyn += m_vnyp;
                                if(m_count%100==0&&i==loop_range)
                                        std::cout<<"xnn=="<<ixn<<"ynn=="<<iyn<<std::endl;
                                (*m_volume)( 2*ixn, iyn+1, 1 )   += btqr * weight;
                                (*m_volume)( 2*ixn+1, iyn+1, 1 ) += btqi * weight;
                                (*m_wptr)(ixn,iyn+1, 1) += weight;
                        }
 
 
                }
                checked_delete( padfft );
                return 0;
        } else return 0;
}

References checked_delete(), insert_padfft_slice(), LOGERR, m_count, m_ndim, m_npad, m_sizeofprojection, m_vnxp, m_vnyp, m_volume, m_xratio, m_yratio, EMAN::padfft_slice(), and sqrt().

◆ load_default_settings()

void EMAN::nn4_rectReconstructor::load_default_settings ( )

inlineprivate

Definition at line 1186 of file reconstructor.h.

                {
                        //params["use_weights"] = false;
                }

Referenced by nn4_rectReconstructor().

◆ NEW()

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

inlinestatic

Definition at line 1133 of file reconstructor.h.

                {
                        return new nn4_rectReconstructor();
                }

References nn4_rectReconstructor().

◆ setup() [1/2]

void nn4_rectReconstructor::setup ( )

virtual

Initialize the reconstructor.

Implements EMAN::Reconstructor.

Definition at line 3476 of file reconstructor.cpp.

{
        m_sizeofprojection = params["sizeprojection"];
        int npad = params["npad"];
        m_count=0;
 
        string symmetry;
        if( params.has_key("symmetry") )  symmetry = params["symmetry"].to_str();
        else                               symmetry = "c1";
 
        if( params.has_key("ndim") )  m_ndim = params["ndim"];             
        else                            m_ndim = 3;
    
        if( params.has_key( "snr" ) )  m_osnr = 1.0f/float( params["snr"] );
        else                           m_osnr = 0.0;
 
        setup( symmetry, m_sizeofprojection, npad );
}

References EMAN::Dict::has_key(), m_count, m_ndim, m_osnr, m_sizeofprojection, EMAN::FactoryBase::params, and setup().

Referenced by nn4_rectReconstructor(), and setup().

◆ setup() [2/2]

void nn4_rectReconstructor::setup	(	const string &	symmetry,
		int	size,
		int	npad
	)

Definition at line 3495 of file reconstructor.cpp.

{
        m_weighting = ESTIMATE;
        m_wghta = 0.2f;
        m_symmetry = symmetry;
        m_npad = npad;
        m_nsym = Transform::get_nsym(m_symmetry);
 
        if( params.has_key("sizex") )  m_vnx = params["sizex"];
        else if(params.has_key("xratio")) 
                {
                float temp=params["xratio"];
                m_vnx=int(float(sizeprojection)*temp);
                }
        else                           m_vnx=sizeprojection;
 
        if( params.has_key("sizey") )  m_vny = params["sizey"];
        else if (params.has_key("yratio"))  
               {
                float temp=params["yratio"];
                 m_vny=int(float(sizeprojection)*temp);
                }
        else m_vny=sizeprojection;
 
        if( params.has_key("sizez") ) 
                m_vnz = params["sizez"];
        else 
                if (params.has_key("zratio"))
                {
                        float temp=params["zratio"];
                        m_vnz=int(float(sizeprojection)*temp);
                }
                else                          
                        m_vnz = (m_ndim==3) ? sizeprojection : 1;
        
        m_xratio=float(m_vnx)/float(sizeprojection);    
        m_yratio=float(m_vny)/float(sizeprojection);
        m_zratio=float(m_vnz)/float(sizeprojection);
 
        m_vnxp = m_vnx*npad;
        m_vnyp = m_vny*npad;
        m_vnzp = (m_ndim==3) ? m_vnz*npad : 1;
 
        m_vnxc = m_vnxp/2;
        m_vnyc = m_vnyp/2;
        m_vnzc = (m_ndim==3) ? m_vnzp/2 : 1;
 
        buildFFTVolume();
        buildNormVolume();
}

References buildFFTVolume(), buildNormVolume(), ESTIMATE, EMAN::Transform::get_nsym(), EMAN::Dict::has_key(), m_ndim, m_npad, m_nsym, m_symmetry, m_vnx, m_vnxc, m_vnxp, m_vny, m_vnyc, m_vnyp, m_vnz, m_vnzc, m_vnzp, m_weighting, m_wghta, m_xratio, m_yratio, m_zratio, and EMAN::FactoryBase::params.

Member Data Documentation

◆ m_count

int EMAN::nn4_rectReconstructor::m_count

private

Definition at line 1177 of file reconstructor.h.

Referenced by insert_slice(), and setup().

◆ m_ndim

int EMAN::nn4_rectReconstructor::m_ndim

private

Definition at line 1174 of file reconstructor.h.

Referenced by finish(), insert_slice(), and setup().

◆ m_npad

int EMAN::nn4_rectReconstructor::m_npad

private

Definition at line 1172 of file reconstructor.h.

Referenced by buildFFTVolume(), insert_padfft_slice(), insert_slice(), and setup().

◆ m_nsym

int EMAN::nn4_rectReconstructor::m_nsym

private

Definition at line 1173 of file reconstructor.h.

Referenced by setup().

◆ m_osnr

float EMAN::nn4_rectReconstructor::m_osnr

private

Definition at line 1185 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_sizeofprojection

int EMAN::nn4_rectReconstructor::m_sizeofprojection

private

Definition at line 1180 of file reconstructor.h.

Referenced by insert_padfft_slice(), insert_slice(), and setup().

◆ m_symmetry

string EMAN::nn4_rectReconstructor::m_symmetry

private

Definition at line 1169 of file reconstructor.h.

Referenced by insert_padfft_slice(), and setup().

◆ m_vnx

int EMAN::nn4_rectReconstructor::m_vnx

private

Definition at line 1171 of file reconstructor.h.

Referenced by setup().

◆ m_vnxc

int EMAN::nn4_rectReconstructor::m_vnxc

private

Definition at line 1176 of file reconstructor.h.

Referenced by buildNormVolume(), finish(), and setup().

◆ m_vnxp

int EMAN::nn4_rectReconstructor::m_vnxp

private

Definition at line 1175 of file reconstructor.h.

Referenced by buildFFTVolume(), insert_slice(), and setup().

◆ m_vny

int EMAN::nn4_rectReconstructor::m_vny

private

Definition at line 1171 of file reconstructor.h.

Referenced by setup().

◆ m_vnyc

int EMAN::nn4_rectReconstructor::m_vnyc

private

Definition at line 1176 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_vnyp

int EMAN::nn4_rectReconstructor::m_vnyp

private

Definition at line 1175 of file reconstructor.h.

Referenced by buildFFTVolume(), buildNormVolume(), finish(), insert_slice(), and setup().

◆ m_vnz

int EMAN::nn4_rectReconstructor::m_vnz

private

Definition at line 1171 of file reconstructor.h.

Referenced by setup().

◆ m_vnzc

int EMAN::nn4_rectReconstructor::m_vnzc

private

Definition at line 1176 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_vnzp

int EMAN::nn4_rectReconstructor::m_vnzp

private

Definition at line 1175 of file reconstructor.h.

Referenced by buildFFTVolume(), buildNormVolume(), finish(), and setup().

◆ m_volume

EMData* EMAN::nn4_rectReconstructor::m_volume

private

Definition at line 1167 of file reconstructor.h.

Referenced by buildFFTVolume(), finish(), insert_padfft_slice(), insert_slice(), and nn4_rectReconstructor().

◆ m_weighting

int EMAN::nn4_rectReconstructor::m_weighting

private

Definition at line 1170 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_wghta

float EMAN::nn4_rectReconstructor::m_wghta

private

Definition at line 1183 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_wghtb

float EMAN::nn4_rectReconstructor::m_wghtb

private

Definition at line 1184 of file reconstructor.h.

◆ m_wptr

EMData* EMAN::nn4_rectReconstructor::m_wptr

private

Definition at line 1168 of file reconstructor.h.

Referenced by buildNormVolume(), finish(), insert_padfft_slice(), and nn4_rectReconstructor().

◆ m_xratio

float EMAN::nn4_rectReconstructor::m_xratio

private

Definition at line 1178 of file reconstructor.h.

Referenced by insert_padfft_slice(), insert_slice(), and setup().

◆ m_xscale

float EMAN::nn4_rectReconstructor::m_xscale

private

Definition at line 1179 of file reconstructor.h.

◆ m_yratio

float EMAN::nn4_rectReconstructor::m_yratio

private

Definition at line 1178 of file reconstructor.h.

Referenced by insert_padfft_slice(), insert_slice(), and setup().

◆ m_yscale

float EMAN::nn4_rectReconstructor::m_yscale

private

Definition at line 1179 of file reconstructor.h.

◆ m_zratio

float EMAN::nn4_rectReconstructor::m_zratio

private

Definition at line 1178 of file reconstructor.h.

Referenced by insert_padfft_slice(), and setup().

◆ NAME

const string nn4_rectReconstructor::NAME = "nn4_rect"

static

Definition at line 1164 of file reconstructor.h.

Referenced by get_name().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ nn4_rectReconstructor() [1/2]

◆ nn4_rectReconstructor() [2/2]

◆ ~nn4_rectReconstructor()

Member Function Documentation

◆ buildFFTVolume()

◆ buildNormVolume()

◆ finish()

◆ get_desc()

◆ get_name()

◆ get_param_types()

◆ insert_padfft_slice()

◆ insert_slice()

◆ load_default_settings()

◆ NEW()

◆ setup() [1/2]

◆ setup() [2/2]

Member Data Documentation

◆ m_count

◆ m_ndim

◆ m_npad

◆ m_nsym

◆ m_osnr

◆ m_sizeofprojection

◆ m_symmetry

◆ m_vnx

◆ m_vnxc

◆ m_vnxp

◆ m_vny

◆ m_vnyc

◆ m_vnyp

◆ m_vnz

◆ m_vnzc

◆ m_vnzp

◆ m_volume

◆ m_weighting

◆ m_wghta

◆ m_wghtb

◆ m_wptr

◆ m_xratio

◆ m_xscale

◆ m_yratio

◆ m_yscale

◆ m_zratio

◆ NAME