emdata_metadata.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 emdata__metadata_h__
#define emdata__metadata_h__
 
public:
EMData *get_fft_amplitude();
 
EMData *get_fft_amplitude2D();
 
EMData *get_fft_phase();
 
#ifdef EMAN2_USING_CUDA
inline float *get_data() const
{
        if(rdata == 0){
                rdata = (float*)malloc(num_bytes);
                cudadirtybit = 1;
        }
        if(cudadirtybit == 1){
                cudadirtybit = 0;
                cudaMemcpy(rdata,cudarwdata,num_bytes,cudaMemcpyDeviceToHost);
        }
        return rdata;
}
#else
inline float *get_data() const { return rdata; }
#endif
 
inline const float * get_const_data() const { return get_data(); }
 
inline void set_data(float* data, const int x, const int y, const int z) {
        if (rdata) { EMUtil::em_free(rdata); rdata = 0; }
#ifdef EMAN2_USING_CUDA
        //cout << "set data" << endl;
//      free_cuda_memory();
#endif
        rdata = data;
        nx = x; ny = y; nz = z;
        nxy = nx*ny;
        nxyz = (size_t)nx*ny*nz;
        update();
}
 
inline void set_data(float* data) {
        rdata = data;
}
 
void write_data(string fsp,size_t loc,const Region* const area=0,const int file_nx=0, const int file_ny=0, const int file_nz=0);
 
void read_data(string fsp,size_t loc,const Region* area=0,const int file_nx=0, const int file_ny=0, const int file_nz=0);
 
 
 
inline void update()
{
        flags |= EMDATA_NEEDUPD;
        changecount++;
#ifdef FFT_CACHING
        if (fftcache!=0) { delete fftcache; fftcache=0; }
#endif //FFT_CACHING
 
}
 
inline void clearupdate()
{
        flags &= ~EMDATA_NEEDUPD;
        changecount--;
}
 
inline bool has_ctff() const
{
        if (this->has_attr("ctf")) {
                return true;
        }
        else {
                return false;
        }
}
 
 
float calc_center_density();
 
 
float calc_sigma_diff();
 
 
IntPoint calc_min_location() const;
 
 
IntPoint calc_max_location() const;
 
IntPoint calc_max_location_wrap(const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1, float *value = 0);
 
vector<float> calc_max_location_wrap_intp(const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1);
 
FloatPoint calc_center_of_mass(const float threshold=0);
 
size_t calc_min_index() const;
 
 
size_t calc_max_index() const;
 
 
vector<Pixel> calc_highest_locations(float threshold)  const;
 
vector<Pixel> calc_n_highest_locations(int n);
 
vector<Pixel> find_pixels_with_value(float val);
 
float get_edge_mean() const;
 
 
float get_circle_mean();
 
 
Ctf * get_ctf() const;
 
 
void set_ctf(Ctf * ctf);
 
 
inline Vec3f get_translation() const
{
        return all_translation;
}
 
 
inline void set_translation(const Vec3f &t)
{
        all_translation = t;
}
 
 
inline void set_translation(float dx, float dy, float dz)
{
        all_translation = Vec3f(dx, dy, dz);
}
 
 
inline Transform get_transform() const
{
        Dict rotation_dict;
        rotation_dict["type"] = "eman";
        rotation_dict["alt"] = attr_dict["euler_alt"];
        rotation_dict["az"] = attr_dict["euler_az"];
        rotation_dict["phi"] = attr_dict["euler_phi"];
 
        Transform trans;
        trans.to_identity();
        trans.set_rotation(rotation_dict);
 
        return trans;
}
 
inline void set_rotation(float az, float alt, float phi)
{
    attr_dict["orientation_convention"] = "EMAN";
        attr_dict["euler_alt"]=alt;
        attr_dict["euler_az"]=az;
        attr_dict["euler_phi"]=phi;
}
 
 
inline void set_rotation(const Transform& t3d)
{
        Dict d = t3d.get_rotation("eman");
        attr_dict["orientation_convention"] = "EMAN";
        attr_dict["euler_alt"] = (float) d["alt"];
        attr_dict["euler_az"] = (float) d["az"];
        attr_dict["euler_phi"] = (float) d["phi"];;
}
 
 
void set_size(int nx, int ny=1, int nz=1, bool noalloc=false);
 
