BoxStatProcessor files are a kind of neighborhood processors. More...

#include <processor.h>

Inheritance diagram for EMAN::BoxStatProcessor:

[legend]

Collaboration diagram for EMAN::BoxStatProcessor:

Public Member Functions
virtual void	process_inplace (EMData *image)
	To process an image in-place. More...

virtual EMData *	process (EMData *image)

TypeDict	get_param_types () const
	Get processor parameter information in a dictionary. More...

Public Member Functions inherited from EMAN::Processor
virtual	~Processor ()

virtual EMData *	process (const EMData *const image)
	To proccess an image out-of-place. More...

virtual void	process_list_inplace (vector< EMData * > &images)
	To process multiple images using the same algorithm. More...

virtual string	get_name () const =0
	Get the processor's name. More...

virtual Dict	get_params () const
	Get the processor parameters in a key/value dictionary. More...

virtual void	set_params (const Dict &new_params)
	Set the processor parameters using a key/value dictionary. More...

virtual string	get_desc () const =0
	Get the descrition of this specific processor. More...

Static Public Member Functions
static string	get_group_desc ()

Static Public Member Functions inherited from EMAN::Processor
static string	get_group_desc ()
	Get the description of this group of processors. More...

static void	EMFourierFilterInPlace (EMData *fimage, Dict params)
	Compute a Fourier-filter processed image in place. More...

static EMData *	EMFourierFilter (EMData *fimage, Dict params)
	Compute a Fourier-processor processed image without altering the original image. More...

Protected Member Functions
virtual void	process_pixel (float pixel, const float array, int n) const =0

Additional Inherited Members
Public Types inherited from EMAN::Processor
enum	fourier_filter_types { TOP_HAT_LOW_PASS , TOP_HAT_HIGH_PASS , TOP_HAT_BAND_PASS , TOP_HOMOMORPHIC , GAUSS_LOW_PASS , GAUSS_HIGH_PASS , GAUSS_BAND_PASS , GAUSS_INVERSE , GAUSS_HOMOMORPHIC , BUTTERWORTH_LOW_PASS , BUTTERWORTH_HIGH_PASS , BUTTERWORTH_HOMOMORPHIC , KAISER_I0 , KAISER_SINH , KAISER_I0_INVERSE , KAISER_SINH_INVERSE , SHIFT , TANH_LOW_PASS , TANH_HIGH_PASS , TANH_HOMOMORPHIC , TANH_BAND_PASS , RADIAL_TABLE , CTF_ }
	Fourier filter Processor type enum. More...

Protected Attributes inherited from EMAN::Processor
Dict	params

Detailed Description

BoxStatProcessor files are a kind of neighborhood processors.

These processors compute every output pixel using information from a reduced region on the neighborhood of the input pixel. The classical form are the 3x3 processors. BoxStatProcessors could perform diverse tasks ranging from noise reduction, to differential , to mathematical morphology. BoxStatProcessor class is the base class. Specific BoxStatProcessor needs to define process_pixel(float *pixel, const float *array, int n).

Parameters

radius The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1)

Definition at line 4479 of file processor.h.

Member Function Documentation

◆ get_group_desc()

static string EMAN::BoxStatProcessor::get_group_desc ( )

inlinestatic

Definition at line 4485 of file processor.h.

                {
                        return "BoxStatProcessor files are real-space neighborhood processors. These processors compute every output pixel using information from a reduced region on the neighborhood of the input pixel. The classical form are the 3x3 processors. BoxStatProcessors could perform diverse tasks ranging from noise reduction, to differential , to mathematical morphology. BoxStatProcessor class is the base class. Specific BoxStatProcessor needs to define process_pixel(float *pixel, const float *array, int n).";
                }

◆ get_param_types()

TypeDict EMAN::BoxStatProcessor::get_param_types ( ) const

inlinevirtual

Get processor parameter information in a dictionary.

