EMAN2
Public Types | Public Member Functions | Static Public Member Functions | Protected Attributes | Static Private Member Functions
EMAN::Processor Class Reference

Typical usage of Processors are as follows: More...

#include <processor.h>

Inherited by EMAN::ACFCenterProcessor, EMAN::AddMaskShellProcessor, EMAN::AddNoiseProcessor, EMAN::AddRandomNoiseProcessor, EMAN::AddShapeProcessor, EMAN::AmpweightFourierProcessor, EMAN::ApplySymProcessor, EMAN::AreaProcessor, EMAN::AutoMask2DProcessor, EMAN::AutoMask3D2Processor, EMAN::AutoMask3DProcessor, EMAN::AutoMaskAsymUnit, EMAN::AutoMaskDustProcessor, EMAN::AverageXProcessor, EMAN::Axis0FourierProcessor, EMAN::BeamstopProcessor, EMAN::BilateralProcessor, EMAN::BinarizeFourierProcessor, EMAN::BinaryOperateProcessor< Type >, EMAN::BinarySkeletonizerProcessor, EMAN::BoxStatProcessor, EMAN::CCDNormProcessor, EMAN::ClampingProcessor, EMAN::ComplexPixelProcessor, EMAN::ConvolutionKernelProcessor, EMAN::ConvolutionProcessor, EMAN::CoordinateMaskFileProcessor, EMAN::CoordinateProcessor, EMAN::CtfSimProcessor, EMAN::CutoffBlockProcessor, EMAN::DecayEdgeProcessor, EMAN::DiffBlockProcessor, EMAN::DirectionalSumProcessor, EMAN::DistanceSegmentProcessor, EMAN::FFTProcessor, EMAN::FFTResampleProcessor, EMAN::FileFourierProcessor, EMAN::FlattenBackgroundProcessor, EMAN::FlipProcessor, EMAN::FourierAnlProcessor, EMAN::FourierProcessor, EMAN::FourierToCenterProcessor, EMAN::FourierToCornerProcessor, EMAN::FSCFourierProcessor, EMAN::GradientPlaneRemoverProcessor, EMAN::GradientRemoverProcessor, EMAN::HistogramBin, EMAN::ImageProcessor, EMAN::IndexMaskFileProcessor, EMAN::IntTranslateProcessor, EMAN::IterBinMaskProcessor, EMAN::IterMultiMaskProcessor, EMAN::KmeansSegmentProcessor, EMAN::LinearPyramidProcessor, EMAN::LocalNormProcessor, EMAN::MaxShrinkProcessor, EMAN::MeanShrinkProcessor, EMAN::MeanZeroEdgeProcessor, EMAN::MedianShrinkProcessor, EMAN::MinShrinkProcessor, EMAN::MirrorProcessor, EMAN::ModelHelixProcessor, EMAN::NewFourierProcessor, EMAN::NonConvexProcessor, EMAN::NormalizeByMassProcessor, EMAN::NormalizeProcessor, EMAN::NormalizeRampNormVar, EMAN::NormalizeRowProcessor, EMAN::NormalizeToLeastSquareProcessor, EMAN::PaintProcessor, EMAN::Phase180Processor, EMAN::PhaseToMassCenterProcessor, EMAN::RadialProcessor, EMAN::RampProcessor, EMAN::RealPixelProcessor, EMAN::RealToFFTProcessor, EMAN::Rotate180Processor, EMAN::RotateInFSProcessor, EMAN::RotationalAverageProcessor, EMAN::RotationalSubstractProcessor, EMAN::ScaleTransformProcessor, EMAN::SigmaZeroEdgeProcessor, EMAN::SmartMaskProcessor, EMAN::SNREvalProcessor, EMAN::SNRProcessor, EMAN::StripeXYProcessor, EMAN::SubtractOptProcessor, EMAN::SymSearchProcessor, EMAN::TestImageProcessor, EMAN::ToMassCenterProcessor, EMAN::ToMinvalProcessor, EMAN::TomoTiltAngleWeightProcessor, EMAN::TomoTiltEdgeMaskProcessor, EMAN::TransformProcessor, EMAN::TransposeProcessor, EMAN::VerticalStripeProcessor, EMAN::WatershedProcessor, EMAN::WaveletProcessor, EMAN::Wiener2DAutoAreaProcessor, EMAN::Wiener2DFourierProcessor, EMAN::XGradientProcessor, EMAN::XYZProcessor, EMAN::YGradientProcessor, EMAN::ZeroEdgePlaneProcessor, EMAN::ZeroEdgeRowProcessor, and EMAN::ZGradientProcessor.

Collaboration diagram for EMAN::Processor:
Collaboration graph
[legend]

List of all members.

Public Types

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

Public Member Functions

virtual ~Processor ()
virtual void process_inplace (EMData *image)=0
 To process an image in-place.
virtual EMDataprocess (const EMData *const image)
 To proccess an image out-of-place.
virtual void process_list_inplace (vector< EMData * > &images)
 To process multiple images using the same algorithm.
virtual string get_name () const =0
 Get the processor's name.
virtual Dict get_params () const
 Get the processor parameters in a key/value dictionary.
virtual void set_params (const Dict &new_params)
 Set the processor parameters using a key/value dictionary.
virtual TypeDict get_param_types () const
 Get processor parameter information in a dictionary.
virtual string get_desc () const =0
 Get the descrition of this specific processor.

Static Public Member Functions

static string get_group_desc ()
 Get the description of this group of processors.
static void EMFourierFilterInPlace (EMData *fimage, Dict params)
 Compute a Fourier-filter processed image in place.
static EMDataEMFourierFilter (EMData *fimage, Dict params)
 Compute a Fourier-processor processed image without altering the original image.

Protected Attributes

Dict params

Static Private Member Functions

static EMDataEMFourierFilterFunc (EMData *fimage, Dict params, bool doInPlace=true)
 Compute a Fourier-filter processed image.

Detailed Description

Typical usage of Processors are as follows:

Definition at line 93 of file processor.h.


Member Enumeration Documentation

Fourier filter Processor type enum.

New Fourier filter processors are computed in a single function, EMFourierFilterFunc, that uses a large switch statement to apply the correct filter processor. This enum specifies the filter processor to be applied.

Enumerator:
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_ 

Definition at line 186 of file processor.h.


Constructor & Destructor Documentation

virtual EMAN::Processor::~Processor ( ) [inline, virtual]

Definition at line 96 of file processor.h.

                {
                }

Member Function Documentation

static EMData* EMAN::Processor::EMFourierFilter ( EMData fimage,
Dict  params 
) [inline, static]

Compute a Fourier-processor processed image without altering the original image.

Purpose: Apply selected Fourier space processor to 1-,2-, or 3-D image.
Method:
Parameters:
fimageInput image object to be processeded, either a real-space image or a Fourier-space image. Image may be 1-, 2-, or 3-dimensional.
[in]paramsProcessor parameters. Different processors require different parameters, so we this routine accepts a dictionary of parameters and looks up the appropriate params for the chosen processor processor at run time. All processors use the "dopad" parameter to determine whether the Fourier workspace array should be zero- padded to twice the original length (dopad == 1) or not zero-padded at all (dopad == 0).
Returns:
1-, 2-, or 3-dimensional filter processed image. If the input image is a real-space image, then the returned output image will also be a real-space image. Similarly, if the input image is already a Fourier image, then the output image will be a Fourier image.

Definition at line 268 of file processor.h.

References EMFourierFilterFunc().

                                                             {
                        bool doInPlace = false;
                        return EMFourierFilterFunc(fimage, params, doInPlace);
                }
EMData * Processor::EMFourierFilterFunc ( EMData fimage,
Dict  params,
bool  doInPlace = true 
) [static, private]

Compute a Fourier-filter processed image.

This function is called by either of the convience functions EMFourierFilter or EMFourierFilterInPlace.

Purpose: Apply selected Fourier space processor to 1-,2-, or 3-D image.
Method:
Parameters:
fimageInput image object to be processed, either a real-space image or a Fourier-space image. Image may be 1-, 2-, or 3-dimensional. Image fimage will not be changed unless inplace == true.
[in]paramsProcessor parameters. Different processor processors require different parameters, so we this routine accepts a dictionary of parameters and looks up the appropriate params for the chosen processor processor at run time. All processors use the "dopad" parameter to determine whether the Fourier workspace array should be zero- padded to twice the original length (dopad == 1) or not zero-padded at all (dopad == 0).
[in]doInPlaceInplace flag. If this flag is true then fimage will contain the processeded image when this function returns.
Returns:
1-, 2-, or 3-dimensional filter processed image. If the input image is a real-space image, then the returned output image will also be a real-space image. Similarly, if the input image is already a Fourier image, then the output image will be a Fourier image. In either case, if inplace == true then the output image (pointer) will be the same as the input image (pointer).

Definition at line 58 of file fourierfilter.cpp.

References EMAN::EMData::cmplx(), EMAN::EMData::copy(), EMAN::EMData::depad(), EMAN::EMData::do_fft_inplace(), EMAN::EMData::do_ift_inplace(), EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::Util::KaiserBessel::i0win(), iimag(), EMAN::EMData::is_complex(), EMAN::EMData::is_fftodd(), log10(), LOGERR, max, EMAN::EMData::norm_pad(), nx, ny, pihalf, EMAN::EMData::set_array_offsets(), sign, EMAN::Util::KaiserBessel::sinhwin(), EMAN::Dict::size(), sqrt(), tf(), twopi, EMAN::EMData::update(), and v.

