aligner.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
 * 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__aligner_h__
#define eman__aligner_h__ 1
 
 
#include "emobject.h"
 
 
namespace EMAN
{
        class EMData;
        class Cmp;
 
        class Aligner
        {
          public:
                virtual ~ Aligner()
                {
                }
 
                virtual EMData *align(EMData * this_img, EMData * to_img) const = 0;
 
                virtual EMData *align(EMData * this_img, EMData * to_img,
                                                          const string & cmp_name, const Dict& cmp_params) const = 0;
 
                virtual string get_name() const = 0;
 
                virtual string get_desc() 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 = 0;
 
                virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
//              {
//                      vector<Dict> solns;
//                      return solns;
//              }
 
          protected:
                mutable Dict params;
 
//              /** Get a Transform pointer that is currently stored in the image header corresponding to the given key.
//               * If non existant then initialize a new Transform pointer, set it as the image attribute, and return it.
//               * The point being that if you have to access the xform.align2d or the xform.align3d
//               * attributes from multiple aligners then you always want to get the same one.
//               * @param key the alignment key such as "xform.align2d" or "xform.align3d"
//               * @param image the image from which the Transform pointer will be extracted (and potentially assigned to if non existant)
//               * @return the Transform pointer that is currently stored in the image header corresponding to the given key.
//               */
//              static Transform* get_align_attr(const string& key, EMData* const image );
//
//              static Transform* get_set_align_attr(const string& key, EMData* const to_image, const EMData* const from_image  );
        };
 
        class ScaleAlignerABS:public Aligner
        {
          public:
                 ScaleAlignerABS(const string& ba) : basealigner(ba)
                 {
                 }
 
                 EMData* align_using_base(EMData * this_img, EMData * to_img,
                                                const string & cmp_name = "dot", const Dict& cmp_params = Dict()) const;
 
          protected:
                const string basealigner;
                Dict basealigner_params;
 
        };
 
