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();


float *get_data() const;
inline const float * const 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
        free_cuda_memory();
#endif
        rdata = data;
        nx = x; ny = y; nz = z;
        nxy = nx*ny;
        update();
}


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 | EMDATA_GPU_NEEDS_UPDATE | EMDATA_GPU_RO_NEEDS_UPDATE;
        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);

FloatPoint calc_center_of_mass();

int calc_min_index() const;


int calc_max_index() const;


vector<Pixel> calc_highest_locations(float threshold);


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 Transform3D get_transform() const
{
        return Transform3D( (float)attr_dict["euler_alt"],
                            (float)attr_dict["euler_az"],
                            (float)attr_dict["euler_phi"]);
}


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 Transform3D& t3d)
{
        Dict d = t3d.get_rotation(Transform3D::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);

#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;


MCArray3D* get_3dcviewptr() const;


MArray2D get_2dview(int x0, int y0) const;


MArray3D get_3dview(int x0, int y0, int z0) const;


MCArray2D get_2dcview(int x0, int y0) const;


MCArray3D get_3dcview(int x0, int y0, int z0) 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;


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 size_t get_size() const
{
        return (size_t)nx*(size_t)ny*(size_t)nz;
}

inline vector<float> get_data_as_vector() const {
        int 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;
std::string 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);


private:
void set_attr_dict_explicit(const Dict & new_dict);

/*****************************************************************************/

#endif  //emdata__metadata_h__