#ifdef EMAN2_USING_CUDA
void set_size_cuda(int nx, int ny=1, int nz=1);
#endif //#EMAN2_USING_CUDA
 
 
void set_complex_size(int nx, int ny=1, int nz=1) {
        set_size(nx*2, ny, nz);
}
 
 
inline void set_path(const string & new_path)
{
        path = new_path;
}
 
 
inline void set_pathnum(int n)
{
        pathnum = n;
}
 
 
MArray2D get_2dview() const;
 
 
MArray3D get_3dview() const;
 
 
MCArray2D get_2dcview() const;
 
 
MCArray3D get_3dcview() const;
 
 
EMObject get_attr(const string & attr_name) const;
 
EMObject get_attr_default(const string & attr_name, const EMObject & em_obj = EMObject()) const;
 
void set_attr(const string & key, EMObject val);
 
 
void set_attr_python(const string & key, EMObject val);
 
inline bool has_attr(const string& key) const {
        return attr_dict.has_key(key);
}
 
Dict get_attr_dict() const;
 
#ifdef EMAN2_USING_CUDA
inline Dict get_attr_dict_cuda() const {return attr_dict;}
#endif
 
void set_attr_dict(const Dict & new_dict);
 
 
 
 void del_attr(const string & attr_name);
 
 
 void del_attr_dict(const vector<string> & del_keys);
 
 
inline int get_xsize() const
{
        return nx;
}
 
 
inline int get_ysize() const
{
        return ny;
}
 
 
inline int get_zsize() const
{
        return nz;
}
 
 
inline IntSize get_sizes() const
{
        return IntSize(get_xsize(), get_ysize(), get_zsize());
}
 
 
inline size_t get_size() const
{
        return (size_t)nx*(size_t)ny*(size_t)nz;
}
 
inline vector<float> get_data_as_vector() const {
        size_t size = get_size();
        vector<float> v(size);
        float* data = get_data();
        std::copy(data,data+size,v.begin());
        return v;
}
 
inline int get_ndim() const
{
        if (nz <= 1) {
                if (ny <= 1) {
                        return 1;
                }
                else {
                        return 2;
                }
        }
 
        return 3;
}
 
 
inline bool is_shuffled() const
{  //     PRB
        if (flags & EMDATA_SHUFFLE) {
                return true;
        }
 
        if(has_attr("is_shuffled")) {
                return get_attr("is_shuffled");
        }
 
        return false;
}
 
 
inline bool is_FH() const
{  //     PRB
        if (flags & EMDATA_FH) {
                return true;
        }
 
        if(has_attr("is_fh")) {
                return get_attr("is_fh");
        }
 
        return false;
}
 
 
inline bool is_complex() const
{
        if(attr_dict.has_key("is_complex")) {
                if (int(attr_dict["is_complex"])) {
                        return true;
                }
                else {
                        return false;
                }
        }
        else {
                return false;
        }
}
 
 
inline bool is_real() const
{
        return !is_complex();
}
 
 
inline void set_shuffled(bool is_shuffled)
{ // PRB
        if (is_shuffled) {
//              printf("entered correct part of set_shuffled \n");
//              flags |=  EMDATA_SHUFFLE;
                set_attr("is_shuffled", (int)1);
        }
        else {
//              flags &= ~EMDATA_SHUFFLE;
                set_attr("is_shuffled", (int)0);
        }
}
 
 
inline void set_FH(bool is_FH)
{ // PRB
        if (is_FH) {
//              flags |=  EMDATA_FH;
                set_attr("is_fh", (int)1);
        }
        else {
//              flags &= ~EMDATA_FH;
                set_attr("is_fh", (int)0);
        }
}
 
 
inline void set_complex(bool is_complex)
{
        if (is_complex) {
                attr_dict["is_complex"] = int(1);
        }
        else {
                attr_dict["is_complex"] = int(0);
        }
}
 
 
inline bool is_complex_x() const
{
        if(attr_dict.has_key("is_complex_x")) {
                if (int(attr_dict["is_complex_x"])) {
                        return true;
                }
                else {
                        return false;
                }
        }
        else {
                return false;
        }
}
 
