polardata.h

Go to the documentation of this file.

/*
 * Author: Grant Tang, 02/06/2006 (gtang@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__polardata_h__
#define eman__polardata_h__
 
#include <map>
#include <vector>
#include "log.h"
#include "exception.h"
 
using std::map;
using std::vector; 
 
namespace EMAN
{
        static const int MAXFFT=32768;
        class EMData;
        
        class UnevenMatrix
        {
        public:
                UnevenMatrix() : data(0) {
                        printf("Welcome to UnevenMatrix\n");
                }
                virtual ~UnevenMatrix() {
                        if(data) {
                                delete data;
                                data = 0;
                        }
                        printf("Destructor of UnevenMatrix...\n");
                }
                
                inline int get_xsize(int y) {
                        int xsize = desc_data[y].x1 - desc_data[y].x0;
                        if( xsize <= 0 ) {
                                throw InvalidValueException(xsize, "xsize <= 0");
                        }
                        else {
                                return xsize;
                        }
                }
                
                inline int get_xmin(int y) {
                        return desc_data[y].x0;
                }
                
                inline int get_xmax(int y) {
                        return desc_data[y].x1 - 1;
                }
                
                inline int get_size() {
                        return tot_size;
                }
 
#ifdef DEBUG
                void print_UnevenMatrix() {
                        printf("print function in UnevenMatrix\n");
                } 
#endif  //DEBUG
 
        protected:
                void alloc_data();
                
                struct Xdim {
                        int x0;
                        int x1;
                        Xdim() {}
                        Xdim(int i0, int i1) : x0(i0), x1(i1) {
                                if( x1 <= x0 ) {
                                        LOGERR("x dimension error ... x0(%d) > x1(%d)", x0, x1);
                                }
                        }
                };
                
                float * data;
                
                map< int, Xdim >        desc_data;
                
                int tot_size;
        };
        
        class PolarData : public UnevenMatrix
        {
        public:
                PolarData() {printf("Welcome to PolarData class... \n");}
                
                PolarData(EMData * image, int xcen, int ycen, string mode);
                
                virtual ~PolarData() {
                        printf("Destructor of PolarData...\n");
                }
                
#ifdef DEBUG            
                void print_polar() {
                        printf("PolarData class is a specialized image class for storing the \n");
                        printf("results of a transform from EMData to polar coordinates, currently \n");
                        printf("support 2D only. Data on x dimension may be variable size, which \n");
                        printf("is defined in map< int, Xdim > desc_data\n");
                }
                
                int test_init_desc_data();
#endif  //DEBUG
 
        private:
                map< int, float >       weight;
                
                vector<int> Numrinit(int first_ring, int last_ring, int skip, string mode);
        
                int log2(int n);
                
                vector<float> ringwe( vector<int> numr, string mode );
        };
 
}
 
 
#endif  //eman__polardata_h__