emutil.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__emutil__h__
#define eman__emutil__h__ 1

#include "emobject.h"
#include "emassert.h"
#include <string.h>

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

// Defining EMDelete using templates
// Use EMDelete instead of delete as this will be very clean.
// This should perhaps be moved to somewhere else later to make it
// more widely accessible. (C. Yang 04/27/06)
template <class T>
inline void EMDeletePtr(T & x)
{
#ifdef _WIN32
        if(x != NULL) {
                delete x;
                x = NULL;
        }
#else
        {Assert(x != NULL);}
        delete x;
        x = NULL;
#endif
}

template <class T>
inline void EMDeleteArray(T & x)
{
#ifdef _WIN32
        if(x != NULL) {
                delete x;
                x = NULL;
        }
#else
        {Assert(x != NULL);}
     delete [] x;
     x = NULL;
#endif
}

namespace EMAN
{
        class Region;
        class ImageIO;

        class EMUtil
        {
        public:
                enum EMDataType
                {
                        EM_UNKNOWN,
                        EM_CHAR,
                        EM_UCHAR,
                        EM_SHORT,
                        EM_USHORT,
                        EM_INT,
                        EM_UINT,
                        EM_FLOAT,
                        EM_DOUBLE,
                        EM_SHORT_COMPLEX,
                        EM_USHORT_COMPLEX,
                        EM_FLOAT_COMPLEX
                };

                enum ImageType
                {
                        IMAGE_UNKNOWN,
                        IMAGE_MRC,
                        IMAGE_SPIDER,
                        IMAGE_SINGLE_SPIDER,
                        IMAGE_IMAGIC,
                        IMAGE_HDF,
                        IMAGE_DM3,
                        IMAGE_TIFF,
                        IMAGE_PGM,
                        IMAGE_LST,
                        IMAGE_PIF,
                        IMAGE_VTK,
                        IMAGE_PNG,
                        IMAGE_SAL,
                        IMAGE_ICOS,
                        IMAGE_EMIM,
                        IMAGE_GATAN2,
                        IMAGE_AMIRA,
                        IMAGE_XPLOR,
                        IMAGE_EM,
                        IMAGE_V4L,
                        IMAGE_JPEG,
                        IMAGE_FITS,
                        IMAGE_LSTFAST
                };

                static EMData *vertical_acf(const EMData * image, int maxdy);

                static EMData *make_image_median(const vector < EMData * >&image_list);

                static ImageType get_image_ext_type(const string & file_ext);

                static ImageType get_image_type(const string & filename);

                static bool is_valid_filename(const string & filename);

                static int get_image_count(const string & filename);

                static ImageIO *get_imageio(const string & filename, int rw_mode,
                                                                        ImageType image_type = IMAGE_UNKNOWN);

                static const char *get_imagetype_name(EMUtil::ImageType type);

                static const char *get_datatype_string(EMDataType type);

                static void get_region_dims(const Region * area, int nx, int *area_x, int ny,
                                                                        int *area_y, int nz = 1, int *area_z = 0);

                static void get_region_origins(const Region * area, int *p_x0, int *p_y0,
                                                                           int *p_z0 = 0, int nz = 1, int image_index = 0);

                static void process_region_io(void *cdata, FILE * file, int rw_mode,
                                                                          int image_index, size_t mode_size, int nx,
                                                                          int ny, int nz = 1, const Region * area = 0,
                                                                          bool need_flip = false, ImageType imgtype=IMAGE_UNKNOWN,
                                                                          int pre_row = 0, int post_row = 0);


                static void process_ascii_region_io(float *data, FILE * file, int rw_mode,
                                                                                        int image_index, size_t mode_size,
                                                                                        int nx, int ny, int nz,
                                                                                        const Region * area, bool has_index_line,
                                                                                        int nitems_per_line, const char *outformat);


                static void dump_dict(const Dict & dict);

                static bool is_same_size(const EMData * image1, const EMData * image2);

                static bool is_same_ctf(const EMData * image1, const EMData * image2);


                static bool is_complex_type(EMDataType datatype);

                static void jump_lines(FILE * file, int nlines);

        static vector<string> get_euler_names(const string & euler_type);

                static vector<EMObject> get_all_attributes(const string & file_name, const string & attr_name);


                static bool cuda_available() {
#ifdef EMAN2_USING_CUDA
                        return true;
#else
                        return false;
#endif
                }

                inline static void* em_malloc(const size_t size) {
                        return malloc(size);
                }

                inline static void* em_calloc(const size_t nmemb,const size_t size) {
                        return calloc(nmemb,size);
                }

                inline static void* em_realloc(void* data,const size_t new_size) {
                        return realloc(data, new_size);
                }
                inline static void em_memset(void* data, const int value, const size_t size) {
                        memset(data, value, size);
                }
                inline static void em_free(void*data) {
                        free(data);
                }

                inline static void em_memcpy(void* dst,const void* const src,const size_t size) {
                        memcpy(dst,src,size);
                }
          private:
                static ImageType fast_get_image_type(const string & filename,
                                                                                         const void *first_block,
                                                                                         off_t file_size);

                static void jump_lines_by_items(FILE * file, int nitems, int nitems_per_line);



                static void process_numbers_io(FILE * file, int rw_mode,
                                                                           int nitems_per_line,
                                                                           size_t mode_size, int start, int end,
                                                                           float *data, int *p_i,
                                                                           const char *outformat);

                static void exclude_numbers_io(FILE * file, int rw_mode,
                                                                           int nitems_per_line,
                                                                           size_t mode_size, int start, int end,
                                                                           float * data, int *p_i,
                                                                           const char *outformat);

                static void process_lines_io(FILE * file, int rw_mode,
                                                                         int nitems_per_line, size_t mode_size,
                                                                         int nitems, float *data, int *p_i,
                                                                         const char *outformat);


        };

        struct ImageScore {
                int index;
                float score;
                ImageScore(int i=0, float s=0) : index(i), score(s) {}
        };

        class ImageSort {
        public:
                ImageSort(int n);
                ~ImageSort();

                void sort();

                void set(int i, float score);
                int get_index(int i) const;
                float get_score(int i) const;

                int size() const;
        private:
                ImageScore* image_scores;
                int n;

        };
}

#endif  //eman__emutil__h__