;
inline void set_complex_x(bool is_complex_x)
{
        if (is_complex_x) {
                attr_dict["is_complex_x"] = int(1);
        }
        else {
                attr_dict["is_complex_x"] = int(0);
        }
}
 
 
inline bool is_flipped() const
{
        if (flags & EMDATA_FLIP) { //keep here for back compatibility
                return true;
        }
 
        if(attr_dict.has_key("is_flipped")) {
                if(get_attr("is_flipped")) {
                        return true;
                }
        }
 
        return false;
 
}
 
 
inline void set_flipped(bool is_flipped)
{
        if (is_flipped) {
                set_attr("is_flipped", (int)1);
        }
        else {
                set_attr("is_flipped", (int)0);
        }
}
 
 
inline bool is_ri() const
{
        if(attr_dict.has_key("is_complex_ri")) {
                if (int(attr_dict["is_complex_ri"])) {
                        return true;
                }
                else {
                        return false;
                }
        }
        else {
                return false;
        }
}
 
 
inline void set_ri(bool is_ri)
{
        if (is_ri) {
                attr_dict["is_complex_ri"] = int(1);
        }
        else {
                attr_dict["is_complex_ri"] = int(0);
        }
}
 
 
inline bool is_fftpadded() const
{
        if (flags & EMDATA_PAD) {
                return true;
        }
 
        if(has_attr("is_fftpad")) {
                return get_attr("is_fftpad");
        }
 
        return false;
 
}
 
 
inline void set_fftpad(bool is_fftpadded)
{
        if (is_fftpadded) {
                set_attr("is_fftpad", int(1));
        }
        else {
                set_attr("is_fftpad", int(0));
        }
}
 
 
inline bool is_fftodd() const
{
        if(flags & EMDATA_FFTODD) {
                return true;
        }
        else if( attr_dict.has_key("is_fftodd") && (int)attr_dict["is_fftodd"] == 1 ) {
                return true;
        }
        else {
                return false;
        }
}
 
 
inline void set_fftodd(bool is_fftodd)
{
        if (is_fftodd) {
                set_attr("is_fftodd", int(1));
        }
        else {
                set_attr("is_fftodd", int(0));
        }
}
 
 
inline void set_nxc(int nxc)
{
        attr_dict["nxc"] = nxc;
}
 
/******************************************************************************
 ** These functions are used for EMData's pickling, do not use it for         *
 *  other purpose, e.g. get flags of a EMData object                          *
 * ***************************************************************************/
inline int get_flags() const
{
        return flags;
}
 
inline void set_flags(int f)
{
        flags = f;
}
 
inline int get_changecount() const
{
        return changecount;
}
 
inline void set_changecount(int c)
{
        changecount = c;
}
 
inline int get_xoff() const
{
        return xoff;
}
 
inline int get_yoff() const
{
        return yoff;
}
 
inline int get_zoff() const
{
        return zoff;
}
 
inline void set_xyzoff(int x, int y, int z)
{
        xoff = x;
        yoff = y;
        zoff = z;
}
 
void scale_pixel(float scale_factor) const;
 
inline string get_path() const
{
        return path;
}
 
inline int get_pathnum() const
{
        return pathnum;
}
 
//vector<float> get_data_pickle() const;
EMBytes get_data_pickle() const;
 
//void set_data_pickle(const vector<float>& vf);
void set_data_pickle(std::string vf);
 
//we don't actually pickle supp, just a place holder to set supp to NULL
int get_supp_pickle() const;
 
void set_supp_pickle(int i);
 
vector<Vec3i> mask_contig_region(const float& val, const Vec3i& seed);
 
float get_amplitude_thres(float thres);
 
private:
void set_attr_dict_explicit(const Dict & new_dict);
 
/*****************************************************************************/
 
#endif  //emdata__metadata_h__