        class ScaleAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name = "dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs real space scale alignment";
                }
 
                static Aligner *NEW()
                {
                        return new ScaleAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("min", EMObject::FLOAT, "Minimum scaling (default: 0.95)");
                        d.put("max", EMObject::FLOAT, "Maximum scaling (default: 1.05)");
                        d.put("step", EMObject::FLOAT, "Scaling step (default: 0.01)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class TranslationalAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Translational 2D and 3D alignment by cross-correlation";
                }
 
                static Aligner *NEW()
                {
                        return new TranslationalAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("intonly", EMObject::INT,"Integer pixel translations only");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF");
                        d.put("maxshift", EMObject::INT,"Maximum translation in pixels");
                        d.put("masked", EMObject::INT,"Treat zero pixels in 'this' as a mask for normalization (default false)");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotationalAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name = "dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment, even on poorly centered images, but leaves a 180 degree ambiguity which requires a translational alignment to resolve. Usually called internally by rotate_translate aligner.";
                }
 
                static Aligner *NEW()
                {
                        return new RotationalAligner();
                }
 
                static EMData * align_180_ambiguous(EMData * this_img, EMData * to_img, int rfp_mode = 2,int zscore=0);
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print. O is the original eman1 way. 1 is just using calc_ccf without padding. 2 is using calc_mutual_correlation without padding.");
                        d.put("zscore", EMObject::INT,"Either 0 or 1. If set, will convert per-radius CCF curves into Z-score significnace curves before averaging. In theory this should produce better results by focusing on radii with more alignment information. (default=false)");
                        d.put("ambig180", EMObject::INT,"Either 0 or 1. If set, will not try and resolve the 180 degree ambiguity. If not set, it will assume the particle is well centered and resolve the ambiguity that way. default=false");
                        d.put("maxshift", EMObject::INT,"This is provided for compatibility with other aligners. It does absolutely nothing here, as there is an implicit maxshift=0.");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotationalAlignerBispec:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name = "dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment using bispectral invariants";
                }
 
                static Aligner *NEW()
                {
                        return new RotationalAlignerBispec();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("maxshift", EMObject::INT,"This is provided for compatibility with other aligners. It does absolutely nothing here, as there is an implicit maxshift=0.");
                        d.put("size", EMObject::INT,"Passed as the size parameter to the bispectrum calculation");
                        d.put("rfpn", EMObject::INT,"Passed as the rfp parameter to the bispectrum calculation");
                        d.put("harmonic", EMObject::INT,"If set, uses harmonic power instead of bispectra");
                        return d;
                }
 
                static const string NAME;
        };
 
        
        class RotationalAlignerIterative:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name = "dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment using the SPIDER method of iterating between rotational and translational alingment in real-space";
                }
 
                static Aligner *NEW()
                {
                        return new RotationalAlignerIterative();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotatePrecenterAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name = "dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and works accurately if the image is precentered";
                }
 
                static Aligner *NEW()
                {
                        return new RotatePrecenterAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateAligner:public Aligner
        {
          public:
                  virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and follows this with translational alignment.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        //d.put("usedot", EMObject::INT);
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
                        d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        d.put("zscore", EMObject::INT,"Either 0 or 1. This option is passed directly to the rotational aligner (default=false)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateAlignerBispec:public Aligner
        {
          public:
                  virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational and translational alignment using bispectral invariants.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateAlignerBispec();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        //d.put("usedot", EMObject::INT);
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
//                      d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        d.put("size", EMObject::INT,"Passed as the size parameter to the bispectrum calculation");
                        d.put("rfpn", EMObject::INT,"Passed as the rfp parameter to the bispectrum calculation");
                        d.put("harmonic", EMObject::INT,"If set, uses harmonic power instead of bispectra");
                        
//                      d.put("zscore", EMObject::INT,"Either 0 or 1. This option is passed directly to the rotational aligner (default=false)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateScaleAligner:public ScaleAlignerABS
        {
          public:
 
                //Set the type of base aligner
                RotateTranslateScaleAligner() : ScaleAlignerABS("rotate_translate")
                {
                }
 
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and follows this with translational and then scaling alignment.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateScaleAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("min", EMObject::FLOAT, "Minimum scaling (default: 0.95)");
                        d.put("max", EMObject::FLOAT, "Maximum scaling (default: 1.05)");
                        d.put("step", EMObject::FLOAT, "Scaling step (default: 0.01)");
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
                        d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        d.put("zscore", EMObject::INT,"Either 0 or 1. This option is passed directly to the rotational aligner (default=false)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateAlignerIterative:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and follows this with translational alignment using the iterative method.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateAlignerIterative();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        d.put("maxiter", EMObject::INT, "Maximum number of iterations");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateScaleAlignerIterative:public ScaleAlignerABS
        {
          public:
                //Set the type of base aligner
                RotateTranslateScaleAlignerIterative() : ScaleAlignerABS("rotate_translate_iterative")
                {
                }
 
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and follows this with translational alignment using the iterative method. Does this for each scale and returns the best";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateScaleAlignerIterative();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("min", EMObject::FLOAT, "Minimum scaling (default: 0.95)");
                        d.put("max", EMObject::FLOAT, "Maximum scaling (default: 1.05)");
                        d.put("step", EMObject::FLOAT, "Scaling step (default: 0.01)");
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        d.put("maxiter", EMObject::INT, "Maximum number of iterations");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateAlignerPawel:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and translation align by resampling to polar coordinates in real space.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateAlignerPawel();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        //d.put("usedot", EMObject::INT);
                        d.put("tx", EMObject::INT, "Maximum x translation in pixels, Default = 0");
                        d.put("ty", EMObject::INT, "Maximum y translation in pixels, Default = 0");
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateBestAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "frc", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Full 2D alignment using 'Rotational' and 'Translational', also incorporates 2D 'Refine' alignments.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateBestAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("snr", EMObject::FLOATARRAY, "signal to noise ratio array");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateFlipAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs two rotational alignments, one using the original image and one using the hand-flipped image. Decides which alignment is better using a comparitor and returns it";
                }
 
                static Aligner *NEW()
                {
                        return new RotateFlipAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        return static_get_param_types();
                }
 
                static TypeDict static_get_param_types() {
                        TypeDict d;
 
                        d.put("imask", EMObject::INT);
                        d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateFlipAlignerIterative:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "dot", Dict());
                }
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs two rotational alignments, iterative style, one using the original image and one using the hand-flipped image. Decides which alignment is better using a comparitor and returns it";
                }
 
                static Aligner *NEW()
                {
                        return new RotateFlipAlignerIterative();
                }
 
                virtual TypeDict get_param_types() const
                {
                        return static_get_param_types();
                }
 
                static TypeDict static_get_param_types() {
                        TypeDict d;
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateFlipAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return " Does two 'rotate_translate' alignments, one to accommodate for possible handedness change. Decided which alignment is better using a comparitor and returns the aligned image as the solution";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateFlipAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        return static_get_param_types();
                }
 
                static TypeDict static_get_param_types() {
                        TypeDict d;
 
                        d.put("flip", EMObject::EMDATA);
                        d.put("usedot", EMObject::INT);
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print");
                        d.put("usebispec", EMObject::INT,"Uses rotate_translate_bispec for subalignments and ignore rfp_mode.");
                        d.put("useharmonic", EMObject::INT,"Uses rotate_translate_bispec in harmonic mode for alignments and ignores rfp_mode.");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        d.put("zscore", EMObject::INT,"Either 0 or 1. This option is passed directly to the rotational aligner (default=false)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateFlipScaleAligner:public ScaleAlignerABS
        {
          public:
                //Set the type of base aligner
                RotateTranslateFlipScaleAligner() : ScaleAlignerABS("rotate_translate_flip")
                {
                }
 
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and follows this with translational and then scaling alignment.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateFlipScaleAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("min", EMObject::FLOAT, "Minimum scaling (default: 0.95)");
                        d.put("max", EMObject::FLOAT, "Maximum scaling (default: 1.05)");
                        d.put("step", EMObject::FLOAT, "Scaling step (default: 0.01)");
                        d.put("flip", EMObject::EMDATA);
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("nozero", EMObject::INT,"Zero translation not permitted (useful for CCD images)");
                        d.put("rfp_mode", EMObject::INT,"Either 0,1 or 2. A temporary flag for testing the rotational foot print");
                        d.put("useflcf", EMObject::INT,"Use Fast Local Correlation Function rather than CCF for translational alignment");
                        d.put("zscore", EMObject::INT,"Either 0 or 1. This option is passed directly to the rotational aligner (default=false)");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateFlipAlignerIterative:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return " Does two 'rotate_translate.iterative' alignments, one to accommodate for possible handedness change. Decided which alignment is better using a comparitor and returns the aligned image as the solution";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateFlipAlignerIterative();
                }
 
                virtual TypeDict get_param_types() const
                {
                        return static_get_param_types();
                }
 
                static TypeDict static_get_param_types() {
                        TypeDict d;
                        d.put("flip", EMObject::EMDATA);
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        d.put("maxiter", EMObject::INT, "Maximum number of iterations");
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateFlipScaleAlignerIterative:public ScaleAlignerABS
        {
          public:
                //Set the type of base aligner
                RotateTranslateFlipScaleAlignerIterative() : ScaleAlignerABS("rotate_translate_flip_iterative")
                {
                }
 
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment and follows this with translational alignment using the iterative method. Does this for each scale and returns the best";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateFlipScaleAlignerIterative();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("min", EMObject::FLOAT, "Minimum scaling (default: 0.95)");
                        d.put("max", EMObject::FLOAT, "Maximum scaling (default: 1.05)");
                        d.put("step", EMObject::FLOAT, "Scaling step (default: 0.01)");
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        d.put("flip", EMObject::EMDATA);
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        d.put("maxiter", EMObject::INT, "Maximum number of iterations");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RotateTranslateFlipAlignerPawel:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Performs rotational alignment, translation align, and flip by resampling to polar coordinates in real space.";
                }
 
                static Aligner *NEW()
                {
                        return new RotateTranslateFlipAlignerPawel();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        //d.put("usedot", EMObject::INT);
                        d.put("tx", EMObject::INT, "Maximum x translation in pixels, Default = 0");
                        d.put("ty", EMObject::INT, "Maximum y translation in pixels, Default = 0");
                        d.put("r1", EMObject::INT, "Inner ring, pixels");
                        d.put("r2", EMObject::INT, "Outer ring, pixels");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RTFExhaustiveAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Experimental full 2D alignment with handedness check using semi-exhaustive search (not necessarily better than RTFBest)";
                }
 
                static Aligner *NEW()
                {
                        return new RTFExhaustiveAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
 
                        d.put("flip", EMObject::EMDATA);
                        d.put("maxshift", EMObject::INT, "Maximum translation in pixels");
                        return d;
                }
 
                static const string NAME;
        };
 
        class RTFSlowExhaustiveAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                                const string & cmp_name, const Dict& cmp_params) const;
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Experimental full 2D alignment with handedness check using more exhaustive search (not necessarily better than RTFBest)";
                }
 
                static Aligner *NEW()
                {
                        return new RTFSlowExhaustiveAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("flip", EMObject::EMDATA,"Optional. This is the flipped version of the images that is being aligned. If specified it will be used for the handedness check, if not a flipped copy of the image will be made");
                        d.put("maxshift", EMObject::INT,"The maximum length of the detectable translational shift");
                        d.put("transtep", EMObject::FLOAT,"The translation step to take when honing the alignment, which occurs after coarse alignment");
                        d.put("angstep", EMObject::FLOAT,"The angular step (in degrees) to take in the exhaustive search for the solution angle. Typically very small i.e. 3 or smaller.");
                        return d;
                }
 
                static const string NAME;
        };
 
        class SymAlignProcessor:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img, const string & cmp_name="ccc", const Dict& cmp_params = Dict()) const;
 
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "ccc", Dict());
                        }
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        static Aligner *NEW()
                        {
                                return new SymAlignProcessor();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("sym", EMObject::STRING, "The symmetry under which to do the alignment, Default=c1" );
                                d.put("delta", EMObject::FLOAT,"Angle the separates points on the sphere. This is exclusive of the \'n\' paramater. Default is 10");
                                d.put("dphi", EMObject::FLOAT,"The angle increment in the phi direction. Default is 10");
                                d.put("lphi", EMObject::FLOAT,"Lower bound for phi. Default it 0");
                                d.put("uphi", EMObject::FLOAT,"Upper bound for phi. Default it 359.9");
                                d.put("avger", EMObject::STRING, "The sort of averager to use, Default=mean" );
                                return d;
                        }
 
                        virtual string get_desc() const
                        {
                                return "The image is centered and rotated to the standard orientation for the specified symmetry";
                        }
 
                        static const string NAME;
 
        };
 
        class RefineAligner:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Refines a preliminary 2D alignment using a simplex algorithm. Subpixel precision.";
                }
 
                static Aligner *NEW()
                {
                        return new RefineAligner();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
 
                        d.put("mode", EMObject::INT, "Currently unused");
                        d.put("xform.align2d", EMObject::TRANSFORM, "The Transform storing the starting guess. If unspecified the identity matrix is used");
                        d.put("stepx", EMObject::FLOAT, "The x increment used to create the starting simplex. Default is 1");
                        d.put("stepy", EMObject::FLOAT, "The y increment used to create the starting simplex. Default is 1");
                        d.put("stepaz", EMObject::FLOAT, "The rotational increment used to create the starting simplex. Default is 5");
                        d.put("precision", EMObject::FLOAT, "The precision which, if achieved, can stop the iterative refinement before reaching the maximum iterations. Default is 0.04.");
                        d.put("maxiter", EMObject::INT,"The maximum number of iterations that can be performed by the Simplex minimizer. default=28");
                        d.put("maxshift", EMObject::INT,"Maximum translation in pixels in any direction. If the solution yields a shift beyond this value in any direction, then the refinement is judged a failure and the original alignment is used as the solution.");
                        d.put("stepscale", EMObject::FLOAT, "If set to any non-zero value, scale will be included in the alignment, and this will be the initial step. Images should be edgenormalized. If the scale goes beyond +-30% alignment will fail.");
                        d.put("mask", EMObject::EMDATA, "A mask to be applied to the image being aligned prior to each similarity comparison.");
                        d.put("verbose", EMObject::INT, "This will cause debugging information to be printed on the screen for the iterative refinement. Larger numbers -> more info. default=0");
                        return d;
                }
 
                static const string NAME;
        };
 
 
        class RefineAlignerCG:public Aligner
        {
          public:
                virtual EMData * align(EMData * this_img, EMData * to_img,
                                           const string & cmp_name="dot", const Dict& cmp_params = Dict()) const;
 
                virtual EMData * align(EMData * this_img, EMData * to_img) const
                {
                        return align(this_img, to_img, "sqeuclidean", Dict());
                }
 
                virtual string get_name() const
                {
                        return NAME;
                }
 
                virtual string get_desc() const
                {
                        return "Refines a preliminary 2D alignment using a simplex algorithm. Subpixel precision.";
                }
 
                static Aligner *NEW()
                {
                        return new RefineAlignerCG();
                }
 
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
 
                        d.put("mode", EMObject::INT, "Currently unused");
                        d.put("xform.align2d", EMObject::TRANSFORM, "The Transform storing the starting guess. If unspecified the identity matrix is used");
                        d.put("step", EMObject::FLOAT, "The x increment used to create the starting simplex. Default is 0.1");
                        d.put("precision", EMObject::FLOAT, "The precision which, if achieved, can stop the iterative refinement before reaching the maximum iterations. Default is 0.02.");
                        d.put("maxiter", EMObject::INT,"The maximum number of iterations that can be performed by the Simplex minimizer. default=12");
                        d.put("maxshift", EMObject::INT,"Maximum translation in pixels in any direction. If the solution yields a shift beyond this value in any direction, then the refinement is judged a failure and the original alignment is used as the solution.");
                        d.put("stepscale", EMObject::FLOAT, "If set to any non-zero value, scale will be included in the alignment. Images should be edgenormalized. If the scale goes beyond +-30% alignment will fail.");
                        d.put("mask", EMObject::EMDATA, "A mask to be applied to the image being aligned prior to each similarity comparison.");
                        d.put("verbose", EMObject::INT, "This will cause debugging information to be printed on the screen for the iterative refinement. Larger numbers -> more info. default=0");
                        return d;
                }
 
                static const string NAME;
        };
 
        class SymAlignProcessorQuat : public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                   const string & cmp_name="ccc", const Dict& cmp_params = Dict()) const;
 
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "ccc", Dict());
                        }
 
                virtual string get_name() const
                {
                        return NAME;
                }
                static Aligner *NEW()
                {
                        return new SymAlignProcessorQuat();
                }
                string get_desc() const
                {
                        return "Finds the symmetry axis using the simplex algorithm.";
                }
                virtual TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("sym", EMObject::STRING, "The symmettry. Default is c1");
                        d.put("xform.align3d", EMObject::TRANSFORM, "The initial guess for to align the particel to sym axis");
                        d.put("stepx", EMObject::FLOAT, "The initial simplex step size in x. Default is 1");
                        d.put("stepy", EMObject::FLOAT, "The initial simplex step size in y. Default is 1");
                        d.put("stepz", EMObject::FLOAT, "The initial simplex step size in z. Default is 1." );
                        d.put("stepn0", EMObject::FLOAT, "The initial simplex step size in the first quaternion vecotr component. Default is 1." );
                        d.put("stepn1", EMObject::FLOAT, "The initial simplex step size in the second quaternion vecotr component. Default is 1." );
                        d.put("stepn2", EMObject::FLOAT, "The initial simplex step size in the third quaternion vecotr component. Default is 1." );
                        d.put("spin_coeff", EMObject::FLOAT,"The multiplier appied to the spin (if it is too small or too large the simplex will not converge).  Default is 10.");
                        d.put("precision", EMObject::FLOAT, "The precision which, if achieved, can stop the iterative refinement before reaching the maximum iterations. Default is 0.01." );
                        d.put("maxiter", EMObject::INT, "The maximum number of iterations that can be performed by the Simplex minimizer. Default is 100.");
                        d.put("maxshift", EMObject::INT,"Maximum translation in pixels in any direction. If the solution yields a shift beyond this value in any direction, then the refinement is judged a failure and the original alignment is used as the solution.");
                        return d;
                }
                static const string NAME;
        };
 
        class Refine3DAlignerGrid:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                   const string & cmp_name="sqeuclidean", const Dict& cmp_params = Dict()) const;
 
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "Refines a preliminary 3D alignment using a simplex algorithm. Subpixel precision.";
                        }
 
                        static Aligner *NEW()
                        {
                                return new Refine3DAlignerGrid();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("xform.align3d", EMObject::TRANSFORM,"The Transform storing the starting guess. If unspecified the identity matrix is used");
                                d.put("delta", EMObject::FLOAT, "The angular step size. Default is 1." );
                                d.put("range", EMObject::FLOAT, "The angular range size. Default is 10." );
                                d.put("dotrans", EMObject::BOOL,"Do a translational search. Default is True(1)");
                                d.put("search", EMObject::INT,"The maximum length of the detectable translational shift - if you supply this parameter you can not supply the maxshiftx, maxshifty or maxshiftz parameters. Each approach is mutually exclusive.");
                                d.put("searchx", EMObject::INT,"The maximum length of the detectable translational shift in the x direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchy", EMObject::INT,"The maximum length of the detectable translational shift in the y direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchz", EMObject::INT,"The maximum length of the detectable translational shift in the z direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }
 
                        static const string NAME;
        };
 
        class Refine3DAlignerQuaternion:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                   const string & cmp_name="sqeuclidean", const Dict& cmp_params = Dict()) const;
 
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "Refines a preliminary 3D alignment using a simplex algorithm. Subpixel precision.";
                        }
 
                        static Aligner *NEW()
                        {
                                return new Refine3DAlignerQuaternion();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("xform.align3d", EMObject::TRANSFORM,"The Transform storing the starting guess. If unspecified the identity matrix is used");
                                d.put("stepx", EMObject::FLOAT, "The initial simplex step size in x. Default is 1");
                                d.put("stepy", EMObject::FLOAT, "The initial simplex step size in y. Default is 1");
                                d.put("stepz", EMObject::FLOAT, "The initial simplex step size in z. Default is 1." );
                                d.put("stepn0", EMObject::FLOAT, "The initial simplex step size in the first quaternion vecotr component. Default is 1." );
                                d.put("stepn1", EMObject::FLOAT, "The initial simplex step size in the second quaternion vecotr component. Default is 1." );
                                d.put("stepn2", EMObject::FLOAT, "The initial simplex step size in the third quaternion vecotr component. Default is 1." );
                                d.put("spin_coeff", EMObject::FLOAT,"The multiplier appied to the spin (if it is too small or too large the simplex will not converge).  Default is 10.");
                                d.put("precision", EMObject::FLOAT, "The precision which, if achieved, can stop the iterative refinement before reaching the maximum iterations. Default is 0.01." );
                                d.put("maxiter", EMObject::INT, "The maximum number of iterations that can be performed by the Simplex minimizer. Default is 100.");
                                d.put("maxshift", EMObject::INT,"Maximum translation in pixels in any direction. If the solution yields a shift beyond this value in any direction, then the refinement is judged a failure and the original alignment is used as the solution.");
                                return d;
                        }
 
                        static const string NAME;
        };
 
        class RT3DGridAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                   const string & cmp_name="ccc.tomo", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "ccc.tomo", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "3D rotational and translational alignment using specified ranges and maximum shifts";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT3DGridAligner();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("daz", EMObject::FLOAT,"The angle increment in the azimuth direction. Default is 10");
                                d.put("az0", EMObject::FLOAT,"Lower bound for the azimuth direction. Default it 0");
                                d.put("az1", EMObject::FLOAT,"Upper bound for the azimuth direction. Default it 180.0");
                                d.put("dphi", EMObject::FLOAT,"The angle increment in the phi direction. Default is 10");
                                d.put("phi0", EMObject::FLOAT,"Lower bound for the phi direction. Default it 0");
                                d.put("phi1", EMObject::FLOAT,"Upper bound for the phi direction. Default it 360.0");
                                d.put("dalt", EMObject::FLOAT,"The angle increment in the altitude direction. Default is 10");
                                d.put("alt0", EMObject::FLOAT,"Lower bound for the altitude direction. Default it 0");
                                d.put("alt1", EMObject::FLOAT,"Upper bound for the altitude direction. Default it 360.0");
                                d.put("dotrans", EMObject::BOOL,"Do a translational search. Default is True(1)");
                                d.put("search", EMObject::INT,"The maximum length of the detectable translational shift - if you supply this parameter you can not supply the maxshiftx, maxshifty or maxshiftz parameters. Each approach is mutually exclusive.");
                                d.put("searchx", EMObject::INT,"The maximum length of the detectable translational shift in the x direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchy", EMObject::INT,"The maximum length of the detectable translational shift in the y direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchz", EMObject::INT,"The maximum length of the detectable translational shift in the z direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3");
                                d.put("initxform", EMObject::TRANSFORM,"The Transform storing the starting position. If unspecified the identity matrix is used");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }
 
                        static const string NAME;
        };
 
        class RT3DSphereAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                                   const string & cmp_name= "sqeuclidean", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "3D rotational and translational alignment using spherical sampling. Can reduce the search space if symmetry is supplied";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT3DSphereAligner();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("sym", EMObject::STRING,"The symmtery to use as the basis of the spherical sampling. Default is c1 (asymmetry).");
                                d.put("orientgen", EMObject::STRING,"Advanced. The orientation generation strategy. Default is eman");
                                d.put("delta", EMObject::FLOAT,"Angle the separates points on the sphere. This is exclusive of the \'n\' paramater. Default is 10");
                                d.put("n", EMObject::INT,"An alternative to the delta argument, this is the number of points you want generated on the sphere. Default is OFF");
                                d.put("dphi", EMObject::FLOAT,"The angle increment in the phi direction. Default is 10");
                                d.put("phi0", EMObject::FLOAT,"Lower bound for phi. Default it 0");
                                d.put("phi1", EMObject::FLOAT,"Upper bound for phi. Default it 360");
                                d.put("dotrans", EMObject::BOOL,"Do a translational search. Default is True(1)");
                                d.put("search", EMObject::INT,"The maximum length of the detectable translational shift - if you supply this parameter you can not supply the maxshiftx, maxshifty or maxshiftz parameters. Each approach is mutually exclusive.");
                                d.put("searchx", EMObject::INT,"The maximum length of the detectable translational shift in the x direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchy", EMObject::INT,"The maximum length of the detectable translational shift in the y direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3.");
                                d.put("searchz", EMObject::INT,"The maximum length of the detectable translational shift in the z direction- if you supply this parameter you can not supply the maxshift parameters. Default is 3");
                                d.put("initxform", EMObject::TRANSFORM,"The Transform storing the starting position. If unspecified the identity matrix is used");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }
 
                        static const string NAME;
        };
 
        class RT2DTreeAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                                   const string & cmp_name= "sqeuclidean", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "2D rotational and translational alignment using a hierarchical approach in Fourier space. flip options specifies whether this is RT or RTF. No 'refine' alignment should be required +-1 pixel.";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT2DTreeAligner();
                        }
 
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
//                              d.put("sigmathis", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
//                              d.put("initxform", EMObject::TRANSFORM,"The Transform storing the starting position. If unspecified the identity matrix is used");
                                d.put("flip", EMObject::BOOL,"Include flip in the alignment search. Default True");
                                d.put("verbose", EMObject::INT,"Turn this on to have useful information printed to standard out.");
                                d.put("maxshift", EMObject::INT,"Maximum acceptable translation. Used only approximately.");
                                d.put("maxres", EMObject::FLOAT,"Maximum resolution to consider when full sampling is used");
                                return d;
                        }
 
                        static const string NAME;
 
                private:
                        bool testort(EMData *small_this, EMData *small_to,vector<float> &sigmathisv,vector<float> &sigmatov, vector<float> &s_score, vector<float> &s_coverage,vector<Transform> &s_xform,int i,Dict &upd) const;
 
        };
 
        class RT2Dto3DTreeAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                                   const string & cmp_name= "sqeuclidean", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "3D rotational and translational alignment using a hierarchical approach in Fourier space. Should be very fast and not require 'refine' alignment.";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT2Dto3DTreeAligner();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("sym", EMObject::STRING,"The symmtery to use as the basis of the spherical sampling. Default is c1 (no symmetry)");
                                d.put("maxshift", EMObject::INT,"maximum shift allowed");