Each parameter has one record in the dictionary. Each record contains its name, data-type, and description.

Returns: A dictionary containing the parameter info.

Reimplemented from EMAN::Processor.

Reimplemented in EMAN::PeakOnlyProcessor, and EMAN::BwMajorityProcessor.

Definition at line 4490 of file processor.h.

                {
                        TypeDict d;
                        d.put("radius", EMObject::INT, "The 'radius' of the (square/cube) search box, eg - 1 -> 3x3 box");
                        d.put("xsize", EMObject::INT, "+- range on X axis, 0 uses the value only, 1 -> -1,0,+1, ...");
                        d.put("ysize", EMObject::INT, "+- range on Y axis");
                        d.put("zsize", EMObject::INT, "+- range on Z axis)");
                        return d;
                }

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

◆ process()

EMData * BoxStatProcessor::process ( EMData * image )

virtual

Definition at line 2658 of file processor.cpp.

{
        if (!image) {
                LOGWARN("NULL Image");
                return NULL;
        }
 
 
        int nx = image->get_xsize();
        int ny = image->get_ysize();
        int nz = image->get_zsize();
 
        int dx=1,dy=1,dz=1;
        if (params.has_key("radius")) dx=dy=dz=params["radius"];
        if (params.has_key("xsize")) dx=params["xsize"];
        if (params.has_key("ysize")) dy=params["ysize"];
        if (params.has_key("zsize")) dz=params["zsize"];
        if (nz==1) dz=0;
 
        int matrix_size = (2*dx+1)*(2*dy+1)*(2*dz+1);
 
        vector<float> array(matrix_size);
//      image->process_inplace("normalize");
 
        EMData *ret = image->copy_head();
        
        // The old version of this code had a lot of hand optimizations, which likely weren't accomplishing much
        // This is much simpler, but relies on the compiler to optimize. May be some cost associated with the new
        // edge-mirroring policy which could be hand optomized if necessary
        for (int k=0; k<nz; k++) {
                for (int j=0; j<ny; j++) {
                        for (int i=0; i<nx; i++) {
                                
                                for (int kk=k-dz,s=0; kk<=k+dz; kk++) {
                                        for (int jj=j-dy; jj<=j+dy; jj++) {
                                                for (int ii=i-dx; ii<=i+dx; ii++,s++) {
                                                        array[s]=image->get_value_at(MIRE(ii,nx),MIRE(jj,ny),MIRE(kk,nz));
                                                }
                                        }
                                }
                                float newv=image->get_value_at(i,j,k);
                                process_pixel(&newv,array.data(),matrix_size);
                                ret->set_value_at(i,j,k,newv);
                        }
                }
        }
        
        ret->update();
        
        return ret;
}

References EMAN::Dict::has_key(), LOGWARN, MIRE(), EMAN::Processor::params, and process_pixel().

Referenced by process_inplace().

◆ process_inplace()

void BoxStatProcessor::process_inplace ( EMData * image )

virtual

To process an image in-place.

For those processors which can only be processed out-of-place, override this function to just print out some error message to remind user call the out-of-place version.

Parameters

image The image to be processed.

Implements EMAN::Processor.

Definition at line 2649 of file processor.cpp.

                                                    {
        EMData *cpy = process(image);
        memcpy(image->get_data(),cpy->get_data(),image->get_size()*sizeof(float));
        delete cpy;
}

References process().

◆ process_pixel()

virtual void EMAN::BoxStatProcessor::process_pixel	(	float *	pixel,
		const float *	array,
		int	n
	)		const

protectedpure virtual

Implemented in EMAN::BoxMedianProcessor, EMAN::BwMajorityProcessor, EMAN::BoxSigmaProcessor, EMAN::BoxMaxProcessor, EMAN::LocalMinAbsProcessor, EMAN::MinusPeakProcessor, and EMAN::PeakOnlyProcessor.

Referenced by process().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions