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 <cstring>
#include "emobject.h"
#include "emassert.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;
 
        // Was going to make this a static member of EMUtil since it is tied to EMDataType, but couldn't sort out the syntax
        const int EMDataTypeBits[] = { 0,8,8,16,16,32,32,32,64,32,32,64,0 };
 
        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,
                        EM_COMPRESSED                           // compressed
                };
                
 
                enum ImageType
                {
                        IMAGE_UNKNOWN,
                        IMAGE_MRC,
                        IMAGE_EER,
                        IMAGE_EER2X,
                        IMAGE_EER4X,
                        IMAGE_SPIDER,
                        IMAGE_SINGLE_SPIDER,
                        IMAGE_IMAGIC,
                        IMAGE_HDF,
                        IMAGE_DM3,
                        IMAGE_DM4,
                        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,
                        IMAGE_DF3,
                        IMAGE_OMAP,
                        IMAGE_SITUS,
                        IMAGE_SER
                };
 
                static EMData *vertical_acf(const EMData * image, int maxdy);
 
                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 void close_imageio(const string & filename, const ImageIO * io);
 
                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 double mode_size_product(size_t factor, size_t mode_size);
 
                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 void getRenderLimits(const Dict & dict, float & rendermin, float & rendermax, int & renderbits);
 
                static void getRenderMinMax(float * data, const int nx, const int ny, float & rendermin, float & rendermax, int &renderbits, const int nz = 1);
                
#ifdef USE_HDF5
                static EMObject read_hdf_attribute(const string & filename, const string & key, int image_index=0);
 
                static int write_hdf_attribute(const string & filename, const string & key, EMObject value, int image_index=0);
 
                static int delete_hdf_attribute(const string & filename, const string & key, int image_index=0);
#endif  //USE_HDF5
 
                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__