Referenced by EMFourierFilter(), and EMFourierFilterInPlace().

{
        int    nx, ny, nz, nyp2, nzp2, ix, iy, iz, jx, jy, jz;
        float  dx, dy, dz, omega=0, omegaL=0, omegaH=0;
        float  center=0, gamma=0, argx, argy, argz;
        float  aa, eps, ord=0, cnst=0, aL, aH, cnstL=0, cnstH=0;
        bool   complex_input;
        vector<float> table;
        int undoctf=0;
        float voltage=100.0f, ak=0.0f, cs=2.0f, ps=1.0f, b_factor=0.0f, wgh=0.1f, sign=-1.0f, dza = 0.0f, azz = 0.0f;
        float  tf=0.0f;
        if (!fimage)  return NULL;
        const int ndim = fimage->get_ndim();
        // Set amount of Fourier padding
        // dopad should be a bool, but EMObject Dict's can't store bools.
        int dopad = params["dopad"];
        int npad;
        if (0 == dopad) {
                // no padding
                npad = 1;
        } else if (1 == dopad) {
                // 2x padding (hard-wired)
                npad = 2;
        } else if (2 == dopad) {
        npad = 4;
        } else {
                // invalid entry
                LOGERR("The dopad parameter must be 0 (false) or 1 (true)");
                return NULL; // FIXME: replace w/ exception throw
        }

        // If the input image is already a Fourier image, then we want to
        // have this routine return a Fourier image
        complex_input = fimage->is_complex();
        if ( complex_input && 1 == dopad ) {
                // Cannot pad Fourier input image
                LOGERR("Cannot pad Fourier input image");
                return NULL; // FIXME: replace w/ exception throw
        }

        Util::KaiserBessel* kbptr = 0;


        nx  = fimage->get_xsize();
        ny  = fimage->get_ysize();
        nz  = fimage->get_zsize();
                // We manifestly assume no zero-padding here, just the
                // necessary extension along x for the fft
        if (complex_input) nx = (nx - 2 + fimage->is_fftodd());

        const int nxp = npad*nx;
        const int nyp = (ny > 1) ? npad*ny : 1;
        const int nzp = (nz > 1) ? npad*nz : 1;

        int lsd2 = (nxp + 2 - nxp%2) / 2; // Extended x-dimension of the complex image
        int lsd3 = lsd2 - 1;

        //  Perform padding (if necessary) and fft, if the image is not already an fft image
        EMData* fp = NULL; // workspace image
        if (complex_input) {
                if (doInPlace) {
                        // it's okay to change the original image
                        fp = fimage;
                } else {
                        // fimage must remain pristine
                        fp = fimage->copy();
                }
        } else {
                if (doInPlace) {
                        if (npad>1) {
                                LOGERR("Cannot pad with inplace filter");
                                return NULL;    // FIXME, exception
                        }
                        fp=fimage;
                        fp->do_fft_inplace();
                } else {
                        fp = fimage->norm_pad( false, npad, 1);
                        fp->do_fft_inplace();
                }
        }
        fp->set_array_offsets(1,1,1);

        //  And the filter type is:
        int filter_type = params["filter_type"];

        nyp2 = nyp/2; nzp2 = nzp/2;
        dx = 1.0f/float(nxp);
#ifdef _WIN32
        dy = 1.0f/_cpp_max(float(nyp),1.0f);
        dz = 1.0f/_cpp_max(float(nzp),1.0f);
#else
        dy = 1.0f/std::max(float(nyp),1.0f);
        dz = 1.0f/std::max(float(nzp),1.0f);
#endif  //_WIN32
        float dx2 = dx*dx, dy2 = dy*dy, dz2 = dz*dz;

        vector<float>::size_type tsize;
        float sz[3];
        float szmax;
        vector<float>::size_type maxsize;
        float xshift=0.0, yshift=0.0, zshift=0.0;

        // For the given type of filter set up any necessary parameters for the
        // filter calculation.  FIXME: Need parameter bounds checking!
        switch (filter_type) {
                case TOP_HAT_LOW_PASS:
                case TOP_HAT_HIGH_PASS:
                        omega = params["cutoff_abs"];
                        omega = 1.0f/omega/omega;
                        break;
                case TOP_HAT_BAND_PASS:
                        omegaL = params["low_cutoff_frequency"];
                        omegaH = params["high_cutoff_frequency"];
                        omegaL = 1.0f/omegaL/omegaL;
                        omegaH = 1.0f/omegaH/omegaH;
                        break;
                case TOP_HOMOMORPHIC:
                        omegaL = params["low_cutoff_frequency"];
                        omegaH = params["high_cutoff_frequency"];
                        gamma  = params["value_at_zero_frequency"];
                        omegaL = 1.0f/omegaL/omegaL;
                        omegaH = 1.0f/omegaH/omegaH;
                        break;
                case GAUSS_LOW_PASS:
                case GAUSS_HIGH_PASS:
                case GAUSS_INVERSE:
                        omega = params["cutoff_abs"];
                        omega = 0.5f/omega/omega;
                        break;
                case GAUSS_BAND_PASS:
                        omega = params["cutoff_abs"];
                        center = params["center"];
                        omega = 0.5f/omega/omega;
                        break;
                case GAUSS_HOMOMORPHIC:
                        omega = params["cutoff_abs"];
                        gamma = params["value_at_zero_frequency"];
                        omega = 0.5f/omega/omega;
                        gamma = 1.0f-gamma;
                        break;
                case BUTTERWORTH_LOW_PASS:
                case BUTTERWORTH_HIGH_PASS:
                        omegaL = params["low_cutoff_frequency"];
                        omegaH = params["high_cutoff_frequency"];
                        eps = 0.882f;
                        aa = 10.624f;
                        ord = 2.0f*log10(eps/sqrt(aa*aa-1.0f))/log10(omegaL/omegaH);
                        omegaL = omegaL/pow(eps,2.0f/ord);
                        break;
                case BUTTERWORTH_HOMOMORPHIC:
                        omegaL = params["low_cutoff_frequency"];
                        omegaH = params["high_cutoff_frequency"];
                        gamma  = params["value_at_zero_frequency"];
                        eps = 0.882f;
                        aa  = 10.624f;
                        ord = 2.0f*log10(eps/sqrt(pow(aa,2)-1.0f))/log10(omegaL/omegaH);
                        omegaL = omegaL/pow(eps,2.0f/ord);
                        gamma = 1.0f-gamma;
                        break;
                case SHIFT:
                        xshift = params["x_shift"];
                        yshift = params["y_shift"];
                        zshift = params["z_shift"];
                        //origin_type = params["origin_type"];
                        break;
                case TANH_LOW_PASS:
                case TANH_HIGH_PASS:
                        omega = params["cutoff_abs"];
                        aa = params["fall_off"];
                        cnst = float(pihalf/aa/omega);
                        break;
                case TANH_HOMOMORPHIC:
                        omega = params["cutoff_abs"];
                        aa = params["fall_off"];
                        gamma = params["value_at_zero_frequency"];
                        cnst = float(pihalf/aa/omega);
                        gamma=1.0f-gamma;
                        break;
                case TANH_BAND_PASS:
                        omegaL = params["low_cutoff_frequency"];
                        aL = params["Low_fall_off"];
                        omegaH = params["high_cutoff_frequency"];
                        aH = params["high_fall_off"];
                        cnstL = float(pihalf/aL/(omegaH-omegaL));
                        cnstH = float(pihalf/aH/(omegaH-omegaL));
                        break;
                case CTF_:
                        dz       = params["defocus"];
                        cs       = params["Cs"];
                        voltage  = params["voltage"];
                        ps       = params["Pixel_size"];
                        b_factor = params["B_factor"];
                        wgh      = params["amp_contrast"];
                        sign     = params["sign"];
                        undoctf  = params["undo"];
                        ix       = params["binary"];
                        if(ix == 1) {undoctf = 2;  b_factor=0.0;} //ignore B-factor for the binary CTF
                        dza = params["dza"];
                        azz = params["azz"];
                        break;
                case KAISER_I0:
                case KAISER_SINH:
                case KAISER_I0_INVERSE:
                case KAISER_SINH_INVERSE:
                        {
                                float alpha = params["alpha"];
                                int       K = params["K"];
                                float     r = params["r"];
                                float     v = params["v"];
                                int       N = params["N"];
                                kbptr = new Util::KaiserBessel(alpha, K, r, v, N);
                                break;
                        }//without this bracket, compiler on water will complain about crosses initialization
                case RADIAL_TABLE:
                        table = params["table"];
                        tsize = table.size();
                        sz[0] = static_cast<float>(lsd2);
                        sz[1] = static_cast<float>(nyp2);
                        sz[2] = static_cast<float>(nzp2);
                        szmax = *max_element(&sz[0],&sz[3]);
                        // for 2d, sqrt(2) = 1.414, relax a little bit to 1.6
                        // for 3d, sqrt(3) = 1.732, relax a little bit to 1.9
                        if (nzp > 1) {maxsize = vector<float>::size_type(1.9*szmax);} else {maxsize = vector<float>::size_type(1.6*szmax);}
                        for (vector<float>::size_type i = tsize+1; i < maxsize; i++) table.push_back(0.f);
                        break;
                default:
                        LOGERR("Unknown Fourier Filter type");
                        return NULL; // FIXME: replace w/ exception throw
        }
        // Perform actual calculation
        //  Gaussian bandpass is the only one with center for frequencies
        switch (filter_type) {
                case GAUSS_BAND_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *= exp(-pow(sqrt(argx)-center,2)*omega);
                                        }
                                }
                        }
                        break;
                case TOP_HAT_LOW_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                if (argx*omega>1.0f) fp->cmplx(ix,iy,iz) = 0.0f;
                                        }
                                }
                        }
                        break;
                case TOP_HAT_HIGH_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                if (argx*omega<=1.0f) fp->cmplx(ix,iy,iz) = 0.0f;
                                        }
                                }
                        }                               break;
                case TOP_HAT_BAND_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                if (argx*omegaL<1.0f || argx*omegaH>=1.0f) fp->cmplx(ix,iy,iz) = 0.0f;
                                        }
                                }
                        }
                        break;
                case TOP_HOMOMORPHIC:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                if (argx*omegaH>1.0f)      fp->cmplx(ix,iy,iz)  = 0.0f;
                                                else if (argx*omegaL<=1.0f) fp->cmplx(ix,iy,iz) *= gamma;
                                        }
                                }
                        }
                        break;
                case GAUSS_LOW_PASS :
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *= exp(-argx*omega);
                                        }
                                }
                        }
                        break;
                case GAUSS_HIGH_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *= 1.0f-exp(-argx*omega);
                                        }
                                }
                        }
                        break;
                case GAUSS_HOMOMORPHIC:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *= 1.0f-gamma*exp(-argx*omega);
                                        }
                                }
                        }
                        break;
                case GAUSS_INVERSE :
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *= exp(argx*omega);
                                        }
                                }
                        }
                        break;
                case KAISER_I0:   // K-B filter
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                float nuz = jz*dz;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp;
                                        float nuy = jy*dy;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1;
                                                float nux = jx*dx;
                                                //if (!kbptr)
                                                //      throw
                                                //              NullPointerException("kbptr null!");
                                                switch (ndim) {
                                                        case 3:
                                                                fp->cmplx(ix,iy,iz) *= kbptr->i0win(nux)*kbptr->i0win(nuy)*kbptr->i0win(nuz);
                                                                break;
                                                        case 2:
                                                                fp->cmplx(ix,iy,iz) *= kbptr->i0win(nux)*kbptr->i0win(nuy);
                                                                break;
                                                        case 1:
                                                                fp->cmplx(ix,iy,iz)*= kbptr->i0win(nux);
                                                                break;
                                                }
                                        }
                                }
                        }
                        break;
                case KAISER_SINH:   //  Sinh filter
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if(jy>nyp2) jy=jy-nyp;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1;
                                                //if (!kbptr)
                                                //      throw
                                                //              NullPointerException("kbptr null!");
                                                switch (ndim) {
                                                        case 3:
                                                                fp->cmplx(ix,iy,iz)*= kbptr->sinhwin((float)jx)*kbptr->sinhwin((float)jy)*kbptr->sinhwin((float)jz);
                                                                break;
                                                        case 2:
                                                                fp->cmplx(ix,iy,iz)*= kbptr->sinhwin((float)jx)*kbptr->sinhwin((float)jy);
                                                                break;
                                                        case 1:
                                                                fp->cmplx(ix,iy,iz)*= kbptr->sinhwin((float)jx);
                                                                //float argu = kbptr->sinhwin((float) jx);
                                                                //cout << jx<<"  "<< nux<<"  "<<argu<<endl;
                                                                break;
                                                }
                                        }
                                }
                        }
                        break;
                case KAISER_I0_INVERSE:   // 1./(K-B filter)
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                float nuz = jz*dz;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if(jy>nyp2) jy=jy-nyp;
                                        float nuy = jy*dy;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1;
                                                float nux = jx*dx;
                                        //if (!kbptr)
                                        //      throw
                                        //              NullPointerException("kbptr null!");
                                                switch (ndim) {
                                                        case 3:
                                                                fp->cmplx(ix,iy,iz) /= (kbptr->i0win(nux)*kbptr->i0win(nuy)*kbptr->i0win(nuz));
                                                                break;
                                                        case 2:
                                                                fp->cmplx(ix,iy,iz) /= (kbptr->i0win(nux)*kbptr->i0win(nuy));
                                                                break;
                                                        case 1:
                                                                fp->cmplx(ix,iy,iz) /= kbptr->i0win(nux);
                                                                break;
                                                }
                                        }
                                }
                        }
                        break;
                case KAISER_SINH_INVERSE:  // 1./sinh
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1;
                                                //if (!kbptr)
                                                //      throw
                                                //              NullPointerException("kbptr null!");
                                                switch (ndim) {
                                                        case 3:
                                                                fp->cmplx(ix,iy,iz) /= (kbptr->sinhwin((float)jx)*kbptr->sinhwin((float)jy)*kbptr->sinhwin((float)jz));
                                                                break;
                                                        case 2:
                                                                fp->cmplx(ix,iy,iz) /= (kbptr->sinhwin((float)jx)*kbptr->sinhwin((float)jy));
                                                                break;
                                                        case 1:
                                                                fp->cmplx(ix,iy,iz) /= kbptr->sinhwin((float)jx);
                                                                //float argu = kbptr->sinhwin((float) jx);
                                                                //cout << jx<<"  "<< nux<<"  "<<argu<<endl;
                                                                break;
                                                }
                                        }
                                }
                        }
                        break;
                case BUTTERWORTH_LOW_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *= sqrt(1.0f/(1.0f+pow(sqrt(argx)/omegaL,ord)));
                                        }
                                }
                        }
                        break;
                case BUTTERWORTH_HIGH_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *=  1.0f-sqrt(1.0f/(1.0f+pow(sqrt(argx)/omegaL,ord)));
                                        }
                                }
                        }
                        break;
                case BUTTERWORTH_HOMOMORPHIC:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                fp->cmplx(ix,iy,iz) *=  1.0f-gamma*sqrt(1.0f/(1.0f+pow(sqrt(argx)/omegaL,ord)));
                                        }
                                }
                        }
                        break;
                case SHIFT:
                        //if (origin_type) {
                                for ( iz = 1; iz <= nzp; iz++) {
                                        jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                        for ( iy = 1; iy <= nyp; iy++) {
                                                jy=iy-1; if (jy>nyp2) jy=jy-nyp;
                                                for ( ix = 1; ix <= lsd2; ix++) {
                                                        jx=ix-1;
                                                        fp->cmplx(ix,iy,iz) *=  exp(-float(twopi)*iimag*(xshift*jx/nx + yshift*jy/ny+ zshift*jz/nz));
                                                }
                                        }
                                }
                        /*} else {
                                for ( iz = 1; iz <= nzp; iz++) {
                                        jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                        if  (iz>nzp2) { kz=iz-nzp2; } else { kz=iz+nzp2; }
                                        for ( iy = 1; iy <= nyp; iy++) {
                                                jy=iy-1; if (jy>nyp2) jy=jy-nyp;
                                                if  (iy>nyp2) { ky=iy-nyp2; } else { ky=iy+nyp2; }
                                                for ( ix = 1; ix <= lsd2; ix++) {
                                                        jx=ix-1;
                                                        fp->cmplx(ix,ky,kz) *=  exp(-float(twopi)*iimag*(xshift*jx/nx + yshift*jy/ny+ zshift*jz/nz));
                                                }
                                        }
                                }
                        }*/
                        break;
                case TANH_LOW_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = sqrt(argy + float(jx*jx)*dx2);
                                                fp->cmplx(ix,iy,iz) *=  0.5f*(tanh(cnst*(argx+omega))-tanh(cnst*(argx-omega)));
                                        }
                                }
                        }
                        break;
                case TANH_HIGH_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; sqrt(argx = argy + float(jx*jx)*dx2);
                                                fp->cmplx(ix,iy,iz) *=  1.0f-0.5f*(tanh(cnst*(argx+omega))-tanh(cnst*(argx-omega)));
                                        }
                                }
                        }
                        break;
                case TANH_HOMOMORPHIC:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = sqrt(argy + float(jx*jx)*dx2);
                                                fp->cmplx(ix,iy,iz) *= 1.0f-gamma*0.5f*(tanh(cnst*(argx+omega))-tanh(cnst*(argx-omega)));
                                        }
                                }
                        }
                        break;
                case TANH_BAND_PASS:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = sqrt(argy + float(jx*jx)*dx2);
                                                fp->cmplx(ix,iy,iz) *= 0.5f*(tanh(cnstH*(argx+omegaH))-tanh(cnstH*(argx-omegaH))-tanh(cnstL*(argx+omegaL))+tanh(cnstL*(argx-omegaL)));
                                        }
                                }
                        }
                        break;
                case RADIAL_TABLE:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp; argz = float(jz*jz)*dz2;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp; argy = argz + float(jy*jy)*dy2;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1; argx = argy + float(jx*jx)*dx2;
                                                float rf = sqrt( argx )*nxp;
                                                int  ir = int(rf);
                                                float df = rf - float(ir);
                                                float f = table[ir] + df * (table[ir+1] - table[ir]); // (1-df)*table[ir]+df*table[ir+1];
                                                fp->cmplx(ix,iy,iz) *= f;
                                        }
                                }
                        }
                        break;
                case CTF_:
                        for ( iz = 1; iz <= nzp; iz++) {
                                jz=iz-1; if (jz>nzp2) jz=jz-nzp;
                                for ( iy = 1; iy <= nyp; iy++) {
                                        jy=iy-1; if (jy>nyp2) jy=jy-nyp;
                                        for ( ix = 1; ix <= lsd2; ix++) {
                                                jx=ix-1;
                                                if(ny>1 && nz<=1 ) {
                                                        //  astigmatism makes sense only on 2D
                                                        ak = sqrt(static_cast<float>(jx)/lsd3*static_cast<float>(jx)/lsd3 +
                                                                static_cast<float>(jy)/nyp2*static_cast<float>(jy)/nyp2)/ps/2.0f;
                                                        if(dza == 0.0f)  tf = Util::tf(dz, ak, voltage, cs, wgh, b_factor, sign);
                                                        else {
                                                                float az = atan2(static_cast<float>(jy)/nyp2, static_cast<float>(jx)/lsd3);
                                                                float dzz = dz - dza/2.0f*sin(2*(az+azz*M_PI/180.0f));
                                                                tf = Util::tf(dzz, ak, voltage, cs, wgh, b_factor, sign);
                                                        }
                                                }  else if(ny<=1) {
                                                        ak=sqrt(static_cast<float>(jx)/lsd3*static_cast<float>(jx)/lsd3)/ps/2.0f;
                                                        tf = Util::tf(dz, ak, voltage, cs, wgh, b_factor, sign);
                                                }  else if(nz>1)  {
                                                        ak=sqrt(static_cast<float>(jx)/lsd3*static_cast<float>(jx)/lsd3 +
                                                                static_cast<float>(jy)/nyp2*static_cast<float>(jy)/nyp2 +
                                                                static_cast<float>(jz)/nzp2*static_cast<float>(jz)/nzp2)/ps/2.0f;
                                                        tf  =Util::tf(dz, ak, voltage, cs, wgh, b_factor, sign);
                                                }
                                                switch (undoctf) {
                                                case 0:
                                                    fp->cmplx(ix,iy,iz) *= tf;
                                                    break;
                                                case 1:
                                                    if( tf>0 && tf <  1e-5 ) tf =  1e-5f;
                                                    if( tf<0 && tf > -1e-5 ) tf = -1e-5f;
                                                    fp->cmplx(ix,iy,iz) /= tf;
                                                    break;
                                                case 2:
                                                    if(tf < 0.0f) fp->cmplx(ix,iy,iz) *= -1.0f;
                                                    break;
                                                }
                                        }
                                }
                        }
                        break;
        }
        delete kbptr; kbptr = 0;
        if (!complex_input) {
                fp->do_ift_inplace();
                fp->depad();
        }

                // Return a complex (Fourier) filtered image
                // Note: fp and fimage are the _same_ object if doInPlace
                // is true, so in that case fimage has been filtered.
                // We always return an image (pointer), but if the function
                // was called with doInPlace == true then the calling function
                // will probably ignore the return value.

                // ELSE Return a real-space filtered image
                //
                // On 12/15/2006 Wei Zhang comment:
                // If input is reald and doInPlace == true, we might need delete fp after copy its
                // data back to fimage, since fp is allocated inside this function and is ignored
                // by caller if doInPlace == true. As a reminder, the caller is EMFourierFuncInPlace
                //
        fp->set_array_offsets(0,0,0);
        fp->update();
        if (doInPlace && !complex_input) {
                // copy workspace data into the original image
                float* orig = fimage->get_data();
                float* work = fp->get_data();
                for (size_t i = 0; i < (size_t)nx*ny*nz; i++) orig[i] = work[i];
                fimage->update();
        }
        EXITFUNC;
        return fp;
}
static void EMAN::Processor::EMFourierFilterInPlace ( EMData fimage,
Dict  params 
) [inline, static]

