processor.h

Go to the documentation of this file.

/*
 * Author: Steven Ludtke, 04/10/2003 (sludtke@bcm.edu)
 * Copyright (c) 2000-2006 Baylor College of Medicine
 *
 * This software is issued under a joint BSD/GNU license. You may use the
 * source code in this file under either license. However, note that the
 * complete EMAN2 and SPARX software packages have some GPL dependencies,
 * so you are responsible for compliance with the licenses of these packages
 * if you opt to use BSD licensing. The warranty disclaimer below holds
 * in either instance.
 *
 * This complete copyright notice must be included in any revised version of the
 * source code. Additional authorship citations may be added, but existing
 * author citations must be preserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by.edge
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * */

#ifndef eman_processor_h__
#define eman_processor_h__ 1

#include "emobject.h"
#include "util.h"
#include "geometry.h"
#include "transform.h"
#include "emdata.h"
#include "gorgon/skeletonizer.h"

#include <cfloat>
#include <climits>
#include <cstring>

using std::vector;
using std::map;
using std::string;

namespace EMAN
{
        class EMData;

        class Processor
        {
          public:
                virtual ~ Processor()
                {
                }

                virtual void process_inplace(EMData *image) = 0;

                virtual EMData* process(const EMData * const image);

                virtual void process_list_inplace(vector < EMData * > & images)
                {
                        for (size_t i = 0; i < images.size(); i++) {
                                process_inplace(images[i]);
                        }
                }

                virtual string get_name() const = 0;

                virtual Dict get_params() const
                {
                        return params;
                }

                virtual void set_params(const Dict & new_params)
                {
                        params = new_params;
                }

                virtual TypeDict get_param_types() const
                {
                        return TypeDict();
                }

                static string get_group_desc()
                {
                        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 get_desc() const = 0;

                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_,
                };

                static void
                EMFourierFilterInPlace(EMData* fimage, Dict params) {
                        bool doInPlace = true;
                        EMFourierFilterFunc(fimage, params, doInPlace);
                }

                static EMData*
                EMFourierFilter(EMData* fimage, Dict params) {
                        bool doInPlace = false;
                        return EMFourierFilterFunc(fimage, params, doInPlace);
                }

          private:
                static EMData*
                EMFourierFilterFunc(EMData* fimage, Dict params, bool doInPlace=true);

          protected:
                mutable Dict params;
        };

        class ImageProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                static string get_group_desc()
                {
                        return "An Image Processor defines a way to create a processor image. The processor image is used to multiply the input-image in the fourier space. ImageFilter class is the base class. Each specific ImageFilter class must define function create_processor_image(). ";
                }