//                              d.put("sigmathis", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
//                              d.put("sigmato", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
                                d.put("initxform", EMObject::TRANSFORMARRAY,"An array of Transforms storing the starting positions.");
                                d.put("maxang", EMObject::FLOAT,"maximum angle from initial rotation.");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                d.put("maxres", EMObject::FLOAT,"Maximum resolution to consider when full sampling is used");
                                d.put("minres", EMObject::FLOAT,"Minimum resolution to consider when full sampling is used");
                                return d;
                        }
 
                        static const string NAME;
 
                private:
                        bool testort(EMData *small_this, EMData *small_to,vector<float> &s_score,vector<Transform> &s_xform,int i,Dict &upd, Transform initxf, int maxshift, int maxang) const;
 
        };
 
        
        class RT3DTreeAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                                   const string & cmp_name= "sqeuclidean", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "3D rotational and translational alignment using a hierarchical approach in Fourier space. Should be very fast and not require 'refine' alignment. 'this' should be the fixed reference, aligned to symmetry axes and mask if provided. If masking, provide the mask rather than premasking the volume.";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT3DTreeAligner();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("mask", EMObject::EMDATA,"A mask under which to do the alignment. Mask relative to 'this'");
                                d.put("maxshift", EMObject::INT,"maximum shift allowed");
                                d.put("sym", EMObject::STRING,"The symmtery to use as the basis of the spherical sampling. Default is c1 (no symmetry)");
                                d.put("sigmathis", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
                                d.put("sigmato", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
                                d.put("maxres", EMObject::FLOAT,"maximum resolution to compare");
                                d.put("minres", EMObject::FLOAT,"minimum resolution to compare");
                                d.put("maxang", EMObject::FLOAT,"maximum angle from initial rotation.");
                                d.put("initxform", EMObject::TRANSFORMARRAY,"An array of Transforms storing the starting positions.");
 
//                              d.put("initxform", EMObject::TRANSFORM,"The Transform storing the starting position. If unspecified the identity matrix is used");
                                d.put("randphi", EMObject::BOOL,"Ignore phi constraint for refine search");
                                d.put("rand180", EMObject::BOOL,"Ignore 180 rotation for refine search");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }
 
                        static const string NAME;
 
                private:
                        bool testort(EMData *small_this, EMData *small_to,vector<float> &sigmathisv,vector<float> &sigmatov, vector<float> &s_score, vector<float> &s_coverage,vector<Transform> &s_xform,int i,Dict &upd, Transform initxf, int maxshift,EMData *mask) const;
 
        };
 
        class RT3DLocalTreeAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                                   const string & cmp_name= "sqeuclidean", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "sqeuclidean", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "EXPERIMENATAL - 3D rotational and translational alignment using a hierarchical approach in Fourier space. Should be very fast and not require 'refine' alignment. This variant performs a locally normalized CCF for translational alignment and should thus work better when the reference is masked, but will be slower.";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT3DLocalTreeAligner();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("maxshift", EMObject::INT,"maximum shift allowed");
                                d.put("sym", EMObject::STRING,"The symmtery to use as the basis of the spherical sampling. Default is c1 (no symmetry)");
                                d.put("sigmathis", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
                                d.put("sigmato", EMObject::FLOAT,"Only Fourier voxels larger than sigma times this value will be considered");
                                d.put("maxres", EMObject::FLOAT,"maximum resolution to compare");
                                d.put("minres", EMObject::FLOAT,"minimum resolution to compare");
                                d.put("maxang", EMObject::FLOAT,"maximum angle from initial rotation.");
                                d.put("initxform", EMObject::TRANSFORMARRAY,"An array of Transforms storing the starting positions.");
 
//                              d.put("initxform", EMObject::TRANSFORM,"The Transform storing the starting position. If unspecified the identity matrix is used");
                                d.put("randphi", EMObject::BOOL,"Ignore phi constraint for refine search");
                                d.put("rand180", EMObject::BOOL,"Ignore 180 rotation for refine search");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }
 
                        static const string NAME;
 
                private:
                        bool testort(EMData *small_this, EMData *small_to,EMData *small_mask,EMData *small_thissq,vector<float> &sigmathisv,vector<float> &sigmatov, vector<float> &s_score, vector<float> &s_coverage,vector<Transform> &s_xform,int i,Dict &upd, Transform initxf, int maxshift) const;
 
        };
 
        class RT3DSymmetryAligner:public Aligner
        {
                public:
                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                   const string & cmp_name="ccc.tomo", const Dict& cmp_params = Dict()) const;
                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                        {
                                return align(this_img, to_img, "ccc.tomo", Dict());
                        }
 
 
                        virtual vector<Dict> xform_align_nbest(EMData * this_img, EMData * to_img, const unsigned int nsoln, const string & cmp_name, const Dict& cmp_params) const;
 
                        virtual string get_name() const
                        {
                                return NAME;
                        }
 
                        virtual string get_desc() const
                        {
                                return "3D symmetry aligner";
                        }
 
                        static Aligner *NEW()
                        {
                                return new RT3DSymmetryAligner();
                        }
 
                        virtual TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("sym", EMObject::FLOAT,"The symmetry. Default is icos");
                                d.put("transform", EMObject::TRANSFORM,"The transform to move to symmetry axis");
                                d.put("verbose", EMObject::BOOL,"Turn this on to have useful information printed to standard out.");
                                return d;
                        }
 
                        static const string NAME;
        };
 
        class FRM2DAligner:public Aligner
                        {
                                public:
                                        virtual EMData * align(EMData * this_img, EMData * to_img,
                                                        const string& cmp_name, const Dict& cmp_params=Dict()) const; //ming add ="frc"
 
                                        virtual EMData * align(EMData * this_img, EMData * to_img) const
                                        {
                                                return align(this_img, to_img, "frc", Dict());
                                        }
 
                                        string get_name() const
                                        {
                                                return NAME;
                                        }
 
                                        string get_desc() const
                                        {
                                                return "FRM2D uses two rotational parameters and one translational parameter";
                                        }
 
                                        static Aligner *NEW()
                                        {
                                                return new FRM2DAligner();
                                        }
                                        virtual TypeDict get_param_types() const
                                        {
                                                        TypeDict d;
                                                        d.put("maxshift", EMObject::INT,"Maximum translation in pixels in any direction. If the solution yields a shift beyond this value in any direction, then the refinement is judged a failure and the original alignment is used as the solution.");
 
                                                        //d.put("p_max", EMObject::FLOAT,"p_max is");
                                                        return d;
                                        }
 
                                        static const string NAME;
                };
 
 
        class CUDA_Aligner
        {
          public:
                CUDA_Aligner(int id);
 
                void finish();
 
                void setup(int nima, int nx, int ny, int ring_length, int nring, int ou, float step, int kx, int ky, bool ctf);
 
                void insert_image(EMData *image, int num);
 
                void filter_stack(vector<float> ctf_params);
 
                void sum_oe(vector<float> ctf_params, vector<float> ali_params, EMData* ave1, EMData *ave2);
 
                vector<float> alignment_2d(EMData *ref_image, vector<float> sx, vector<float> sy, int silent);
 
                vector<float> ali2d_single_iter(EMData *ref_image, vector<float> ali_params, float csx, float csy, int silent, float delta);
 
          private:
                float *image_stack, *image_stack_filtered;
                float *ccf;
                int NIMA, NX, NY, RING_LENGTH, NRING, OU, KX, KY;
                bool CTF;
                float STEP;
        };
 
        class CUDA_multiref_aligner
        {
          public:
                CUDA_multiref_aligner(int id);
 
                void finish();
 
                void setup(int nima, int nref, int nx, int ny, int ring_length, int nring, int ou, float step, int kx, int ky, bool ctf);
 
                void setup_params(vector<float> all_ali_params, vector<float> all_ctf_params);
 
                void insert_image(EMData *image, int num);
 
                void insert_ref_image(EMData *image, int num);
 
                vector<float> multiref_ali2d(int silent);
 
          private:
                float *image_stack, *ref_image_stack, *ref_image_stack_filtered;
                float *ccf;
                float *ali_params, *ctf_params;
                int NIMA, NREF, NX, NY, RING_LENGTH, NRING, OU, KX, KY, MAX_IMAGE_BATCH;
                bool CTF;
                float STEP;
        };
 
        template <> Factory < Aligner >::Factory();
 
        void dump_aligners();
        map<string, vector<string> > dump_aligners_list();
}
 
#endif