Compute a Fourier-filter processed image in place.

Purpose: Apply selected Fourier space processor to 1-,2-, or 3-D image.
Method:
Parameters:
fimageInput image object to be processed, either a real-space image or a Fourier-space image. Image may be 1-, 2-, or 3-dimensional. The original input image is not touched by this routine.
[in]paramsProcessor parameters. Different processors require different parameters, so we this routine accepts a dictionary of parameters and looks up the appropriate params for the chosen processor at run time. All processors use the "dopad" parameter to determine whether the Fourier workspace array should be zero- padded to twice the original length (dopad == 1) or not zero-padded at all (dopad == 0).
Returns:
No explicit return. The image fimage is modified in place.

Definition at line 237 of file processor.h.

References EMFourierFilterFunc().

Referenced by EMAN::CTF_Processor::process_inplace(), EMAN::NewBandpassTanhProcessor::process_inplace(), EMAN::NewHomomorphicTanhProcessor::process_inplace(), EMAN::NewHighpassTanhProcessor::process_inplace(), EMAN::NewLowpassTanhProcessor::process_inplace(), EMAN::NewHomomorphicButterworthProcessor::process_inplace(), EMAN::NewHighpassButterworthProcessor::process_inplace(), EMAN::NewLowpassButterworthProcessor::process_inplace(), EMAN::NewRadialTableProcessor::process_inplace(), EMAN::InverseKaiserSinhProcessor::process_inplace(), EMAN::InverseKaiserI0Processor::process_inplace(), EMAN::SHIFTProcessor::process_inplace(), EMAN::NewInverseGaussProcessor::process_inplace(), EMAN::NewHomomorphicGaussProcessor::process_inplace(), EMAN::NewBandpassGaussProcessor::process_inplace(), EMAN::NewHighpassGaussProcessor::process_inplace(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::NewHomomorphicTopHatProcessor::process_inplace(), EMAN::NewBandpassTopHatProcessor::process_inplace(), EMAN::NewHighpassTopHatProcessor::process_inplace(), and EMAN::NewLowpassTopHatProcessor::process_inplace().

                                                                    {
                        bool doInPlace = true;
                        EMFourierFilterFunc(fimage, params, doInPlace);
                }
virtual string EMAN::Processor::get_desc ( ) const [pure virtual]

Get the descrition of this specific processor.

This function must be overwritten by a subclass.

Returns:
The description of this processor.

Implemented in EMAN::XYZProcessor, EMAN::SNREvalProcessor, EMAN::Axis0FourierProcessor, EMAN::AmpweightFourierProcessor, EMAN::ConvolutionProcessor, EMAN::XGradientProcessor, EMAN::YGradientProcessor, EMAN::ZGradientProcessor, EMAN::Wiener2DAutoAreaProcessor, EMAN::DistanceSegmentProcessor, EMAN::KmeansSegmentProcessor, EMAN::CtfSimProcessor, EMAN::Wiener2DFourierProcessor, EMAN::LinearRampFourierProcessor, EMAN::LowpassRandomPhaseProcessor, EMAN::LowpassAutoBProcessor, EMAN::HighpassAutoPeakProcessor, EMAN::LinearRampProcessor, EMAN::LoGFourierProcessor, EMAN::DoGFourierProcessor, EMAN::AbsoluateValueProcessor, EMAN::FloorValueProcessor, EMAN::BooleanProcessor, EMAN::RecipCarefullyProcessor, EMAN::ValuePowProcessor, EMAN::ValueSquaredProcessor, EMAN::ValueSqrtProcessor, EMAN::ToZeroProcessor, EMAN::AboveToZeroProcessor, EMAN::AddShapeProcessor, EMAN::Rotate180Processor, EMAN::TransformProcessor, EMAN::IntTranslateProcessor, EMAN::ApplySymProcessor, EMAN::ScaleTransformProcessor, EMAN::ClampingProcessor, EMAN::NSigmaClampingProcessor, EMAN::ToMinvalProcessor, EMAN::CutToZeroProcessor, EMAN::BinarizeProcessor, EMAN::BinarizeFourierProcessor, EMAN::CollapseProcessor, EMAN::LinearXformProcessor, EMAN::ExpProcessor, EMAN::FiniteProcessor, EMAN::RangeThresholdProcessor, EMAN::SigmaProcessor, EMAN::LogProcessor, EMAN::CircularMaskProcessor, EMAN::MaskSharpProcessor, EMAN::MaskSoftProcessor, EMAN::MaskEdgeMeanProcessor, EMAN::MaskNoiseProcessor, EMAN::MaskGaussProcessor, EMAN::MaskGaussNonuniformProcessor, EMAN::MaskGaussInvProcessor, EMAN::LinearPyramidProcessor, EMAN::MakeRadiusSquaredProcessor, EMAN::MakeRadiusProcessor, EMAN::ComplexNormPixel, EMAN::AreaProcessor, EMAN::LaplacianProcessor, EMAN::ZeroConstantProcessor, EMAN::BoxMedianProcessor, EMAN::BoxSigmaProcessor, EMAN::BoxMaxProcessor, EMAN::MinusPeakProcessor, EMAN::PeakOnlyProcessor, EMAN::DiffBlockProcessor, EMAN::CutoffBlockProcessor, EMAN::MaxShrinkProcessor, EMAN::MinShrinkProcessor, EMAN::MeanShrinkProcessor, EMAN::MedianShrinkProcessor, EMAN::FFTResampleProcessor, EMAN::GradientRemoverProcessor, EMAN::GradientPlaneRemoverProcessor, EMAN::NonConvexProcessor, EMAN::FlattenBackgroundProcessor, EMAN::RampProcessor, EMAN::VerticalStripeProcessor, EMAN::RealToFFTProcessor, EMAN::SigmaZeroEdgeProcessor, EMAN::BeamstopProcessor, EMAN::MeanZeroEdgeProcessor, EMAN::AverageXProcessor, EMAN::DecayEdgeProcessor, EMAN::ZeroEdgeRowProcessor, EMAN::ZeroEdgePlaneProcessor, EMAN::BilateralProcessor, EMAN::NormalizeUnitProcessor, EMAN::NormalizeUnitSumProcessor, EMAN::NormalizeStdProcessor, EMAN::NormalizeMaskProcessor, EMAN::NormalizeRampNormVar, EMAN::NormalizeByMassProcessor, EMAN::NormalizeEdgeMeanProcessor, EMAN::NormalizeCircleMeanProcessor, EMAN::NormalizeLREdgeMeanProcessor, EMAN::NormalizeMaxMinProcessor, EMAN::NormalizeRowProcessor, EMAN::SubtractOptProcessor, EMAN::NormalizeToLeastSquareProcessor, EMAN::RotationalAverageProcessor, EMAN::RotationalSubstractProcessor, EMAN::TransposeProcessor, EMAN::FlipProcessor, EMAN::AddNoiseProcessor, EMAN::AddSigmaNoiseProcessor, EMAN::AddRandomNoiseProcessor, EMAN::FourierToCornerProcessor, EMAN::FourierToCenterProcessor, EMAN::PhaseToCenterProcessor, EMAN::PhaseToCornerProcessor, EMAN::AutoMask2DProcessor, EMAN::AutoMaskAsymUnit, EMAN::AutoMaskDustProcessor, EMAN::AutoMask3DProcessor, EMAN::AutoMask3D2Processor, EMAN::IterMultiMaskProcessor, EMAN::AddMaskShellProcessor, EMAN::PhaseToMassCenterProcessor, EMAN::ToMassCenterProcessor, EMAN::ACFCenterProcessor, EMAN::FSCFourierProcessor, EMAN::SNRProcessor, EMAN::FileFourierProcessor, EMAN::SymSearchProcessor, EMAN::StripeXYProcessor, EMAN::LocalNormProcessor, EMAN::IndexMaskFileProcessor, EMAN::CoordinateMaskFileProcessor, EMAN::PaintProcessor, EMAN::DirectionalSumProcessor, EMAN::WatershedProcessor, EMAN::BinaryOperateProcessor< Type >, EMAN::MatchSFProcessor, EMAN::SetSFProcessor, EMAN::SmartMaskProcessor, EMAN::IterBinMaskProcessor, EMAN::TestImagePureGaussian, EMAN::TestImageFourierNoiseGaussian, EMAN::TestImageFourierNoiseProfile, EMAN::CTFSNRWeightProcessor, EMAN::TestImageLineWave, EMAN::TestTomoImage, EMAN::TestImageGradient, EMAN::TestImageAxes, EMAN::TestImageGaussian, EMAN::TestImageScurve, EMAN::TestImageSphericalWave, EMAN::TestImageSinewave, EMAN::TestImageSinewaveCircular, EMAN::TestImageSquarecube, EMAN::TestImageEllipse, EMAN::TestImageHollowEllipse, EMAN::TestImageCirclesphere, EMAN::TestImageNoiseUniformRand, EMAN::TestImageNoiseGauss, EMAN::TestImageCylinder, EMAN::CCDNormProcessor, EMAN::WaveletProcessor, EMAN::TomoTiltEdgeMaskProcessor, EMAN::TomoTiltAngleWeightProcessor, EMAN::FFTProcessor, EMAN::RadialProcessor, EMAN::HistogramBin, EMAN::ModelEMCylinderProcessor, EMAN::ApplyPolynomialProfileToHelix, EMAN::BinarySkeletonizerProcessor, EMAN::ConvolutionKernelProcessor, EMAN::RotateInFSProcessor, EMAN::MirrorProcessor, EMAN::NewLowpassTopHatProcessor, EMAN::NewHighpassTopHatProcessor, EMAN::NewBandpassTopHatProcessor, EMAN::NewHomomorphicTopHatProcessor, EMAN::NewLowpassGaussProcessor, EMAN::NewHighpassGaussProcessor, EMAN::NewBandpassGaussProcessor, EMAN::NewHomomorphicGaussProcessor, EMAN::NewInverseGaussProcessor, EMAN::SHIFTProcessor, EMAN::InverseKaiserI0Processor, EMAN::InverseKaiserSinhProcessor, EMAN::NewRadialTableProcessor, EMAN::NewLowpassButterworthProcessor, EMAN::NewHighpassButterworthProcessor, EMAN::NewHomomorphicButterworthProcessor, EMAN::NewLowpassTanhProcessor, EMAN::NewHighpassTanhProcessor, EMAN::NewHomomorphicTanhProcessor, EMAN::NewBandpassTanhProcessor, and EMAN::CTF_Processor.

static string EMAN::Processor::get_group_desc ( ) [inline, static]

Get the description of this group of processors.

This function is defined in a parent class. It gives a introduction to a group of processors.

Returns:
The description of this group of processors.

Reimplemented in EMAN::ImageProcessor, EMAN::FourierProcessor, EMAN::FourierAnlProcessor, EMAN::RealPixelProcessor, EMAN::CoordinateProcessor, EMAN::ComplexPixelProcessor, EMAN::BoxStatProcessor, EMAN::NormalizeProcessor, EMAN::TestImageProcessor, and EMAN::NewFourierProcessor.

Definition at line 163 of file processor.h.

                {
                        return "EMAN processors are in-place image processors. You may apply a processor to process a single image or process multiple images. Processor class is the base class for all processor. <br> \
The basic design of EMAN Processors: <br>\
    1) Each Processor class defines an image-processinging algorithm. <br>\
    2) All the Processor classes in EMAN are managed by a Factory pattern. So each Processor class must define: <br> a) a unique name to idenfity itself in the factory. <br>b) a static method to register itself in the factory.<br>\
    3) Each Processor class defines its own parameter set.<br>\
    4) Each Processor class defines functions to return its documentation including parameter information, and processor description. These functions enable EMAN to generate processor manuals dynamically.";
                }
virtual string EMAN::Processor::get_name ( ) const [pure virtual]

Get the processor's name.

Each processor is identified by a unique name.

Returns:
The processor's name.

Implemented in EMAN::XYZProcessor, EMAN::SNREvalProcessor, EMAN::Axis0FourierProcessor, EMAN::AmpweightFourierProcessor, EMAN::ConvolutionProcessor, EMAN::XGradientProcessor, EMAN::YGradientProcessor, EMAN::ZGradientProcessor, EMAN::Wiener2DAutoAreaProcessor, EMAN::DistanceSegmentProcessor, EMAN::KmeansSegmentProcessor, EMAN::CtfSimProcessor, EMAN::Wiener2DFourierProcessor, EMAN::LinearRampFourierProcessor, EMAN::LowpassRandomPhaseProcessor, EMAN::LowpassAutoBProcessor, EMAN::HighpassAutoPeakProcessor, EMAN::LinearRampProcessor, EMAN::LoGFourierProcessor, EMAN::DoGFourierProcessor, EMAN::AbsoluateValueProcessor, EMAN::FloorValueProcessor, EMAN::BooleanProcessor, EMAN::RecipCarefullyProcessor, EMAN::ValuePowProcessor, EMAN::ValueSquaredProcessor, EMAN::ValueSqrtProcessor, EMAN::ToZeroProcessor, EMAN::AboveToZeroProcessor, EMAN::AddShapeProcessor, EMAN::Rotate180Processor, EMAN::TransformProcessor, EMAN::IntTranslateProcessor, EMAN::ApplySymProcessor, EMAN::ScaleTransformProcessor, EMAN::ClampingProcessor, EMAN::NSigmaClampingProcessor, EMAN::ToMinvalProcessor, EMAN::CutToZeroProcessor, EMAN::BinarizeProcessor, EMAN::BinarizeFourierProcessor, EMAN::CollapseProcessor, EMAN::LinearXformProcessor, EMAN::ExpProcessor, EMAN::FiniteProcessor, EMAN::RangeThresholdProcessor, EMAN::SigmaProcessor, EMAN::LogProcessor, EMAN::MaskSharpProcessor, EMAN::MaskSoftProcessor, EMAN::MaskEdgeMeanProcessor, EMAN::MaskNoiseProcessor, EMAN::MaskGaussProcessor, EMAN::MaskGaussNonuniformProcessor, EMAN::MaskGaussInvProcessor, EMAN::LinearPyramidProcessor, EMAN::MakeRadiusSquaredProcessor, EMAN::MakeRadiusProcessor, EMAN::ComplexNormPixel, EMAN::LaplacianProcessor, EMAN::ZeroConstantProcessor, EMAN::BoxMedianProcessor, EMAN::BoxSigmaProcessor, EMAN::BoxMaxProcessor, EMAN::MinusPeakProcessor, EMAN::PeakOnlyProcessor, EMAN::DiffBlockProcessor, EMAN::CutoffBlockProcessor, EMAN::MaxShrinkProcessor, EMAN::MinShrinkProcessor, EMAN::MeanShrinkProcessor, EMAN::MedianShrinkProcessor, EMAN::FFTResampleProcessor, EMAN::GradientRemoverProcessor, EMAN::GradientPlaneRemoverProcessor, EMAN::NonConvexProcessor, EMAN::FlattenBackgroundProcessor, EMAN::RampProcessor, EMAN::VerticalStripeProcessor, EMAN::RealToFFTProcessor, EMAN::SigmaZeroEdgeProcessor, EMAN::BeamstopProcessor, EMAN::MeanZeroEdgeProcessor, EMAN::AverageXProcessor, EMAN::DecayEdgeProcessor, EMAN::ZeroEdgeRowProcessor, EMAN::ZeroEdgePlaneProcessor, EMAN::BilateralProcessor, EMAN::NormalizeUnitProcessor, EMAN::NormalizeUnitSumProcessor, EMAN::NormalizeStdProcessor, EMAN::NormalizeMaskProcessor, EMAN::NormalizeRampNormVar, EMAN::NormalizeByMassProcessor, EMAN::NormalizeEdgeMeanProcessor, EMAN::NormalizeCircleMeanProcessor, EMAN::NormalizeLREdgeMeanProcessor, EMAN::NormalizeMaxMinProcessor, EMAN::NormalizeRowProcessor, EMAN::SubtractOptProcessor, EMAN::NormalizeToLeastSquareProcessor, EMAN::RotationalAverageProcessor, EMAN::RotationalSubstractProcessor, EMAN::TransposeProcessor, EMAN::FlipProcessor, EMAN::AddNoiseProcessor, EMAN::AddSigmaNoiseProcessor, EMAN::AddRandomNoiseProcessor, EMAN::FourierToCornerProcessor, EMAN::FourierToCenterProcessor, EMAN::PhaseToCenterProcessor, EMAN::PhaseToCornerProcessor, EMAN::AutoMask2DProcessor, EMAN::AutoMaskAsymUnit, EMAN::AutoMaskDustProcessor, EMAN::AutoMask3DProcessor, EMAN::AutoMask3D2Processor, EMAN::IterMultiMaskProcessor, EMAN::AddMaskShellProcessor, EMAN::PhaseToMassCenterProcessor, EMAN::ToMassCenterProcessor, EMAN::ACFCenterProcessor, EMAN::FSCFourierProcessor, EMAN::SNRProcessor, EMAN::FileFourierProcessor, EMAN::SymSearchProcessor, EMAN::StripeXYProcessor, EMAN::LocalNormProcessor, EMAN::IndexMaskFileProcessor, EMAN::CoordinateMaskFileProcessor, EMAN::PaintProcessor, EMAN::DirectionalSumProcessor, EMAN::WatershedProcessor, EMAN::BinaryOperateProcessor< Type >, EMAN::MatchSFProcessor, EMAN::SetSFProcessor, EMAN::SmartMaskProcessor, EMAN::IterBinMaskProcessor, EMAN::TestImagePureGaussian, EMAN::TestImageFourierNoiseGaussian, EMAN::TestImageFourierNoiseProfile, EMAN::CTFSNRWeightProcessor, EMAN::TestImageLineWave, EMAN::TestTomoImage, EMAN::TestImageGradient, EMAN::TestImageAxes, EMAN::TestImageGaussian, EMAN::TestImageScurve, EMAN::TestImageSphericalWave, EMAN::TestImageSinewave, EMAN::TestImageSinewaveCircular, EMAN::TestImageSquarecube, EMAN::TestImageEllipse, EMAN::TestImageHollowEllipse, EMAN::TestImageCirclesphere, EMAN::TestImageNoiseUniformRand, EMAN::TestImageNoiseGauss, EMAN::TestImageCylinder, EMAN::CCDNormProcessor, EMAN::WaveletProcessor, EMAN::TomoTiltEdgeMaskProcessor, EMAN::TomoTiltAngleWeightProcessor, EMAN::FFTProcessor, EMAN::RadialProcessor, EMAN::HistogramBin, EMAN::ModelEMCylinderProcessor, EMAN::ApplyPolynomialProfileToHelix, EMAN::BinarySkeletonizerProcessor, EMAN::ConvolutionKernelProcessor, EMAN::RotateInFSProcessor, EMAN::MirrorProcessor, EMAN::NewLowpassTopHatProcessor, EMAN::NewHighpassTopHatProcessor, EMAN::NewBandpassTopHatProcessor, EMAN::NewHomomorphicTopHatProcessor, EMAN::NewLowpassGaussProcessor, EMAN::NewHighpassGaussProcessor, EMAN::NewBandpassGaussProcessor, EMAN::NewHomomorphicGaussProcessor, EMAN::NewInverseGaussProcessor, EMAN::SHIFTProcessor, EMAN::InverseKaiserI0Processor, EMAN::InverseKaiserSinhProcessor, EMAN::NewRadialTableProcessor, EMAN::NewLowpassButterworthProcessor, EMAN::NewHighpassButterworthProcessor, EMAN::NewHomomorphicButterworthProcessor, EMAN::NewLowpassTanhProcessor, EMAN::NewHighpassTanhProcessor, EMAN::NewHomomorphicTanhProcessor, EMAN::NewBandpassTanhProcessor, and EMAN::CTF_Processor.

Referenced by EMAN::group_processors().

virtual TypeDict EMAN::Processor::get_param_types ( ) const [inline, virtual]

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 in EMAN::XYZProcessor, EMAN::FourierProcessor, EMAN::FourierAnlProcessor, EMAN::SNREvalProcessor, EMAN::Axis0FourierProcessor, EMAN::AmpweightFourierProcessor, EMAN::ConvolutionProcessor, EMAN::XGradientProcessor, EMAN::YGradientProcessor, EMAN::ZGradientProcessor, EMAN::Wiener2DAutoAreaProcessor, EMAN::DistanceSegmentProcessor, EMAN::KmeansSegmentProcessor, EMAN::CtfSimProcessor, EMAN::Wiener2DFourierProcessor, EMAN::LowpassAutoBProcessor, EMAN::LinearRampProcessor, EMAN::LoGFourierProcessor, EMAN::DoGFourierProcessor, EMAN::RecipCarefullyProcessor, EMAN::ValuePowProcessor, EMAN::ToZeroProcessor, EMAN::AboveToZeroProcessor, EMAN::AddShapeProcessor, EMAN::TransformProcessor, EMAN::IntTranslateProcessor, EMAN::ApplySymProcessor, EMAN::ScaleTransformProcessor, EMAN::ClampingProcessor, EMAN::NSigmaClampingProcessor, EMAN::ToMinvalProcessor, EMAN::CutToZeroProcessor, EMAN::BinarizeProcessor, EMAN::BinarizeFourierProcessor, EMAN::CollapseProcessor, EMAN::LinearXformProcessor, EMAN::ExpProcessor, EMAN::FiniteProcessor, EMAN::RangeThresholdProcessor, EMAN::SigmaProcessor, EMAN::CircularMaskProcessor, EMAN::MaskSharpProcessor, EMAN::MaskSoftProcessor, EMAN::MaskEdgeMeanProcessor, EMAN::MaskGaussProcessor, EMAN::MaskGaussNonuniformProcessor, EMAN::MaskGaussInvProcessor, EMAN::AreaProcessor, EMAN::BoxStatProcessor, EMAN::PeakOnlyProcessor, EMAN::DiffBlockProcessor, EMAN::CutoffBlockProcessor, EMAN::MaxShrinkProcessor, EMAN::MinShrinkProcessor, EMAN::MeanShrinkProcessor, EMAN::MedianShrinkProcessor, EMAN::FFTResampleProcessor, EMAN::GradientPlaneRemoverProcessor, EMAN::NonConvexProcessor, EMAN::FlattenBackgroundProcessor, EMAN::SigmaZeroEdgeProcessor, EMAN::BeamstopProcessor, EMAN::DecayEdgeProcessor, EMAN::ZeroEdgeRowProcessor, EMAN::ZeroEdgePlaneProcessor, EMAN::BilateralProcessor, EMAN::NormalizeMaskProcessor, EMAN::NormalizeByMassProcessor, EMAN::NormalizeCircleMeanProcessor, EMAN::SubtractOptProcessor, EMAN::NormalizeToLeastSquareProcessor, EMAN::TransposeProcessor, EMAN::FlipProcessor, EMAN::AddNoiseProcessor, EMAN::AddRandomNoiseProcessor, EMAN::AutoMask2DProcessor, EMAN::AutoMaskAsymUnit, EMAN::AutoMaskDustProcessor, EMAN::AutoMask3DProcessor, EMAN::AutoMask3D2Processor, EMAN::IterMultiMaskProcessor, EMAN::AddMaskShellProcessor, EMAN::PhaseToMassCenterProcessor, EMAN::ToMassCenterProcessor, EMAN::ACFCenterProcessor, EMAN::FSCFourierProcessor, EMAN::SNRProcessor, EMAN::FileFourierProcessor, EMAN::SymSearchProcessor, EMAN::StripeXYProcessor, EMAN::LocalNormProcessor, EMAN::IndexMaskFileProcessor, EMAN::CoordinateMaskFileProcessor, EMAN::PaintProcessor, EMAN::DirectionalSumProcessor, EMAN::WatershedProcessor, EMAN::BinaryOperateProcessor< Type >, EMAN::MatchSFProcessor, EMAN::SetSFProcessor, EMAN::SmartMaskProcessor, EMAN::IterBinMaskProcessor, EMAN::TestImagePureGaussian, EMAN::TestImageFourierNoiseGaussian, EMAN::TestImageFourierNoiseProfile, EMAN::CTFSNRWeightProcessor, EMAN::TestImageLineWave, EMAN::TestImageGradient, EMAN::TestImageAxes, EMAN::TestImageGaussian, EMAN::TestImageScurve, EMAN::TestImageSphericalWave, EMAN::TestImageSinewave, EMAN::TestImageSinewaveCircular, EMAN::TestImageSquarecube, EMAN::TestImageEllipse, EMAN::TestImageHollowEllipse, EMAN::TestImageCirclesphere, EMAN::TestImageNoiseUniformRand, EMAN::TestImageNoiseGauss, EMAN::TestImageCylinder, EMAN::CCDNormProcessor, EMAN::WaveletProcessor, EMAN::TomoTiltEdgeMaskProcessor, EMAN::TomoTiltAngleWeightProcessor, EMAN::FFTProcessor, EMAN::RadialProcessor, EMAN::HistogramBin, EMAN::ModelEMCylinderProcessor, EMAN::ApplyPolynomialProfileToHelix, EMAN::BinarySkeletonizerProcessor, EMAN::ConvolutionKernelProcessor, EMAN::RotateInFSProcessor, EMAN::MirrorProcessor, EMAN::NewFourierProcessor, EMAN::NewBandpassTopHatProcessor, EMAN::NewHomomorphicTopHatProcessor, EMAN::NewLowpassGaussProcessor, EMAN::NewBandpassGaussProcessor, EMAN::NewHomomorphicGaussProcessor, EMAN::SHIFTProcessor, EMAN::InverseKaiserI0Processor, EMAN::InverseKaiserSinhProcessor, EMAN::NewRadialTableProcessor, EMAN::NewLowpassButterworthProcessor, EMAN::NewHighpassButterworthProcessor, EMAN::NewHomomorphicButterworthProcessor, EMAN::NewLowpassTanhProcessor, EMAN::NewHighpassTanhProcessor, EMAN::NewHomomorphicTanhProcessor, EMAN::NewBandpassTanhProcessor, and EMAN::CTF_Processor.

Definition at line 152 of file processor.h.

                {
                        return TypeDict();
                }
virtual Dict EMAN::Processor::get_params ( ) const [inline, virtual]

Get the processor parameters in a key/value dictionary.

Returns:
A key/value pair dictionary containing the parameters.

Definition at line 133 of file processor.h.

References params.

                {
                        return params;
                }
EMData * Processor::process ( const EMData *const  image) [virtual]
virtual void EMAN::Processor::process_inplace ( EMData image) [pure 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:
imageThe image to be processed.

Implemented in EMAN::XYZProcessor, EMAN::ImageProcessor, EMAN::FourierProcessor, EMAN::FourierAnlProcessor, EMAN::SNREvalProcessor, EMAN::Axis0FourierProcessor, EMAN::AmpweightFourierProcessor, EMAN::ConvolutionProcessor, EMAN::XGradientProcessor, EMAN::YGradientProcessor, EMAN::ZGradientProcessor, EMAN::Wiener2DAutoAreaProcessor, EMAN::DistanceSegmentProcessor, EMAN::KmeansSegmentProcessor, EMAN::CtfSimProcessor, EMAN::Wiener2DFourierProcessor, EMAN::LowpassRandomPhaseProcessor, EMAN::RealPixelProcessor, EMAN::AddShapeProcessor, EMAN::Rotate180Processor, EMAN::TransformProcessor, EMAN::IntTranslateProcessor, EMAN::ApplySymProcessor, EMAN::ScaleTransformProcessor, EMAN::ClampingProcessor, EMAN::NSigmaClampingProcessor, EMAN::ToMinvalProcessor, EMAN::BinarizeFourierProcessor, EMAN::CoordinateProcessor, EMAN::LinearPyramidProcessor, EMAN::ComplexPixelProcessor, EMAN::AreaProcessor, EMAN::BoxStatProcessor, EMAN::DiffBlockProcessor, EMAN::CutoffBlockProcessor, EMAN::MaxShrinkProcessor, EMAN::MinShrinkProcessor, EMAN::MeanShrinkProcessor, EMAN::MedianShrinkProcessor, EMAN::FFTResampleProcessor, EMAN::GradientRemoverProcessor, EMAN::GradientPlaneRemoverProcessor, EMAN::NonConvexProcessor, EMAN::FlattenBackgroundProcessor, EMAN::RampProcessor, EMAN::VerticalStripeProcessor, EMAN::RealToFFTProcessor, EMAN::SigmaZeroEdgeProcessor, EMAN::BeamstopProcessor, EMAN::MeanZeroEdgeProcessor, EMAN::AverageXProcessor, EMAN::DecayEdgeProcessor, EMAN::ZeroEdgeRowProcessor, EMAN::ZeroEdgePlaneProcessor, EMAN::BilateralProcessor, EMAN::NormalizeProcessor, EMAN::NormalizeRampNormVar, EMAN::NormalizeByMassProcessor, EMAN::NormalizeRowProcessor, EMAN::SubtractOptProcessor, EMAN::NormalizeToLeastSquareProcessor, EMAN::RotationalAverageProcessor, EMAN::RotationalSubstractProcessor, EMAN::TransposeProcessor, EMAN::FlipProcessor, EMAN::AddNoiseProcessor, EMAN::AddRandomNoiseProcessor, EMAN::FourierToCornerProcessor, EMAN::FourierToCenterProcessor, EMAN::PhaseToCenterProcessor, EMAN::PhaseToCornerProcessor, EMAN::AutoMask2DProcessor, EMAN::AutoMaskAsymUnit, EMAN::AutoMaskDustProcessor, EMAN::AutoMask3DProcessor, EMAN::AutoMask3D2Processor, EMAN::IterMultiMaskProcessor, EMAN::AddMaskShellProcessor, EMAN::PhaseToMassCenterProcessor, EMAN::ToMassCenterProcessor, EMAN::ACFCenterProcessor, EMAN::FSCFourierProcessor, EMAN::SNRProcessor, EMAN::FileFourierProcessor, EMAN::SymSearchProcessor, EMAN::StripeXYProcessor, EMAN::LocalNormProcessor, EMAN::IndexMaskFileProcessor, EMAN::CoordinateMaskFileProcessor, EMAN::PaintProcessor, EMAN::DirectionalSumProcessor, EMAN::WatershedProcessor, EMAN::BinaryOperateProcessor< Type >, EMAN::SmartMaskProcessor, EMAN::IterBinMaskProcessor, EMAN::TestImagePureGaussian, EMAN::TestImageFourierNoiseGaussian, EMAN::TestImageFourierNoiseProfile, EMAN::CTFSNRWeightProcessor, EMAN::TestImageLineWave, EMAN::TestTomoImage, EMAN::TestImageGradient, EMAN::TestImageAxes, EMAN::TestImageGaussian, EMAN::TestImageScurve, EMAN::TestImageSphericalWave, EMAN::TestImageSinewave, EMAN::TestImageSinewaveCircular, EMAN::TestImageSquarecube, EMAN::TestImageEllipse, EMAN::TestImageHollowEllipse, EMAN::TestImageCirclesphere, EMAN::TestImageNoiseUniformRand, EMAN::TestImageNoiseGauss, EMAN::TestImageCylinder, EMAN::CCDNormProcessor, EMAN::WaveletProcessor, EMAN::TomoTiltEdgeMaskProcessor, EMAN::TomoTiltAngleWeightProcessor, EMAN::FFTProcessor, EMAN::RadialProcessor, EMAN::HistogramBin, EMAN::ModelEMCylinderProcessor, EMAN::ApplyPolynomialProfileToHelix, EMAN::BinarySkeletonizerProcessor, EMAN::ConvolutionKernelProcessor, EMAN::RotateInFSProcessor, EMAN::MirrorProcessor, EMAN::NewLowpassTopHatProcessor, EMAN::NewHighpassTopHatProcessor, EMAN::NewBandpassTopHatProcessor, EMAN::NewHomomorphicTopHatProcessor, EMAN::NewLowpassGaussProcessor, EMAN::NewHighpassGaussProcessor, EMAN::NewBandpassGaussProcessor, EMAN::NewHomomorphicGaussProcessor, EMAN::NewInverseGaussProcessor, EMAN::SHIFTProcessor, EMAN::InverseKaiserI0Processor, EMAN::InverseKaiserSinhProcessor, EMAN::NewRadialTableProcessor, EMAN::NewLowpassButterworthProcessor, EMAN::NewHighpassButterworthProcessor, EMAN::NewHomomorphicButterworthProcessor, EMAN::NewLowpassTanhProcessor, EMAN::NewHighpassTanhProcessor, EMAN::NewHomomorphicTanhProcessor, EMAN::NewBandpassTanhProcessor, and EMAN::CTF_Processor.

Referenced by process(), EMAN::EMData::process_inplace(), and process_list_inplace().

virtual void EMAN::Processor::process_list_inplace ( vector< EMData * > &  images) [inline, virtual]

To process multiple images using the same algorithm.

Parameters:
imagesMultiple images to be processed.

Definition at line 118 of file processor.h.

References process_inplace().

                {
                        for (size_t i = 0; i < images.size(); i++) {
                                process_inplace(images[i]);
                        }
                }
virtual void EMAN::Processor::set_params ( const Dict new_params) [inline, virtual]

Member Data Documentation

Dict EMAN::Processor::params [mutable, protected]

Definition at line 313 of file processor.h.

Referenced by EMAN::TransformProcessor::assert_valid_aspect(), EMAN::MaskGaussInvProcessor::calc_locals(), EMAN::NormalizeCircleMeanProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::SetSFProcessor::create_radial_func(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::LowpassAutoBProcessor::create_radial_func(), get_params(), EMAN::NewFourierProcessor::preprocess(), EMAN::LowpassAutoBProcessor::preprocess(), EMAN::FourierProcessor::preprocess(), EMAN::HighpassAutoPeakProcessor::preprocess(), EMAN::NewFourierProcessor::preprocessandconvertpars(), EMAN::MinShrinkProcessor::process(), EMAN::MaxShrinkProcessor::process(), EMAN::ConvolutionKernelProcessor::process(), EMAN::BinarySkeletonizerProcessor::process(), EMAN::ScaleTransformProcessor::process(), EMAN::WatershedProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::TransformProcessor::process(), EMAN::DirectionalSumProcessor::process(), EMAN::FSCFourierProcessor::process(), EMAN::CtfSimProcessor::process(), EMAN::SubtractOptProcessor::process(), EMAN::MeanShrinkProcessor::process(), EMAN::FFTResampleProcessor::process(), EMAN::MedianShrinkProcessor::process(), EMAN::KmeansSegmentProcessor::process(), EMAN::ApplySymProcessor::process(), EMAN::DistanceSegmentProcessor::process(), EMAN::XYZProcessor::process_inplace(), EMAN::CTF_Processor::process_inplace(), EMAN::NewBandpassTanhProcessor::process_inplace(), EMAN::NewHomomorphicTanhProcessor::process_inplace(), EMAN::NewHighpassTanhProcessor::process_inplace(), EMAN::NewLowpassTanhProcessor::process_inplace(), EMAN::NewHomomorphicButterworthProcessor::process_inplace(), EMAN::NewHighpassButterworthProcessor::process_inplace(), EMAN::NewLowpassButterworthProcessor::process_inplace(), EMAN::NewRadialTableProcessor::process_inplace(), EMAN::InverseKaiserSinhProcessor::process_inplace(), EMAN::InverseKaiserI0Processor::process_inplace(), EMAN::SHIFTProcessor::process_inplace(), EMAN::NewInverseGaussProcessor::process_inplace(), EMAN::NewHomomorphicGaussProcessor::process_inplace(), EMAN::NewBandpassGaussProcessor::process_inplace(), EMAN::NewHighpassGaussProcessor::process_inplace(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::NewHomomorphicTopHatProcessor::process_inplace(), EMAN::NewBandpassTopHatProcessor::process_inplace(), EMAN::NewHighpassTopHatProcessor::process_inplace(), EMAN::NewLowpassTopHatProcessor::process_inplace(), EMAN::BinaryOperateProcessor< Type >::process_inplace(), EMAN::MinShrinkProcessor::process_inplace(), EMAN::MaxShrinkProcessor::process_inplace(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::ApplyPolynomialProfileToHelix::process_inplace(), EMAN::ModelEMCylinderProcessor::process_inplace(), EMAN::TomoTiltEdgeMaskProcessor::process_inplace(), EMAN::TomoTiltAngleWeightProcessor::process_inplace(), EMAN::ConvolutionProcessor::process_inplace(), EMAN::HistogramBin::process_inplace(), EMAN::NSigmaClampingProcessor::process_inplace(), EMAN::ClampingProcessor::process_inplace(), EMAN::ScaleTransformProcessor::process_inplace(), EMAN::IntTranslateProcessor::process_inplace(), EMAN::TransformProcessor::process_inplace(), EMAN::MirrorProcessor::process_inplace(), EMAN::RadialProcessor::process_inplace(), EMAN::FFTProcessor::process_inplace(), EMAN::WaveletProcessor::process_inplace(), EMAN::CCDNormProcessor::process_inplace(), EMAN::TestImageCylinder::process_inplace(), EMAN::TestImageNoiseGauss::process_inplace(), EMAN::TestImageNoiseUniformRand::process_inplace(), EMAN::TestImageEllipse::process_inplace(), EMAN::TestImageHollowEllipse::process_inplace(), EMAN::TestImageCirclesphere::process_inplace(), EMAN::TestImageSquarecube::process_inplace(), EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImagePureGaussian::process_inplace(), EMAN::TestImageAxes::process_inplace(), EMAN::TestImageGradient::process_inplace(), EMAN::TestImageGaussian::process_inplace(), EMAN::TestImageLineWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::IterBinMaskProcessor::process_inplace(), EMAN::AutoMask3D2Processor::process_inplace(), EMAN::AutoMaskDustProcessor::process_inplace(), EMAN::AutoMask3DProcessor::process_inplace(), EMAN::SmartMaskProcessor::process_inplace(), EMAN::CoordinateMaskFileProcessor::process_inplace(), EMAN::IndexMaskFileProcessor::process_inplace(), EMAN::SymSearchProcessor::process_inplace(), EMAN::LocalNormProcessor::process_inplace(), EMAN::StripeXYProcessor::process_inplace(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::PhaseToMassCenterProcessor::process_inplace(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::AddMaskShellProcessor::process_inplace(), EMAN::IterMultiMaskProcessor::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::AutoMask2DProcessor::process_inplace(), EMAN::AutoMaskAsymUnit::process_inplace(), EMAN::AddNoiseProcessor::process_inplace(), EMAN::FlipProcessor::process_inplace(), EMAN::BilateralProcessor::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::NormalizeToLeastSquareProcessor::process_inplace(), EMAN::NormalizeByMassProcessor::process_inplace(), EMAN::ZeroEdgePlaneProcessor::process_inplace(), EMAN::ZeroEdgeRowProcessor::process_inplace(), EMAN::DecayEdgeProcessor::process_inplace(), EMAN::BeamstopProcessor::process_inplace(), EMAN::SigmaZeroEdgeProcessor::process_inplace(), EMAN::GradientPlaneRemoverProcessor::process_inplace(), EMAN::FlattenBackgroundProcessor::process_inplace(), EMAN::MeanShrinkProcessor::process_inplace(), EMAN::FFTResampleProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::DiffBlockProcessor::process_inplace(), EMAN::BoxStatProcessor::process_inplace(), EMAN::ToMinvalProcessor::process_inplace(), EMAN::LowpassRandomPhaseProcessor::process_inplace(), EMAN::Axis0FourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::PaintProcessor::set_params(), EMAN::PeakOnlyProcessor::set_params(), EMAN::AreaProcessor::set_params(), EMAN::MaskGaussNonuniformProcessor::set_params(), EMAN::MaskGaussProcessor::set_params(), EMAN::MaskEdgeMeanProcessor::set_params(), EMAN::MaskSoftProcessor::set_params(), EMAN::MaskSharpProcessor::set_params(), EMAN::CircularMaskProcessor::set_params(), EMAN::SigmaProcessor::set_params(), EMAN::RangeThresholdProcessor::set_params(), EMAN::FiniteProcessor::set_params(), EMAN::ExpProcessor::set_params(), EMAN::LinearXformProcessor::set_params(), EMAN::CollapseProcessor::set_params(), EMAN::ValuePowProcessor::set_params(), EMAN::RecipCarefullyProcessor::set_params(), EMAN::RealPixelProcessor::set_params(), EMAN::DoGFourierProcessor::set_params(), EMAN::LoGFourierProcessor::set_params(), EMAN::LinearRampProcessor::set_params(), EMAN::Wiener2DFourierProcessor::set_params(), EMAN::Wiener2DAutoAreaProcessor::set_params(), EMAN::AmpweightFourierProcessor::set_params(), EMAN::Axis0FourierProcessor::set_params(), EMAN::SNREvalProcessor::set_params(), set_params(), and EMAN::NewFourierProcessor::setbutterworthdefaults().


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