          protected:
                virtual EMData * create_processor_image() const = 0;
        };

        class FourierProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                static string get_group_desc()
                {
                        return "Fourier Filter processors are a group of processor in the frequency domain. Before using such processors on an image, the image must be transformed from real space to the fourier space. FourierProcessor class is the base class of fourier space processors. Each specific processor is either a lowpass filter processor, or a highpass filter processor, or neighter. The unit of lowpass and highpass parameters are in terms of Nyquist, valid range is [0,0.5]. ";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("cutoff_abs", EMObject::FLOAT, "Processor radius in terms of Nyquist (0-.5)");
                        d.put("cutoff_pixels", EMObject::FLOAT, " Width in Fourier pixels (0 - size()/2)");
                        d.put("cutoff_freq", EMObject::FLOAT, "Resolution in 1/A (0 - 1 / size*apix)");
                        d.put("apix", EMObject::FLOAT, " Override A/pix in the image header (changes x,y and z)");
                        return d;
                }

          protected:
                  virtual void preprocess(EMData * image) {}
                  virtual void create_radial_func(vector < float >&radial_mask) const = 0;
        };

        class FourierAnlProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                static string get_group_desc()
                {
                        return "Fourier Filter processors are a group of processor in the frequency domain. Before using such processors on an image, the image must be transformed from real space to the fourier space. FourierProcessor class is the base class of fourier space processors. Each specific processor is either a lowpass filter processor, or a highpass filter processor, or neighter. The unit of lowpass and highpass parameters are in terms of Nyquist, valid range is [0,0.5]. ";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("cutoff_abs", EMObject::FLOAT, "Processor radius in terms of Nyquist (0-.5)");
                        d.put("cutoff_pixels", EMObject::FLOAT, " Width in Fourier pixels (0 - size()/2)");
                        d.put("cutoff_freq", EMObject::FLOAT, "Resolution in 1/A (0 - 1 / size*apix)");
                        d.put("apix", EMObject::FLOAT, " Override A/pix in the image header (changes x,y and z)");
                        return d;
                }

          protected:
                  virtual void preprocess(EMData * image) {}
                  virtual void create_radial_func(vector < float >&radial_mask,EMData *image) const = 0;
        };

        class SNREvalProcessor:public Processor
        {
                public:
                string get_name() const
                {
                        return "eval.maskedsnr";
                }

                void process_inplace(EMData * image);

                void set_params(const Dict & new_params)
                {
                        params = new_params;
//                      sum = params["sum"];
//                      dosqrt = params["sqrt"];
//                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
//                      d.put("sum", EMObject::EMDATA, "Adds the weights to sum for normalization");
//                      d.put("sqrt", EMObject::INT, "Weights using sqrt of the amplitude if set");
                        return d;
                }

                static Processor *NEW()
                {
                        return new SNREvalProcessor();
                }

                string get_desc() const
                {
                        return "Evaluates the SNR of the particle using a masking method similar to that used in the CTF analysis process. The image is not changed. The resulting value is placed in the particle dictionary as eval_maskedsnr";
                }

                protected:
                EMData *sum;
                int dosqrt;
        };


        class AmpweightFourierProcessor:public Processor
        {
          public:
                string get_name() const
                {
                        return "filter.ampweight";
                }

                void process_inplace(EMData * image);

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        sum = params["sum"];
                        dosqrt = params["sqrt"];
//                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("sum", EMObject::EMDATA, "Adds the weights to sum for normalization");
                        d.put("sqrt", EMObject::INT, "Weights using sqrt of the amplitude if set");
                        return d;
                }

                static Processor *NEW()
                {
                        return new AmpweightFourierProcessor();
                }

                string get_desc() const
                {
                        return "Multiplies each Fourier pixel by its amplitude";
                }

                protected:
                EMData *sum;
                int dosqrt;
        };
        class ConvolutionProcessor : public Processor
        {
                public:
                        ConvolutionProcessor() {}

                        string get_name() const
                        {
                                return "math.convolution";
                        }

                        void process_inplace(EMData *image);

                        static Processor *NEW()
                        {
                                return new ConvolutionProcessor();
                        }

                        string get_desc() const
                        {
                                return "Performs Fourier space convolution. Maintains the space that the image is in - i.e. if image is real, the result is real and vice versa.";
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("with", EMObject::EMDATA, "The image that will convolute the other image");
                                return d;
                        }
        };

        class XGradientProcessor : public Processor
        {
         public:
                XGradientProcessor() {}

                string get_name() const
                {
                        return "math.edge.xgradient";
                }

                void process_inplace(EMData *image);

                static Processor *NEW()
                {
                        return new XGradientProcessor();
                }

                string get_desc() const
                {
                        return "Determines the image gradient in the x direction";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        return d;
                }
        };

        class YGradientProcessor : public Processor
        {
                public:
                        YGradientProcessor() {}

                        string get_name() const
                        {
                                return "math.edge.ygradient";
                        }

                        void process_inplace(EMData *image);

                        static Processor *NEW()
                        {
                                return new YGradientProcessor();
                        }

                        string get_desc() const
                        {
                                return "Determines the image gradient in the y direction";
                        }


                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                return d;
                        }
        };

        class ZGradientProcessor : public Processor
        {
                public:
                        ZGradientProcessor() {}

                        string get_name() const
                        {
                                return "math.edge.zgradient";
                        }

                        void process_inplace(EMData *image);

                        static Processor *NEW()
                        {
                                return new ZGradientProcessor();
                        }

                        string get_desc() const
                        {
                                return "Determines the image gradient in the z direction";
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                return d;
                        }
        };

        class Wiener2DAutoAreaProcessor:public Processor
        {
          public:
                string get_name() const
                {
                        return "filter.wiener2dauto";
                }

                virtual EMData* process(const EMData * const image);

                void process_inplace(EMData *image);

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        bgsize = params["size"];
//                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("size", EMObject::INT, "Size in pixels of the boxes to chop the image into");
                        return d;
                }

                static Processor *NEW()
                {
                        return new Wiener2DAutoAreaProcessor();
                }

                string get_desc() const
                {
                        return "Automatically detrmines the background for the image then uses this to perform Wiener filters on overlapping subregions of the image, which are then combined using linear interpolation";
                }

                protected:
                int bgsize;
        };


        class Wiener2DFourierProcessor:public Processor
        {
          public:
                string get_name() const
                {
                        return "filter.wiener2d";
                }

                virtual EMData* process(const EMData * const image);

                void process_inplace(EMData *image);

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        ctf = params["ctf"];
//                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("ctf", EMObject::EMDATA, "Ctf object to use for Wiener filter parameters");
                        return d;
                }

                static Processor *NEW()
                {
                        return new Wiener2DFourierProcessor();
                }

                string get_desc() const
                {
                        return "Applies a 2-D Wiener filter to an image based on its Ctf parameters";
                }

                protected:
                Ctf *ctf;
        };

        class LowpassFourierProcessor:public FourierProcessor
        {
          public:
                LowpassFourierProcessor():lowpass(0)
                {
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        if( params.has_key("lowpass") ) {
                                lowpass = params["lowpass"];
                        }
//                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
                }

                TypeDict get_param_types() const
                {
                        TypeDict d = FourierProcessor::get_param_types();
                        d.put("lowpass", EMObject::FLOAT, "Processor radius in terms of Nyquist (0-.5)");
                        return d;
                }

                static string get_group_desc()
                {
                        return "Low-pass processor attenuates amplitudes at high spatial frequencies. It has the result of blurring the image, and of eliminating sharp edges and noise. The base class for all low pass fourier processors.";
                }

          protected:
                  virtual void preprocess(EMData * image);
                  float lowpass;
        };

        class LinearRampFourierProcessor:public FourierProcessor
        {
                public:
                        virtual string get_name() const { return "filter.linearfourier"; }

                        virtual string get_desc() const
                        {
                                return "";
                        }

                        static Processor *NEW()
                        {
                                return new LinearRampFourierProcessor();
                        }

                protected:
                        virtual void create_radial_func(vector < float >&radial_mask) const ;
        };

        class HighpassFourierProcessor:public FourierProcessor
        {
          public:
                HighpassFourierProcessor():highpass(0)
                {
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        if( params.has_key("highpass") ) {
                                highpass = params["highpass"];
                        }
                }

                TypeDict get_param_types() const
                {
                        TypeDict d = FourierProcessor::get_param_types();
                        d.put("highpass", EMObject::FLOAT, "Processor radius in terms of Nyquist (0-.5)");
                        return d;
                }

                static string get_group_desc()
                {
                        return "High-pass processor is rotationally symmetric 2D function. It attenuates amplitudes at low spatial frequencies, and increases amplitudes for high spatial frequencies. It has the result of enhancing the edges in the image while suppressing all slow-moving variations.      <br> HighpassFourierProcessor class is the base class for all high pass fourier processors.";
                }

          protected:
                  virtual void preprocess(EMData * image);
                  float highpass;
        };

        class LowpassSharpCutoffProcessor:public LowpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.lowpass.sharp";
                }

                static Processor *NEW()
                {
                        return new LowpassSharpCutoffProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: if x <= lowpass, f(x) = 1; else f(x) = 0;";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };

        class HighpassSharpCutoffProcessor:public HighpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.highpass.sharp";
                }

                static Processor *NEW()
                {
                        return new HighpassSharpCutoffProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: if x >= highpass, f(x) = 1; else f(x) = 0;";
                }


          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };

        class LowpassGaussProcessor:public LowpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.lowpass.gaussian";
                }

                static Processor *NEW()
                {
                        return new LowpassGaussProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: if lowpass > 0, f(x) = exp(-x*x/(lowpass*lowpass)); else f(x) = exp(x*x/(lowpass*lowpass));";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };

        class HighpassAutoPeakProcessor:public FourierAnlProcessor
        {
          public:
                string get_name() const
                {
                        return "filter.highpass.autopeak";
                }
                static Processor *NEW()
                {
                        return new HighpassAutoPeakProcessor();
                }

                string get_desc() const
                {
                        return "Attempts to automatically remove the low resolution peak present in virtually all cryoEM data.";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask, EMData *image) const;
                  virtual void preprocess(EMData * image);
                  float highpass;
        };


        class HighpassGaussProcessor:public HighpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.highpass.gaussian";
                }
                static Processor *NEW()
                {
                        return new HighpassGaussProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: f(x) = 1.0-exp(-x*x/(highpass*highpass);";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };

        class LowpassTanhProcessor:public LowpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.lowpass.tanh";
                }
                static Processor *NEW()
                {
                        return new LowpassTanhProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: f(x)=tanh(lowpass-x)/2.0 + 0.5;";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };


        class HighpassTanhProcessor:public HighpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.highpass.tanh";
                }
                static Processor *NEW()
                {
                        return new HighpassTanhProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: f(x)=tanh(x-highpass)/2.0+0.5;";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };

        class HighpassButterworthProcessor:public HighpassFourierProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.highpass.butterworth";
                }
                static Processor *NEW()
                {
                        return new HighpassButterworthProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: f(x) = 1/(1+t*t);";
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;
        };

        class LinearRampProcessor:public FourierProcessor
        {
          public:
                LinearRampProcessor():intercept(0), slope(0)
                {
                }

                string get_name() const
                {
                        return "eman1.filter.ramp";
                }
                static Processor *NEW()
                {
                        return new LinearRampProcessor();
                }

                string get_desc() const
                {
                        return "processor radial function: f(x) = slope * x + intercept;";
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        intercept = params["intercept"];
                        slope = params["slope"];
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("intercept", EMObject::FLOAT, "intercept in 'f(x) = slope * x + intercept'");
                        d.put("slope", EMObject::FLOAT, "slope in 'f(x) = slope * x + intercept'");
                        return d;
                }

          protected:
                void create_radial_func(vector < float >&radial_mask) const;

          private:
                float intercept;
                float slope;
        };

        class RealPixelProcessor:public Processor
        {
          public:
                RealPixelProcessor():value(0), maxval(1), mean(0), sigma(0)
                {
                }
                void process_inplace(EMData * image);

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        if (params.size() == 1) {
                                vector < EMObject > dict_values = params.values();
                                value = dict_values[0];
                        }
                }

                static string get_group_desc()
                {
                        return "The base class for real space processor working on individual pixels. The processor won't consider the pixel's coordinates and neighbors.";
                }

          protected:
                virtual void process_pixel(float *x) const = 0;
                virtual void calc_locals(EMData *)
                {
                }
                virtual void normalize(EMData *) const
                {
                }

                float value;
                float maxval;
                float mean;
                float sigma;
        };

        class AbsoluateValueProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "math.absvalue";
                }
                static Processor *NEW()
                {
                        return new AbsoluateValueProcessor();
                }
          protected:
                void process_pixel(float *x) const
                {
                        *x = fabs(*x);
                }

                string get_desc() const
                {
                        return "f(x) = |x|";
                }

        };


        class BooleanProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "threshold.notzero";
                }
                static Processor *NEW()
                {
                        return new BooleanProcessor();
                }

                string get_desc() const
                {
                        return "f(x) = 0 if x = 0; f(x) = 1 if x != 0;";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x != 0)
                        {
                                *x = 1.0;
                        }
                }
        };

        class InvertCarefullyProcessor:public RealPixelProcessor
        {
                public:
                        string get_name() const
                        {
                                return "math.invert.carefully";
                        }
                        static Processor *NEW()
                        {
                                return new InvertCarefullyProcessor();
                        }

                        void set_params(const Dict & new_params)
                        {
                                params = new_params;
                                zero_to = params.set_default("zero_to",0.0f);
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("zero_to", EMObject::FLOAT, "Inverted zero values are set to this value, default is 0.");
                                return d;
                        }

                        string get_desc() const
                        {
                                return "if f(x) != 0: f(x) = 1/f(x) else: f(x) = zero_to";
                        }

                protected:
                        void process_pixel(float *x) const
                        {
                                if (*x == 0) *x = zero_to;
                                else *x = 1/(*x);
                        }
                private:
                        float zero_to;
        };

        class ValuePowProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "math.pow";
                }
                static Processor *NEW()
                {
                        return new ValuePowProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        pwr = params["pow"];
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("pow", EMObject::FLOAT, "Each pixel is raised to this power");
                        return d;
                }

                string get_desc() const
                {
                        return "f(x) = x ^ pow;";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x<0 && pwr!=(int)pwr) *x=0;
                        else (*x) = pow(*x,pwr);
                }
          private:
                float pwr;
        };

        class ValueSquaredProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "math.squared";
                }
                static Processor *NEW()
                {
                        return new ValueSquaredProcessor();
                }


                string get_desc() const
                {
                        return "f(x) = x * x;";
                }

          protected:
                void process_pixel(float *x) const
                {
                        (*x) *= (*x);
                }
        };

        class ValueSqrtProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "math.sqrt";
                }
                static Processor *NEW()
                {
                        return new ValueSqrtProcessor();
                }

                string get_desc() const
                {
                        return "f(x) = sqrt(x)";
                }

          protected:
                void process_pixel(float *x) const
                {
                        *x = sqrt(*x);
                }
        };

        class ToZeroProcessor:public RealPixelProcessor
        {
                public:
                        string get_name() const
                        {
                                return "threshold.belowtozero";
                        }
                        static Processor *NEW()
                        {
                                return new ToZeroProcessor();
                        }
                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("minval", EMObject::FLOAT, "Everything below this value is set to zero");
                                return d;
                        }

                        string get_desc() const
                        {
                                return "f(x) = x if x >= minval; f(x) = 0 if x < minval.";
                        }

                protected:
                        inline void process_pixel(float *x) const
                        {
                                if (*x < value) {
                                        *x = 0;
                                }
                        }
        };

        class Rotate180Processor:public Processor
        {
                public:
                        string get_name() const
                        {
                                return "math.rotate.180";
                        }
                        static Processor *NEW()
                        {
                                return new Rotate180Processor();
                        }

                        void process_inplace(EMData* image);

                        string get_desc() const
                        {
                                return "The 2D image is rotated by 180 degree by carefully swapping image pixel values. No explicit matrix multiplication is performed. If image dimensions are even will change pixels along x=0 and y=0. Works for all combinations of even and oddness.";
                        }
        };

        class TransformProcessor:public Processor
        {
                public:
                        virtual string get_name() const
                        {
                                return "math.transform";
                        }
                        static Processor *NEW()
                        {
                                return new TransformProcessor();
                        }

                        virtual void process_inplace(EMData* image);

                        virtual EMData* process(const EMData* const image);

                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("transform", EMObject::TRANSFORM, "The Transform object that will be applied to the image" );
                                return d;
                        }

                        virtual string get_desc() const
                        {
                                return "The image is transformed using Transform parameter.";
                        }
                private:
                        float* transform(const EMData* const image, const Transform& t) const;
                        // This function became redundant if favor of EMData::scale_pixel
                        //void update_emdata_attributes(EMData* const image, const Dict& attr_dict, const float& scale) const;


                        void assert_valid_aspect(const EMData* const image) const;
        };

        class IntTranslateProcessor:public Processor
        {
                public:
                        virtual string get_name() const
                        {
                                return "math.translate.int";
                        }

                        static Processor *NEW()
                        {
                                return new IntTranslateProcessor();
                        }

                        virtual void process_inplace(EMData* image);

                        virtual EMData* process(const EMData* const image);

                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("trans", EMObject::INTARRAY, "The displacement array, can be length 1-3" );
                                return d;
                        }

                        virtual string get_desc() const
                        {
                                return "The image is translated an integer amount";
                        }
                private:
                        void assert_valid_aspect(const vector<int>& translation, const EMData* const image) const;

                        Region get_clip_region(vector<int>& translation, const EMData* const image) const;
        };

                class ScaleTransformProcessor:public Processor
                {
                        public:
                                virtual string get_name() const
                                {
                                        return "math.transform.scale";
                                }
                                static Processor *NEW()
                                {
                                        return new ScaleTransformProcessor();
                                }

                                virtual void process_inplace(EMData* image);

                                virtual EMData* process(const EMData* const image);

                                virtual TypeDict get_param_types() const
                                {
                                        TypeDict d;
                                        d.put("scale", EMObject::FLOAT, "The amount by which to scale" );
                                        d.put("clip", EMObject::INT, "The length of each output dimension. Non sophisticated, output dimensions can't be different" );
                                        return d;
                                }

                                virtual string get_desc() const
                                {
                                        return "The image is scaled with the clip variable in mind, being sure to preserve as much pixel information as possible.";
                                }
                };

        class ClampingProcessor :public Processor
        {
          public:
                ClampingProcessor() : default_max(1.0), default_min(0.0) {}

                string get_name() const
                {
                        return "threshold.clampminmax";
                }
                static Processor *NEW()
                {
                        return new ClampingProcessor();
                }

                void process_inplace(EMData *image);

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("minval", EMObject::FLOAT, "The pixel values that bounds the smallest pixel value in the output image" );
                        d.put("maxval", EMObject::FLOAT, "The pixel values that bounds the largest pixel value in the output image" );
                        d.put("tomean", EMObject::BOOL, "Replace outlying pixels values with the mean pixel value instead" );
                        return d;
                }

                string get_desc() const
                {
                        return "This function clamps the min and max vals in the image at minval and maxval, respectively. In a sense this a bi-truncation of the data.";
                }

          protected:
                float default_max, default_min;
        };

        class NSigmaClampingProcessor : public ClampingProcessor
        {
                public:
                        NSigmaClampingProcessor() : default_sigma(2.0) {}

                        string get_name() const
                        {
                                return "threshold.clampminmax.nsigma";
                        }

                        static Processor *NEW()
                        {
                                return new NSigmaClampingProcessor();
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("nsigma", EMObject::FLOAT, "The number (n) of sigmas to clamp min and max vals at, so that the clamped boundaries are mean-n*sigma and mean+n*sigma" );
                                d.put("tomean", EMObject::BOOL, "Replace outlying pixels values with the mean pixel value instead" );
                                return d;
                        }

                        void process_inplace(EMData *image);

                        string get_desc() const
                        {
                                return "This function clamps the min and max vals in the image at minval and maxval at mean-n*sigma and mean+n*sigma, respectively. The parameter specified by the user is n, the default value of n is 2.";
                        }

                protected:
                        float default_sigma;
        };

        class ToMinvalProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "threshold.belowtominval";
                }
                static Processor *NEW()
                {
                        return new ToMinvalProcessor();
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("minval", EMObject::FLOAT, "Everything below this value is set to this value");
                        return d;
                }

                string get_desc() const
                {
                        return "f(x) = x if x >= minval; f(x) = minval if x < minval.";
                }

        protected:
                inline void process_pixel(float *x) const
                {
                        if (*x < value) {
                                *x = value;
                        }
                }
        };


        class CutToZeroProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "threshold.belowtozero_cut";
                }
                static Processor *NEW()
                {
                        return new CutToZeroProcessor();
                }
                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("minval", EMObject::FLOAT, "the value that will be set to zero - all values below will also be set to zero. Values above get minval subtracted from them" );
                        return d;
                }

                string get_desc() const
                {
                        return "f(x) = x-minval if x >= minval; f(x) = 0 if x < minval.";
                }

          protected:
                void process_pixel(float *x) const
                {
                        *x = *x - value;
                        if (*x < 0) {
                                *x = 0;
                        }
                }
        };

        class BinarizeProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "threshold.binary";
                }
                static Processor *NEW()
                {
                        return new BinarizeProcessor();
                }
                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("value", EMObject::FLOAT, "The thresholding value. If a pixel value is equal to or above the threshold it is set to 1. If it is below it is set to 0" );
                        return d;
                }

                string get_desc() const
                {
                        return "f(x) = 0 if x < value; f(x) = 1 if x >= value.";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x < value)
                        {
                                *x = 0;
                        }
                        else
                        {
                                *x = 1;
                        }
                }
        };

        class BinarizeFourierProcessor:public Processor
                {
                  public:
                        virtual string get_name() const
                        {
                                return "threshold.binary.fourier";
                        }
                        static Processor *NEW()
                        {
                                return new BinarizeFourierProcessor();
                        }

                        virtual void process_inplace(EMData* image);

                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("value", EMObject::FLOAT, "The Fourier amplitude threshold cutoff" );
                                return d;
                        }

                        virtual string get_desc() const
                        {
                                return "f(k) = 0 + 0i if ||f(k)|| < value; f(k) = 1 + 0i if ||f(k)|| >= value.";
                        }
                };

        class CollapseProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "threshold.compress";
                }
                static Processor *NEW()
                {
                        return new CollapseProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        range = params["range"];
                        value = params["value"];
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("range", EMObject::FLOAT, "The range about 'value' which will be collapsed to 'value'");
                        d.put("value", EMObject::FLOAT, "The pixel value where the focus of the collapse operation is");
                        return d;
                }

                string get_desc() const
                {
                        return "f(x): if v-r<x<v+r -> v; if x>v+r -> x-r; if x<v-r -> x+r";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x>value+range) *x-=range;
                        else if (*x<value-range) *x+=range;
                        else *x=value;
                }
                float range;
        };

        class LinearXformProcessor:public RealPixelProcessor
        {
          public:
                LinearXformProcessor():shift(0), scale(0)
                {
                }

                string get_name() const
                {
                        return "math.linear";
                }
                static Processor *NEW()
                {
                        return new LinearXformProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        shift = params.get("shift");
                        scale = params.get("scale");
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("shift", EMObject::FLOAT, "The amount to shift pixel values by before scaling");
                        d.put("scale", EMObject::FLOAT, "The scaling factor to be applied to pixel values");
                        return d;
                }

                string get_desc() const
                {
                        return "linear transform processor: f(x) = x * scale + shift. This is equivalent to a regular contrast stretching operation";
                }

          protected:
                void process_pixel(float *x) const
                {
                        *x = (*x) * scale + shift;
                }

          private:
                float shift;
                float scale;
        };

        class ExpProcessor:public RealPixelProcessor
        {
          public:
                ExpProcessor():low(0), high(0)
                {
                }

                string get_name() const
                {
                        return "math.exp";
                }

                static Processor *NEW()
                {
                        return new ExpProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        low = params.get("low");
                        high = params.get("high");
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("low", EMObject::FLOAT, "Pixels are divided by (low - high) prior to the exponential operation");
                        d.put("high", EMObject::FLOAT, "Pixels are divided by (low - high) prior to the exponential operation");
                        return d;
                }

                string get_desc() const
                {
                        return "f(x) = exp( x / low - high)";
                }

          protected:
                void process_pixel(float *x) const
                {
                        float v = *x / low - high;
                        if (v > 40) {
                                v = 40;
                        }
                        *x = exp(v);
                }

          private:
                float low;
                float high;
        };

        class FiniteProcessor:public RealPixelProcessor
        {
                public:
                        FiniteProcessor():to(0)
                        {
                        }

                        string get_name() const
                        {
                                return "math.finite";
                        }

                        static Processor *NEW()
                        {
                                return new FiniteProcessor();
                        }

                        void set_params(const Dict & new_params)
                        {
                                if (new_params.has_key("to") )
                                        to = params["to"];
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("to", EMObject::FLOAT, "Pixels which are not finite will be set to this value");
                                return d;
                        }

                        string get_desc() const
                        {
                                return "f(x) = f(x) if f(x) is finite | to if f(x) is not finite";
                        }

                protected:
                        void process_pixel(float *x) const;
                private:
                        float to;
        };

        class RangeThresholdProcessor:public RealPixelProcessor
        {
          public:
                RangeThresholdProcessor():low(0), high(0)
                {
                }

                string get_name() const
                {
                        return "threshold.binaryrange";
                }
                static Processor *NEW()
                {
                        return new RangeThresholdProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        low = params.get("low");
                        high = params.get("high");
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("low", EMObject::FLOAT, "The lower limit of the range that will be set to 1");
                        d.put("high", EMObject::FLOAT, "The upper limit of the range that will be set to 1");
                        return d;
                }

                string get_desc() const
                {
                        return "Range thresholding. A range of values is set to 1, all else is set to 0. f(x) = 1 if (low <= x <= high); else f(x) = 0";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x >= low && *x <= high) {
                                *x = 1;
                        }
                        else {
                                *x = 0;
                        }
                }
          private:
                float low;
                float high;

        };

        class SigmaProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "math.sigma";
                }
                static Processor *NEW()
                {
                        return new SigmaProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        value1 = params.get("value1");
                        value2 = params.get("value2");
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("value1", EMObject::FLOAT, "A number reflecting total standard deviations in the right direction");
                        d.put("value2", EMObject::FLOAT, "A number reflecting total standard deviations in the left direction");
                        return d;
                }

                string get_desc() const
                {
                        return "f(x) = mean if x<(mean-v2*sigma) or x>(mean+v1*sigma); else f(x) = x;";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x < (mean - value2 * sigma) || *x > (mean + value1 * sigma))
                        {
                                *x = mean;
                        }
                }

          private:
                float value1;
                float value2;
        };

        class LogProcessor:public RealPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "math.log";
                }
                static Processor *NEW()
                {
                        return new LogProcessor();
                }

                string get_desc() const
                {
                        return "f(x) = log10(x) if x > 0; else f(x) = 0;";
                }

          protected:
                void process_pixel(float *x) const
                {
                        if (*x > 0)
                        {
                                *x = log10(*x);
                        }
                        else
                        {
                                *x = 0;
                        }
                }
        };

        class CoordinateProcessor:public Processor
        {
          public:
                CoordinateProcessor():nx(0), ny(0), nz(0), mean(0), sigma(0), maxval(0), is_complex(false)
                {
                }
                void process_inplace(EMData * image);

                static string get_group_desc()
                {
                        return "CoordinateProcessor applies processing based on a pixel's value and it coordinates. This is the base class. Specific coordinate processor should implement process_pixel().";
                }

          protected:
                virtual void process_pixel(float *pixel, int xi, int yi, int zi) const = 0;
                virtual void calc_locals(EMData *)
                {
                }
                virtual bool is_valid() const
                {
                        return true;
                }

                int nx;
                int ny;
                int nz;
                float mean;
                float sigma;
                float maxval;

                bool is_complex;
        };

        class CircularMaskProcessor:public CoordinateProcessor
        {
          public:
                CircularMaskProcessor():inner_radius(0), outer_radius(0), inner_radius_square(0),
                        outer_radius_square(0), dx(0), dy(0), dz(0), xc(0), yc(0), zc(0)
                {
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;

                        if (params.has_key("inner_radius")) {
                                inner_radius = params["inner_radius"];
                                inner_radius_square = inner_radius * inner_radius;
                        }
                        else {
                                inner_radius = -1;
                                inner_radius_square = -1;
                        }

                        if (params.has_key("outer_radius")) {
                                outer_radius = params["outer_radius"];
                                outer_radius_square = outer_radius * outer_radius;
                        }
                        else {
                                outer_radius = INT_MAX;
                                outer_radius_square = INT_MAX;
                        }

                        if (params.has_key("xc")) xc = params["xc"];
                        if (params.has_key("yc")) yc = params["yc"];
                        if (params.has_key("zc")) zc = params["zc"];
                        if (params.has_key("dx")) dx = params["dx"];
                        if (params.has_key("dy")) dy = params["dy"];
                        if (params.has_key("dz")) dz = params["dz"];
                }

                string get_desc() const
                {
                        return "CircularMaskProcessor applies a circular mask to the data.This is the base class for specific circular mask processors.Its subclass must implement process_dist_pixel().";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;

                        d.put("inner_radius", EMObject::INT, "inner mask radius. optional, default=-1");
                        d.put("outer_radius", EMObject::INT, "outer mask radius");

                        d.put("dx", EMObject::FLOAT,
                                  "Modify mask center by dx relative to the default center nx/2");
                        d.put("dy", EMObject::FLOAT,
                                  "Modify mask center by dy relative to the default center ny/2");
                        d.put("dz", EMObject::FLOAT,
                                  "Modify mask center by dz relative to the default center nz/2");

                        return d;
                }
          protected:
                void calc_locals(EMData * image);

                bool is_valid() const
                {
                        return (!is_complex);
                }

                void process_pixel(float *pixel, int xi, int yi, int zi) const
                {
                        float dist = (xi - xc) * (xi - xc) + (yi - yc) * (yi - yc) + (zi - zc) * (zi - zc);
                        process_dist_pixel(pixel, dist);
                }

                virtual void process_dist_pixel(float *pixel, float dist) const = 0;

                int inner_radius;
                int outer_radius;
                int inner_radius_square;
                int outer_radius_square;
                float dx, dy, dz;
                float xc, yc, zc;
        };

        class MaskSharpProcessor:public CircularMaskProcessor
        {
          public:
                MaskSharpProcessor():value(0)
                {
                }

                string get_name() const
                {
                        return "mask.sharp";
                }
                static Processor *NEW()
                {
                        return new MaskSharpProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        CircularMaskProcessor::set_params(new_params);
                        value = params.set_default("value",0.0f);
                }

                TypeDict get_param_types() const
                {
                        TypeDict d = CircularMaskProcessor::get_param_types();
                        d.put("value", EMObject::FLOAT, "step cutoff to this value. Default is 0.");
                        return d;
                }

                string get_desc() const
                {
                        return "step cutoff to a user-given value in both inner and outer circles.";
                }

          protected:
                void process_dist_pixel(float *pixel, float dist) const
                {
                        if (dist >= outer_radius_square || dist < inner_radius_square)
                        {
                                *pixel = value;
                        }
                }

                float value;
        };


        class MaskEdgeMeanProcessor:public CircularMaskProcessor
        {                                                       // 6
          public:
                string get_name() const
                {
                        return "mask.ringmean";
                }
                static Processor *NEW()
                {
                        return new MaskEdgeMeanProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        CircularMaskProcessor::set_params(new_params);
                        ring_width = params["ring_width"];
                        if (ring_width == 0) {
                                ring_width = 1;
                        }
                }

                TypeDict get_param_types() const
                {
                        TypeDict d = CircularMaskProcessor::get_param_types();
                        d.put("ring_width", EMObject::INT, "The width of the mask ring.");
                        return d;
                }

                string get_desc() const
                {
                        return "A step cutoff to the the mean value in a ring centered on the outer radius";
                }

          protected:
                void calc_locals(EMData * image);


                void process_dist_pixel(float *pixel, float dist) const
                {
                        if (dist >= outer_radius_square || dist < inner_radius_square){
                                *pixel = ring_avg;
                        }
                }

          private:
                int ring_width;
                float ring_avg;
        };

        class MaskNoiseProcessor:public CircularMaskProcessor
        {
          public:
                string get_name() const
                {
                        return "mask.noise";
                }
                static Processor *NEW()
                {
                        return new MaskNoiseProcessor();
                }

                string get_desc() const
                {
                        return "fills masked region";
                }

          protected:
                void process_dist_pixel(float *pixel, float dist) const
                {
                        if (dist >= outer_radius_square || dist < inner_radius_square)
                        {
                                *pixel = Util::get_gauss_rand(mean, sigma);
                        }
                }
        };

        class MaskGaussProcessor:public CircularMaskProcessor
        {
          public:
                string get_name() const
                {
                        return "mask.gaussian";
                }
                static Processor *NEW()
                {
                        return new MaskGaussProcessor();
                }

                void set_params(const Dict & new_params)
                {
                        CircularMaskProcessor::set_params(new_params);
                        exponent = params["exponent"];
                        if (exponent <= 0.0) {
                                exponent = 2.0;
                        }
                }

                TypeDict get_param_types() const
                {
                        TypeDict d = CircularMaskProcessor::get_param_types();
                        d.put("exponent", EMObject::FLOAT, "The exponent, f in e^-Bs^f. default 2.0, producing a Gaussian");
                        return d;
                }

                string get_desc() const
                {
                        return "a gaussian falloff to zero, radius is the 1/e of the width. If inner_radius>0, then \
outer radius specifies width of Gaussian starting at inner_radius rather than total radius.";
                }

          protected:
                float exponent;
                void process_dist_pixel(float *pixel, float dist) const
                {
                        if (inner_radius_square>0) {
                                if (dist>inner_radius_square) {
                                        if (exponent==2.0f) (*pixel) *= exp(-pow(sqrt(dist)-inner_radius,2.0f) / outer_radius_square);
                                        else (*pixel) *= exp(-pow(sqrt(dist)-inner_radius,exponent) / pow(outer_radius_square,exponent/2.0f));
                                }
                        }
                        else {
                                if (exponent==2.0f) (*pixel) *= exp(-dist / outer_radius_square);
                                else (*pixel) *= exp(-pow(dist,exponent/2.0f) / pow(outer_radius_square,exponent/2.0f));
                        }
                }
        };

        class MaskGaussNonuniformProcessor:public CoordinateProcessor
        {
          public:
                MaskGaussNonuniformProcessor():radius_x(0), radius_y(0), radius_z(0), gauss_width(0)
                {
                }

                void set_params(const Dict & new_params)
                {
                        params = new_params;

                        if (params.has_key("radius_x")) radius_x=params["radius_x"];
                        else radius_x=5.0;

                        if (params.has_key("radius_y")) radius_y=params["radius_y"];
                        else radius_y=5.0;

                        if (params.has_key("radius_z")) radius_z=params["radius_z"];
                        else radius_z=5.0;

                        if (params.has_key("gauss_width")) gauss_width=params["gauss_width"];
                        else gauss_width=0.05f;
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;

                        d.put("radius_x", EMObject::INT, "x-axis radius");
                        d.put("radius_y", EMObject::INT, "y-axis radius");
                        d.put("radius_z", EMObject::INT, "z-axis radius");
                        d.put("gauss_width", EMObject::FLOAT, "Gaussian falloff width, relative to each radius, default 0.05");

                        return d;
                }

                string get_name() const
                {
                        return "mask.gaussian.nonuniform";
                }
                static Processor *NEW()
                {
                        return new MaskGaussNonuniformProcessor();
                }

                string get_desc() const
                {
                        return "A Gaussian falloff to zero. Nonisotropic, specify inner radius for x,y,z and Gaussian falloff width. Falloff \
width is also nonisotropic and relative to the radii, with 1 being equal to the radius on that axis.";
                }

          protected:
                void process_pixel(float *pixel, int xi, int yi, int zi) const
                {
                        float dist = pow((xi - nx/2)/radius_x,2.0f) + pow((yi - ny/2)/radius_y,2.0f) + pow((zi - nz/2)/radius_z,2.0f);
                        if (dist>1.0) (*pixel)*=exp(-pow((sqrt(dist)-1.0f)/gauss_width,2.0f));
                }

                float radius_x,radius_y,radius_z,gauss_width;
        };

        class MaskGaussInvProcessor:public CircularMaskProcessor
        {
          public:
                TypeDict get_param_types() const
                {
                        TypeDict d = CircularMaskProcessor::get_param_types();
                        d.put("gauss_width", EMObject::FLOAT, "Used to calculate the constant factor - gauss_width / (ny*ny)" );
                        d.put("ring_width", EMObject::INT, "The width of the mask ring.");
                        return d;
                }

                string get_name() const
                {
                        return "math.gausskernelfix";
                }

                static Processor *NEW()
                {
                        return new MaskGaussInvProcessor();
                }

                string get_desc() const
                {
                        return "f(x) = f(x) / exp(-radius*radius * gauss_width / (ny*ny))";
                }

          protected:
                void calc_locals(EMData *)
                {
                        float gauss_width = params["gauss_width"];
                        slice_value = gauss_width / (ny * ny);
                }

                void process_dist_pixel(float *pixel, float dist) const
                {
                        (*pixel) /= exp(-dist * slice_value);
                }
          private:
                float slice_value;
        };


        class LinearPyramidProcessor:public Processor
        {
          public:
                string get_name() const
                {
                        return "math.linearpyramid";
                }

                void process_inplace(EMData *image);

                static Processor *NEW()
                {
                        return new LinearPyramidProcessor();
                }

                string get_desc() const
                {
                        return "Multiplies image by a 'linear pyramid', 1-(|x-xsize/2|*|y-ysize/2|*4/(xsize*ysize))";
                }

        };


        class MakeRadiusSquaredProcessor:public CircularMaskProcessor
        {
          public:
                string get_name() const
                {
                        return "math.toradiussqr";
                }
                static Processor *NEW()
                {
                        return new MakeRadiusSquaredProcessor();
                }

                string get_desc() const
                {
                        return "overwrites input, f(x) = radius * radius";
                }

          protected:
                void process_dist_pixel(float *pixel, float dist) const
                {
                        *pixel = dist;
                }
        };

        class MakeRadiusProcessor:public CircularMaskProcessor
        {
          public:
                string get_name() const
                {
                        return "math.toradius";
                }
                static Processor *NEW()
                {
                        return new MakeRadiusProcessor();
                }

                string get_desc() const
                {
                        return "overwrites input, f(x) = radius;";
                }

          protected:
                void process_dist_pixel(float *pixel, float dist) const
                {
                        *pixel = sqrt(dist);
                }
        };

        class ComplexPixelProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                static string get_group_desc()
                {
                        return "The base class for fourier space processor working on individual pixels. ri2ap() is called before processing, so individual pixels will be A/P rather than R/I. The processor won't consider the pixel's coordinates and neighbors.";
                }

          protected:
                virtual void process_pixel(float *x) const = 0;
        };

        class ComplexNormPixel:public ComplexPixelProcessor
        {
          public:
                string get_name() const
                {
                        return "complex.normpixels";
                }
                static Processor *NEW()
                {
                        return new ComplexNormPixel();
                }

                string get_desc() const
                {
                        return "Each Fourier pixel will be normalized. ie - amp=1, phase=unmodified. Useful for performing phase-residual-like computations with dot products.";
                }

          protected:
                void process_pixel(float *x) const
                {
                        *x=1.0;
                }
        };

        class AreaProcessor:public Processor
        {
          public:
                AreaProcessor():areasize(0), kernel(0), nx(0), ny(0), nz(0)
                {
                }

                void process_inplace(EMData * image);

                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        areasize = params["areasize"];
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("areasize", EMObject::INT, "The width of the area to process (not radius)");
                        return d;
                }

                string get_desc() const
                {
                        return "AreaProcessor use pixel values and coordinates of a real-space square area. This is the base class. Specific AreaProcessor needs to implement function create_kernel().";
                }

          protected:
                virtual void process_pixel(float *pixel, float, float, float, float *area_matrix) const
                {
                        for (int i = 0; i < matrix_size; i++)
                        {
                                *pixel += area_matrix[i] * kernel[i];
                        }
                }

                virtual void create_kernel() const = 0;

                int areasize;
                int matrix_size;
                float *kernel;
                int nx;
                int ny;
                int nz;
        };

        class LaplacianProcessor:public AreaProcessor
        {
          public:
                string get_name() const
                {
                        return "math.laplacian";
                }
                static Processor *NEW()
                {
                        return new LaplacianProcessor();
                }

                string get_desc() const
                {
                        return "Discrete approximation to Laplacian. Edge enchancement, but works poorly in the presence of noise. Laplacian processor (x -> d^2/dx^2 + d^2/dy^2 + d^2/dz^2).";
                }

          protected:
                void create_kernel() const;

        };

        class ZeroConstantProcessor:public AreaProcessor
        {
          public:
                string get_name() const
                {
                        return "mask.contract";
                }
                static Processor *NEW()
                {
                        return new ZeroConstantProcessor();
                }

                string get_desc() const
                {
                        return "Contraction of data, if any nearest neighbor is 0, value -> 0, generally used iteratively";
                }

          protected:
                void process_pixel(float *pixel, float, float, float, float *matrix) const
                {
                        if (*pixel != 0)
                        {
                                if (*pixel == matrix[1] || *pixel == matrix[3] || *pixel == matrix[5] ||
                                        *pixel == matrix[7] || matrix[1] == 0 || matrix[3] == 0 ||
                                        matrix[5] == 0 || matrix[7] == 0) {
                                        *pixel = 0;
                                }
                        }
                }

                void create_kernel() const
                {
                }
        };

        class BoxStatProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                static string get_group_desc()
                {
                        return "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).";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("radius", EMObject::INT, "The radius of the search box, default is 1 which results in a 3x3 box (3 = 2xradius + 1)");
                        return d;
                }

          protected:
                virtual void process_pixel(float *pixel, const float *array, int n) const = 0;
        };


        class BoxMedianProcessor:public BoxStatProcessor
        {
          public:
                string get_name() const
                {
                        return "eman1.filter.median";
                }
                static Processor *NEW()
                {
                        return new BoxMedianProcessor();
                }

                string get_desc() const
                {
                        return "A processor for noise reduction. pixel = median of values surrounding pixel.";
                }


          protected:
                void process_pixel(float *pixel, const float *array, int n) const
                {
                        float *data = new float[n];
                        memcpy(data, array, sizeof(float) * n);

                        for (int i = 0; i <= n / 2; i++)
                        {
                                for (int j = i + 1; j < n; j++)
                                {
                                        if (data[i] < data[j]) {
                                                float t = data[i];
                                                data[i] = data[j];
                                                data[j] = t;
                                        }
                                }
                        }

                        if (n % 2 != 0)
                        {
                                *pixel = data[n / 2];
                        }
                        else {
                                *pixel = (data[n / 2] + data[n / 2 - 1]) / 2;
                        }
                        if( data )
                        {
                                delete[]data;
                                data = 0;
                        }
                }
        };

        class BoxSigmaProcessor:public BoxStatProcessor
        {
          public:
                string get_name() const
                {
                        return "math.localsigma";
                }
                static Processor *NEW()
                {
                        return new BoxSigmaProcessor();
                }

                string get_desc() const
                {
                        return "pixel = standard deviation of values surrounding pixel.";
                }

          protected:
                void process_pixel(float *pixel, const float *data, int n) const
                {
                        float sum = 0;
                        float square_sum = 0;
                        for (int i = 0; i < n; i++)
                        {
                                sum += data[i];
                                square_sum += data[i] * data[i];
                        }

                        float mean = sum / n;
                        *pixel = sqrt(square_sum / n - mean * mean);
                }
        };

        class BoxMaxProcessor:public BoxStatProcessor
        {
          public:
                string get_name() const
                {
                        return "math.localmax";
                }
                static Processor *NEW()
                {
                        return new BoxMaxProcessor();
                }

                string get_desc() const
                {
                        return "peak processor: pixel = max of values surrounding pixel.";
                }

          protected:
                void process_pixel(float *pixel, const float *data, int n) const
                {
                        float maxval = -FLT_MAX;
                        for (int i = 0; i < n; i++)
                        {
                                if (data[i] > maxval) {
                                        maxval = data[i];
                                }
                        }
                         *pixel = maxval;
                }
        };

        class MinusPeakProcessor:public BoxStatProcessor
        {
          public:
                string get_name() const
                {
                        return "math.submax";
                }
                static Processor *NEW()
                {
                        return new MinusPeakProcessor();
                }

                string get_desc() const
                {
                        return "peak processor: pixel = pixel - max of values surrounding pixel. This is a sort of positive peak-finding algorithm.";
                }

          protected:
                void process_pixel(float *pixel, const float *data, int n) const
                {
                        float maxval = -FLT_MAX;
                        for (int i = 0; i < n; i++)
                        {
                                if (data[i] > maxval) {
                                        maxval = data[i];
                                }
                        }
                         *pixel -= maxval;
                }
        };

        class PeakOnlyProcessor:public BoxStatProcessor
        {
          public:
                string get_name() const
                {
                        return "mask.onlypeaks";
                }
                static Processor *NEW()
                {
                        return new PeakOnlyProcessor();
                }
                void set_params(const Dict & new_params)
                {
                        params = new_params;
                        npeaks = params["npeaks"];
                        if (npeaks == 0) {
                                npeaks = 1;
                        }
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("npeaks", EMObject::INT, "the number of surrounding peaks allow to >= pixel values");
                        return d;
                }

                string get_desc() const
                {
                        return "peak processor -> if npeaks or more surrounding values >= value, value->0";
                }

          protected:
                void process_pixel(float *pixel, const float *data, int n) const
                {
                        int r = 0;

                        for (int i = 0; i < n; i++)
                        {
                                if (data[i] >= *pixel) {
                                        r++;
                                }
                        }

                        if (r > npeaks)
                        {
                                *pixel = 0;
                        }
                }
          private:
                int npeaks;
        };

        class DiffBlockProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "eman1.filter.blockrange";
                }
                static Processor *NEW()
                {
                        return new DiffBlockProcessor();
                }

                string get_desc() const
                {
                        return "averages over cal_half_width, then sets the value in a local block";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("cal_half_width", EMObject::FLOAT, "cal_half_width is dx/dy for calculating an average");
                        d.put("fill_half_width", EMObject::FLOAT, "fill_half_width is dx/dy for fill/step");
                        return d;
                }
        };

        class CutoffBlockProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "eman1.filter.blockcutoff";
                }
                static Processor *NEW()
                {
                        return new CutoffBlockProcessor();
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("value1", EMObject::FLOAT, "val1 is dx/dy");
                        d.put("value2", EMObject::FLOAT, "val2 is lowpass freq cutoff in pixels");
                        return d;
                }

                string get_desc() const
                {
                        return "Block processor, val1 is dx/dy, val2 is lp freq cutoff in pixels. Mystery processor.";
                }

        };

        class BooleanShrinkProcessor
        {
                protected:
                        template<class LogicOp>
                        EMData* process(const EMData *const image, Dict& params);

                        template<class LogicOp>
                        void process_inplace(EMData * image, Dict& params);

        };

        class MaxShrinkProcessor:public BooleanShrinkProcessor, public Processor
        {
                public:
                        virtual EMData* process(const EMData *const image)
                        {
                                return BooleanShrinkProcessor::process<GreaterThan>(image, params);
                        }

                        // resizes the image
                        virtual void process_inplace(EMData * image)
                        {
                                BooleanShrinkProcessor::process_inplace<GreaterThan>(image, params);
                        }

                        string get_desc() const
                        {
                                return "Shrink an image by a given amount (default 2), using the maximum value found in the pixel neighborhood.";
                        }

                        string get_name() const
                        {
                                return "math.maxshrink";
                        }
                        static Processor *NEW()
                        {
                                return new MaxShrinkProcessor();
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("n", EMObject::INT, "The shrink factor");
                                d.put("search", EMObject::INT, "The search area (cubic volume width, usually the same as shrink)");
                                return d;
                        }

                private:
                        struct GreaterThan
                        {
                                inline bool operator()(float left,float right) const { return left > right; }
                                inline float get_start_val() { return -10000000; }
                        };
        };

        class MinShrinkProcessor:public BooleanShrinkProcessor, public Processor
        {
                public:
                        virtual EMData* process(const EMData *const image)
                        {
                                return BooleanShrinkProcessor::process<LessThan>(image, params);
                        }

                        // resizes the image
                        virtual void process_inplace(EMData * image)
                        {
                                BooleanShrinkProcessor::process_inplace<LessThan>(image, params);
                        }
                        string get_desc() const
                        {
                                return "Shrink an image by a given amount (default 2), using the minimum value found in the pixel neighborhood.";
                        }

                        string get_name() const
                        {
                                return "math.minshrink";
                        }
                        static Processor *NEW()
                        {
                                return new MinShrinkProcessor();
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("n", EMObject::INT, "The shrink factor");
                                d.put("search", EMObject::INT, "The search area (cubic volume width, usually the same as shrink)");
                                return d;
                        }

                private:
                struct LessThan
                {
                        inline bool operator()(float left,float right) const { return left < right; }
                        inline float get_start_val() { return 9999999999.0f; }
                };
        };

        class MeanShrinkProcessor : public Processor
        {
                public:
                        virtual EMData* process(const EMData *const image);

                        virtual void process_inplace(EMData * image);

                        string get_desc() const
                        {
                                return "Shrink an image by a given amount , using the mean value found in the pixel neighborhood.";
                        }

                        virtual string get_name() const
                        {
                                return "math.meanshrink";
                        }
                        static Processor *NEW()
                        {
                                return new MeanShrinkProcessor();
                        }

                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("n", EMObject::FLOAT, "The shrink factor");
                                return d;
                        }
                private:
                        void accrue_mean(EMData* to, const EMData *const from, const int shrinkfactor);

                        void accrue_mean_one_p_five(EMData* to, const EMData * const from);
        };


        class MedianShrinkProcessor : public Processor
        {
        public:
                virtual EMData* process(const EMData *const image);

                virtual void process_inplace(EMData * image);

                string get_desc() const
                {
                        return "Shrink an image by a given amount , using the median value found in the pixel neighborhood.";
                }

                virtual string get_name() const
                {
                        return "math.medianshrink";
                }
                static Processor *NEW()
                {
                        return new MedianShrinkProcessor();
                }

                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("n", EMObject::INT, "The shrink factor");
                        return d;
                }
        private:
                void accrue_median(EMData* to, const EMData* const from,const int shrink_factor);
        };


        class FFTResampleProcessor : public Processor
        {
                public:
                        virtual EMData* process(const EMData *const image);

                        virtual void process_inplace(EMData * image);

                        string get_desc() const
                        {
                                return "Robust resampling of an image by clipping its Fourier transform.";
                        }

                        string get_name() const
                        {
                                return "math.fft.resample";
                        }
                        static Processor *NEW()
                        {
                                return new FFTResampleProcessor();
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("n", EMObject::FLOAT, "The sample rate. Less than one enlarges the image, greater than one shrinks it.");
                                return d;
                        }
                private:
                        void fft_resample(EMData* to, const EMData *const from, const float& sample_rate);

        };

        class GradientRemoverProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "math.lineargradientfix";
                }
                static Processor *NEW()
                {
                        return new GradientRemoverProcessor();
                }

                string get_desc() const
                {
                        return "Gradient remover, does a rough plane fit to find linear gradients.";
                }

        };

        class GradientPlaneRemoverProcessor:public Processor
    {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "filter.gradientPlaneRemover";
                }
                static Processor *NEW()
                {
                        return new GradientPlaneRemoverProcessor();
                }

                string get_desc() const
                {
                        return "Remove gradient by least square plane fit";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("mask", EMObject::EMDATA, "mask object: nonzero pixel positions will be used to fit plane. default = 0");
                        d.put("changeZero", EMObject::INT, "if zero pixels are modified when removing gradient. default = 0");
                        d.put("planeParam", EMObject::FLOATARRAY, "fitted plane parameters output");
                        return d;
                }
        };


        class FlattenBackgroundProcessor:public Processor
        {
                public:
                        void process_inplace(EMData * image);

                        string get_name() const
                        {
                                return "filter.flattenbackground";
                        }

                        static Processor *NEW()
                        {
                                return new FlattenBackgroundProcessor();
                        }

                        string get_desc() const
                        {
                                return "Flattens the background by subtracting the local mean";
                        }

                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("mask", EMObject::EMDATA, "A mask the defines the local neighborhood that will be used to find the local mean. Exclusive of the radius argument");
                                d.put("radius", EMObject::INT, "The radius of circle/sphere that defines the local neighborhood. Exclusive of the mask argument");
                                return d;
                        }
        };


        class RampProcessor:public Processor
    {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "filter.ramp";
                }
                static Processor *NEW()
                {
                        return new RampProcessor();
                }

                string get_desc() const
                {
                        return "Ramp processor -- Fits a least-squares plane "
                                   "to the picture, and subtracts the plane from "
                                   "the picture.  A wedge-shaped overall density "
                                   "profile can thus be removed from the picture.";
                }

        };

        class VerticalStripeProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "math.verticalstripefix";
                }

                static Processor *NEW()
                {
                        return new VerticalStripeProcessor();
                }

                string get_desc() const
                {
                        return "Tries to fix images scanned on the zeiss for poor ccd normalization.";
                }

        };

        class RealToFFTProcessor:public Processor
        {
                public:
                void process_inplace(EMData *image);

                string get_name() const
                {
                        return "math.realtofft";
                }

                static Processor *NEW()
                {
                        return new RealToFFTProcessor();
                }

                string get_desc() const
                {
                        return "This will replace the image with a full-circle 2D fft amplitude rendering. Note that this renders amplitude, when intensity is more common.";
                }

        };


        class SigmaZeroEdgeProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "mask.zeroedgefill";
                }
                static Processor *NEW()
                {
                        return new SigmaZeroEdgeProcessor();
                }

                string get_desc() const
                {
                        return "Fill zeroes at edges with nearest horizontal/vertical value.";
                }

        };

        class BeamstopProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "mask.beamstop";
                }

                static Processor *NEW()
                {
                        return new BeamstopProcessor();
                }

                string get_desc() const
                {
                        return "Try to eliminate beamstop in electron diffraction patterns. value1=sig multiplier; value2,value3 are x,y of center, if value1<0 also does radial subtract.";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("value1", EMObject::FLOAT, "sig multiplier");
                        d.put("value2", EMObject::FLOAT, "x of center");
                        d.put("value3", EMObject::FLOAT, "y of center");
                        return d;
                }
        };

        class MeanZeroEdgeProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "mask.dampedzeroedgefill";
                }

                static Processor *NEW()
                {
                        return new MeanZeroEdgeProcessor();
                }

                string get_desc() const
                {
                        return "Fill zeroes at edges with nearest horizontal/vertical value damped towards Mean2.";
                }

        };


        class AverageXProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);

                string get_name() const
                {
                        return "math.averageovery";
                }

                static Processor *NEW()
                {
                        return new AverageXProcessor();
                }

                string get_desc() const
                {
                        return "Average along Y and replace with average";
                }

        };

        class DecayEdgeProcessor:public Processor
        {
          public:
                void process_inplace(EMData * image);
                string get_name() const
                {
                        return "mask.decayedge2d";
                }

                static Processor *NEW()
                {
                        return new DecayEdgeProcessor();
                }

                string get_desc() const
                {
                        return "Decay edges of image to zero";
                }

                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("width", EMObject::INT, "Width of the decay region around the edge of the image in pixels");
                        return d;
                }
        };

        class ZeroEdgeRowProcessor:public Processor
        {