reconstructor_tools.h

Go to the documentation of this file.

/*
 * Author: David Woolford, 07/25/2007 (woolford@bcm.edu)
 * Copyright (c) 2000-2007 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_reconstructor_toosl_h__
#define eman_reconstructor_tools_h__ 1

#include "emdata.h"
#include "interp.h"

#include <string>
using std::string;

#include <cstdlib>

//debug
#include <iostream>
using std::cout;
using std::endl;


namespace EMAN
{
        
        class FourierPixelInserter3D : public FactoryBase
        {
                public:
                FourierPixelInserter3D() : norm(0), rdata(0), nx(0), ny(0), nz(0), nxy(0)
                {}
                
                virtual ~FourierPixelInserter3D()
                {
                        free_memory();
                }
                
                TypeDict get_param_types() const
                {
                        TypeDict d;
                        d.put("nx", EMObject::INT);
                        d.put("ny", EMObject::INT);
                        d.put("nz", EMObject::INT);
                        d.put("rdata", EMObject::FLOAT_POINTER);
                        d.put("norm", EMObject::FLOAT_POINTER);
                        return d;
                }
                
                virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0) = 0;
        

                virtual void init();
                
                virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz) = 0;
                
                protected:
                        float * norm;
                        float * rdata;
                
                        int nx, ny, nz, nxy;
                
                        static float tolerance;
                private:
                // Disallow copy and assignment by default
                        FourierPixelInserter3D( const FourierPixelInserter3D& );
                        FourierPixelInserter3D& operator=( const FourierPixelInserter3D& );
                
                        void free_memory()
                        {
                        }
        };
        
        class FourierInserter3DMode1 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode1() {}
                        virtual ~FourierInserter3DMode1() {}
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);

                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode1();
                        }

                        virtual string get_name() const
                        {
                                return "1";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion using nearest neighbor";
                        }
                
                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);

                private:
                // Disallow copy and assignment by default
                        FourierInserter3DMode1( const FourierInserter3DMode1& );
                        FourierInserter3DMode1& operator=( const FourierInserter3DMode1& );
        };
        
        class FourierInserter3DMode2 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode2() {}
                        virtual ~FourierInserter3DMode2() {}
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode2();
                        }

                        virtual string get_name() const
                        {
                                return "2";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion using interpolation and the nearest 8 voxels";
                        }
                
                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);
                
                        virtual void init();
                private:
                        int off[8];
                        float g[8];
                
                // Disallow copy and assignment by default
                        FourierInserter3DMode2( const FourierInserter3DMode2& );
                        FourierInserter3DMode2& operator=( const FourierInserter3DMode2& );
        };
        
        class FourierInserter3DMode3 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode3() {}
                        virtual ~FourierInserter3DMode3() {}
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode3();
                        }

                        virtual string get_name() const
                        {
                                return "3";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion mode 3";
                        }

                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);
                
                private:
                // Disallow copy and assignment by default
                        FourierInserter3DMode3( const FourierInserter3DMode3& );
                        FourierInserter3DMode3& operator=( const FourierInserter3DMode3& );
        };
        
        class FourierInserter3DMode4 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode4() {}
                        virtual ~FourierInserter3DMode4() {}
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode4();
                        }

                        virtual string get_name() const
                        {
                                return "4";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion mode 4";
                        }

                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);
                
                private:
                // Disallow copy and assignment by default
                        FourierInserter3DMode4( const FourierInserter3DMode4& );
                        FourierInserter3DMode4& operator=( const FourierInserter3DMode4& );
        };
        
        class FourierInserter3DMode5 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode5()
                        {
                                gimx = EMAN::Interp::get_gimx();
                        }
                
                        virtual ~FourierInserter3DMode5()
                        {
                                // Don't delete gimx it causes a seg fault
//                              if ( gimx != 0 )
//                              {
//                                      delete gimx;
//                                      gimx = 0;
//                              }
                        }
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode5();
                        }

                        virtual string get_name() const
                        {
                                return "5";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion mode 5";
                        }
                
                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);
                
                private:
                // Disallow copy and assignment by default
                        FourierInserter3DMode5( const FourierInserter3DMode5& );
                        FourierInserter3DMode5& operator=( const FourierInserter3DMode5& );
                
                        float * gimx;
        };
        
        class FourierInserter3DMode6 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode6() {}
                        virtual ~FourierInserter3DMode6() {}
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode6();
                        }

                        virtual string get_name() const
                        {
                                return "6";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion mode 6";
                        }
                
                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);
                
                private:
                // Disallow copy and assignment by default
                        FourierInserter3DMode6( const FourierInserter3DMode6& );
                        FourierInserter3DMode6& operator=( const FourierInserter3DMode6& );
        };
        
        class FourierInserter3DMode7 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode7() {}
                        virtual ~FourierInserter3DMode7() {}
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode7();
                        }

                        virtual string get_name() const
                        {
                                return "7";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion mode 7";
                        }
                
                        virtual bool effected_pixels_are_zero(const float& xx, const float& yy, const float& zz);
                
                private:
                // Disallow copy and assignment by default
                        FourierInserter3DMode7( const FourierInserter3DMode7& );
                        FourierInserter3DMode7& operator=( const FourierInserter3DMode7& );
        };
        
        class FourierInserter3DMode8 : public FourierPixelInserter3D
        {
                public:
                        FourierInserter3DMode8() : W(0)
                        {
                                
                        }
                        virtual ~FourierInserter3DMode8()
                        {
                                if ( W != 0 )
                                        delete [] W;
                        }
                
                        virtual bool insert_pixel(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight=1.0);
                
                        static FourierPixelInserter3D *NEW()
                        {
                                return new FourierInserter3DMode8();
                        }

                        virtual string get_name() const
                        {
                                return "8";
                        }
                
                        virtual string get_desc() const
                        {
                                return "Fourier pixel insertion mode 8";
                        }
                
                        virtual bool effected_pixels_are_zero(const float&, const float&, const float&) { throw; }
                        
                        virtual void init();
                private:
                        int mFreqCutoff;
                        float mDFreq;
                // Disallow copy and assignment by default
                        FourierInserter3DMode8( const FourierInserter3DMode8& );
                        FourierInserter3DMode8& operator=( const FourierInserter3DMode8& );
                        
                        float* W;
        };
        
        

        class InterpolationFunctoid
        {
        public:
                InterpolationFunctoid() {}
                virtual ~InterpolationFunctoid() {}
                
                virtual float operate( const float radius ) const = 0;
        };
        
        class InterpolationFunctoidMode3 : public InterpolationFunctoid
        {
        public:
                InterpolationFunctoidMode3() {}
                virtual ~InterpolationFunctoidMode3() {}
                
                virtual float operate( const float radius ) const
                {
                        return  exp(-radius / EMConsts::I3G);
                }
        };
        
        class InterpolationFunctoidMode4 : public InterpolationFunctoid
        {
        public:
                InterpolationFunctoidMode4() {}
                virtual ~InterpolationFunctoidMode4() {}
                
                virtual float operate( const float radius ) const
                {
                        return  exp(-radius / EMConsts::I4G);
                }
        };
        
        class InterpolationFunctoidMode5
        {
                public:
                        InterpolationFunctoidMode5() { gimx = EMAN::Interp::get_gimx(); }
                        virtual ~InterpolationFunctoidMode5()
                        {
                                if ( gimx != 0 )
                                {
//                                      delete gimx;
//                                      gimx = 0;
                                }
                        }
                
                        virtual float operate( const int mmx, const int mmy, const int mmz ) const
                        {
                                return gimx[abs(mmx) + abs(mmy) * 100 + abs(mmz) * 10000];
                        }
                private:
                        float * gimx;
        };

        class InterpolationFunctoidMode6 : public InterpolationFunctoid
        {
        public:
                InterpolationFunctoidMode6() {}
                virtual ~InterpolationFunctoidMode6() {}
                
                virtual float operate( const float radius ) const
                {
                        return  exp(-radius / EMConsts::I5G);
                }
        };
        
        class InterpolationFunctoidMode7 : public InterpolationFunctoid
        {
        public:
                InterpolationFunctoidMode7() {}
                virtual ~InterpolationFunctoidMode7() {}
                
                virtual float operate( const float radius ) const
                {
                        return  EMAN::Interp::hyperg(radius);
                }
        };
        
        
        class InterpolatedFRC : public FactoryBase
        {
                public:
                        InterpolatedFRC();
                        
                        virtual ~InterpolatedFRC()
                        {
                                free_memory();
                        }
        
                        void set_params(const Dict & new_params);
                        
                        TypeDict get_param_types() const
                        {
                                TypeDict d;
                                d.put("nx", EMObject::INT);
                                d.put("ny", EMObject::INT);
                                d.put("nz", EMObject::INT);
                                d.put("rdata", EMObject::FLOAT_POINTER);
                                d.put("norm", EMObject::FLOAT_POINTER);
                                d.put("z_scale", EMObject::FLOAT_POINTER);
                                d.put("y_scale", EMObject::FLOAT_POINTER);
                                d.put("x_scale", EMObject::FLOAT_POINTER);
                                d.put("sampling", EMObject::FLOAT_POINTER);
                                return d;
                        }
                        
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0) = 0;
                        
                        unsigned int get_size() { return size; }
        
                        float operator[](const unsigned int& idx) { return frc[idx]; }

//                      QualityScores finish(const unsigned int num_particles);
        
                        void reset();
                
                protected:
                        mutable Dict params;
                        // Disallow copy construction
                        InterpolatedFRC( const InterpolatedFRC& that );
                        // Disallow assigment
                        InterpolatedFRC& operator=( const InterpolatedFRC& that);
                        
                        bool continue_frc_calc_functoid(const float& xx, const float& yy, const float& zz, const float dt[], const InterpolationFunctoid& functoid, const float& weight = 1.0 );
                        
                        void free_memory();
                        
                        void init();
                        
                        // Pointers to the 3D (complex) data 
                        float* threed_rdata, *norm_data;

                        // I wish I could make these unsigned but everything else is ints, so these are too.
                        int nx, ny, nz, nxy;
                        
                        // scale factors are stored when dimensions are being stretched or shrunken in the Fourier reconstructor
                        float x_scale, y_scale, z_scale;
        
                        float bin;
        
                        // The maximum dimension (radius) of a considered pixel
                        int size;
                        int pixel_radius_max;
                        int pixel_radius_max_square;
                        
                        
                        // values used for calculating the normalization value
                        float r, rn;
                        
                        float* frc;
                        float* frc_norm_rdata;
                        float* frc_norm_dt;
                        
                        int off[8];
                        float g[8];
                public:
                        class QualityScores
                        {
                                public:
                                QualityScores() : frc_integral(0), snr_normed_frc_intergral(0), normed_snr_integral(0), norm(0) {}
                                
                                QualityScores( const QualityScores& that ) : frc_integral(that.frc_integral), 
                                        snr_normed_frc_intergral(that.snr_normed_frc_intergral), normed_snr_integral(that.normed_snr_integral), norm(that.norm) {}
                                
                                QualityScores& operator=( const QualityScores& that );
                                ~QualityScores() {}
        
                                
                                float get_frc_integral() const { return frc_integral; }
                                float get_snr_normed_frc_integral() const { return snr_normed_frc_intergral; }
                                float get_normed_snr_integral() const { return normed_snr_integral; }
                                float get_norm() const { return norm; }
        
                                void set_frc_integral( const float& score ) { frc_integral = score; }
                                void set_snr_normed_frc_integral(const float& score) { snr_normed_frc_intergral = score; }
                                void set_normed_snr_integral(const float& score) { normed_snr_integral = score; }
                                void set_norm( const float& score ) { norm = score; }
        
                                void debug_print()
                                {
                                        cout << "frc " << frc_integral << " nfrc " << snr_normed_frc_intergral << " nsnr " << normed_snr_integral << " norm " << norm << endl;
                                }
                                private:
        
                                float frc_integral, snr_normed_frc_intergral, normed_snr_integral, norm;
                        
                        };
                        
                QualityScores finish(const unsigned int num_particles);
        };
        
        class InterpolatedFRCMode1 : public InterpolatedFRC
        {
                public:
                InterpolatedFRCMode1() {};
                        
                virtual ~InterpolatedFRCMode1() {}
                
                virtual string get_name() const
                {
                        return "1";
                }
                
                static InterpolatedFRC *NEW()
                {
                        return new InterpolatedFRCMode1();
                }
                
                virtual string get_desc() const
                {
                        return "Corresponds to Fourier pixel inserter mode 1";
                }
                
                virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
        private:
                // Disallow copy construction
                InterpolatedFRCMode1( const InterpolatedFRCMode1& that );
                // Disallow assigment
                InterpolatedFRCMode1& operator=( const InterpolatedFRCMode1& that);

        };
        
        
        class InterpolatedFRCMode2 : public InterpolatedFRC
        {
                public:
                        InterpolatedFRCMode2() {};
                        
                        virtual ~InterpolatedFRCMode2() {}
                
                        virtual string get_name() const
                        {
                                return "2";
                        }
                        
                        static InterpolatedFRC *NEW()
                        {
                                return new InterpolatedFRCMode2();
                        }
                
                        virtual string get_desc() const
                        {
                                return "Corresponds to Fourier pixel inserter mode 2";
                        }
                
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
                private:
                // Disallow copy construction
                        InterpolatedFRCMode2( const InterpolatedFRCMode2& that );
                // Disallow assigment
                        InterpolatedFRCMode2& operator=( const InterpolatedFRCMode2& that);

        };
        
        class InterpolatedFRCMode3 : public InterpolatedFRC
        {
                public:
                        InterpolatedFRCMode3() {};
                        
                        virtual ~InterpolatedFRCMode3() {}
                        
                        virtual string get_name() const
                        {
                                return "3";
                        }
                
                        static InterpolatedFRC *NEW()
                        {
                                return new InterpolatedFRCMode3();
                        }
                        
                        virtual string get_desc() const
                        {
                                return "Corresponds to Fourier pixel inserter mode 3";
                        }
                
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
                private:
                // Disallow copy construction
                        InterpolatedFRCMode3( const InterpolatedFRCMode3& that );
                // Disallow assigment
                        InterpolatedFRCMode3& operator=( const InterpolatedFRCMode3& that);

        };
        
        
        class InterpolatedFRCMode4 : public InterpolatedFRC
        {
                public:
                        InterpolatedFRCMode4( ) {};
                        
                        virtual ~InterpolatedFRCMode4() {}
                
                        virtual string get_name() const
                        {
                                return "4";
                        }
                
                        static InterpolatedFRC *NEW()
                        {
                                return new InterpolatedFRCMode4();
                        }
                        
                        virtual string get_desc() const
                        {
                                return "Corresponds to Fourier pixel inserter mode 4";
                        }
                
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
                private:
                // Disallow copy construction
                        InterpolatedFRCMode4( const InterpolatedFRCMode4& that );
                // Disallow assigment
                        InterpolatedFRCMode4& operator=( const InterpolatedFRCMode4& that);

        };
        
        
        class InterpolatedFRCMode5 : public InterpolatedFRC
        {
                public:
                        InterpolatedFRCMode5() {};
                        
                        virtual ~InterpolatedFRCMode5() {}
                
                        virtual string get_name() const
                        {
                                return "5";
                        }
                        
                        static InterpolatedFRC *NEW()
                        {
                                return new InterpolatedFRCMode5();
                        }
                
                        virtual string get_desc() const
                        {
                                return "Corresponds to Fourier pixel inserter mode 5";
                        }
                
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
                private:
                // Disallow copy construction
                        InterpolatedFRCMode5( const InterpolatedFRCMode5& that );
                // Disallow assigment
                        InterpolatedFRCMode5& operator=( const InterpolatedFRCMode5& that);

        };
        
        class InterpolatedFRCMode6 : public InterpolatedFRC
        {
                public:
                        InterpolatedFRCMode6() {};
                        
                        virtual ~InterpolatedFRCMode6() {}
                
                        virtual string get_name() const
                        {
                                return "6";
                        }
                        
                        static InterpolatedFRC *NEW()
                        {
                                return new InterpolatedFRCMode6();
                        }
                
                        virtual string get_desc() const
                        {
                                return "Corresponds to Fourier pixel inserter mode 6";
                        }
                
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
                private:
                // Disallow copy construction
                        InterpolatedFRCMode6( const InterpolatedFRCMode6& that );
                // Disallow assigment
                        InterpolatedFRCMode6& operator=( const InterpolatedFRCMode6& that);

        };
        
        class InterpolatedFRCMode7 : public InterpolatedFRC
        {
                public:
                        InterpolatedFRCMode7() {}
                        
                        virtual ~InterpolatedFRCMode7() {}
                
                        virtual string get_name() const
                        {
                                return "7";
                        }
                        
                        static InterpolatedFRC *NEW()
                        {
                                return new InterpolatedFRCMode7();
                        }

                        virtual string get_desc() const
                        {
                                return "Corresponds to Fourier pixel inserter mode 7";
                        }
                
                        virtual bool continue_frc_calc(const float& xx, const float& yy, const float& zz, const float dt[], const float& weight = 1.0);
                
                private:
                // Disallow copy construction
                        InterpolatedFRCMode7( const InterpolatedFRCMode7& that );
                // Disallow assigment
                        InterpolatedFRCMode7& operator=( const InterpolatedFRCMode7& that);

        };
        
        // Factory for FourierPixelInserter3D
        template <> Factory < FourierPixelInserter3D >::Factory();
        template <> Factory < InterpolatedFRC >::Factory();
        
} // namespace EMAN


#endif // eman_reconstructor_tools_h__