emdata_metadata.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
EMData *	get_fft_amplitude ()
	This file is a part of "emdata.h", to use functions in this file, you should "#include "emdata.h", NEVER directly include this file. More...
EMData *	get_fft_amplitude2D ()
	return the amplitudes of the 2D FFT including the left half PRB More...
EMData *	get_fft_phase ()
	return the phases of the FFT including the left half More...
float *	get_data () const
	Get the image pixel density data in a 1D float array. More...
const float *	get_const_data () const
	Get the image pixel density data in a 1D float array - const version of get_data. More...
void	set_data (float *data, const int x, const int y, const int z)
	Set the data explicitly data pointer must be allocated using malloc! More...
void	set_data (float *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)
	Dump the image pixel data in native byte order to a disk file. More...
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)
	Read the image pixel data in native byte order from a disk file. More...
void	update ()
	Mark EMData as changed, statistics, etc will be updated at need. More...
void	clearupdate ()
	turn off updates. More...
bool	has_ctff () const
	check whether the image physical file has the CTF info or not. More...
float	calc_center_density ()
	Calculates the density value at the peak of the image histogram, sort of like the mode of the density. More...
float	calc_sigma_diff ()
	Calculates sigma above and below the mean and returns the difference between them. More...
IntPoint	calc_min_location () const
	Calculates the coordinates of the minimum-value pixel. More...
IntPoint	calc_max_location () const
	Calculates the coordinates of the maximum-value pixel. More...
IntPoint	calc_max_location_wrap (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1, float *value=0)
	Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc If *value is provided, it will be set to the value at the max location. More...
vector< float >	calc_max_location_wrap_intp (const int maxshiftx=-1, const int maxshifty=-1, const int maxshiftz=-1)
	Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc. More...
FloatPoint	calc_center_of_mass (const float threshold=0)
	Calculate the center of mass with a threshold (Default 0, so only positive values are considered) More...
size_t	calc_min_index () const
	Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array. More...
size_t	calc_max_index () const
	Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array. More...
vector< Pixel >	calc_highest_locations (float threshold) const
	Calculate and return a sorted list of pixels whose values are above a specified threshold. More...
vector< Pixel >	calc_n_highest_locations (int n)
	Calculate and return a sorted list of N highest pixels in the map. More...
vector< Pixel >	find_pixels_with_value (float val)
	Find pixels in the image with exactly the specified values. More...
float	get_edge_mean () const
	Calculates the mean pixel values around the (1 pixel) edge of the image. More...
float	get_circle_mean ()
	Calculates the circular edge mean by applying a circular mask on 'this' image. More...
Ctf *	get_ctf () const
	Get ctf parameter of this image. More...
void	set_ctf (Ctf *ctf)
	Set the CTF parameter of this image. More...
Vec3f	get_translation () const
	Get 'this' image's translation vector from the original location. More...
void	set_translation (const Vec3f &t)
	Set 'this' images' translation vector from the original location. More...
void	set_translation (float dx, float dy, float dz)
	Set 'this' images' translation vector from the original location. More...
Transform	get_transform () const
	Get the 3D orientation of 'this' image. More...
void	set_rotation (float az, float alt, float phi)
	Define the 3D orientation of this particle, also used to indicate relative rotations for reconstructions. More...
void	set_rotation (const Transform &t3d)
	Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format. More...
void	set_size (int nx, int ny=1, int nz=1, bool noalloc=false)
	Resize this EMData's main board memory pointer. More...
void	set_complex_size (int nx, int ny=1, int nz=1)
	Resize 'this' complex image. More...
void	set_path (const string &new_path)
	Set the path. More...
void	set_pathnum (int n)
	Set the number of paths. More...
MArray2D	get_2dview () const
	Get image raw pixel data in a 2D multi-array format. More...
MArray3D	get_3dview () const
	Get image raw pixel data in a 3D multi-array format. More...
MCArray2D	get_2dcview () const
	Get complex image raw pixel data in a 2D multi-array format. More...
MCArray3D	get_3dcview () const
	Get complex image raw pixel data in a 3D multi-array format. More...
EMObject	get_attr (const string &attr_name) const
	The generic way to get any image header information given a header attribute name. More...
EMObject	get_attr_default (const string &attr_name, const EMObject &em_obj=EMObject()) const
	The generic way to get any image header information given a header attribute name. More...
void	set_attr (const string &key, EMObject val)
	Set a header attribute's value. More...
void	set_attr_python (const string &key, EMObject val)
	Set a header attribute's value from Python. More...
bool	has_attr (const string &key) const
	Ask if the header has a particular attribute. More...
Dict	get_attr_dict () const
	Get the image attribute dictionary containing all the image attribute names and attribute values. More...
void	set_attr_dict (const Dict &new_dict)
	Merge the new values with the existing dictionary. More...
void	del_attr (const string &attr_name)
	Delete the attribute from dictionary. More...
void	del_attr_dict (const vector< string > &del_keys)
	Delete the attributes from the dictionary. More...
int	get_xsize () const
	Get the image x-dimensional size. More...
int	get_ysize () const
	Get the image y-dimensional size. More...
int	get_zsize () const
	Get the image z-dimensional size. More...
IntSize	get_sizes () const
size_t	get_size () const
	Get the number of allocated floats in the image (nx*ny*nz) More...
vector< float >	get_data_as_vector () const
	Get the pixel data as a vector. More...
int	get_ndim () const
	Get image dimension. More...
bool	is_shuffled () const
	Has this image been shuffled? More...
bool	is_FH () const
	Is this a FH image? More...
bool	is_complex () const
	Is this a complex image? More...
bool	is_real () const
	Is this a real image? More...
void	set_shuffled (bool is_shuffled)
	Mark this image as a shuffled image. More...
void	set_FH (bool is_FH)
	Mark this complex image as a FH image. More...
void	set_complex (bool is_complex)
	Mark this image as a complex image. More...
bool	is_complex_x () const
	Is this image a 1D FFT image in X direction? More...
void	set_complex_x (bool is_complex_x)
	Marks this image a 1D FFT image in X direction. More...
bool	is_flipped () const
	Is this image flipped? More...
void	set_flipped (bool is_flipped)
	Mark this image as flipped. More...
bool	is_ri () const
	Is this image a real/imaginary format complex image? More...
void	set_ri (bool is_ri)
	Mark this image as a real/imaginary format complex image. More...
bool	is_fftpadded () const
	Is this image already extended along x for ffts? More...
void	set_fftpad (bool is_fftpadded)
	Mark this image as already extended along x for ffts. More...
bool	is_fftodd () const
	Does this image correspond to a (real-space) odd nx? More...
void	set_fftodd (bool is_fftodd)
	Mark this image as having (real-space) odd nx. More...
void	set_nxc (int nxc)
	Set the number of complex elements along x. More...
int	get_flags () const
void	set_flags (int f)
int	get_changecount () const
void	set_changecount (int c)
int	get_xoff () const
int	get_yoff () const
int	get_zoff () const
void	set_xyzoff (int x, int y, int z)
void	scale_pixel (float scale_factor) const
	Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford) More...
string	get_path () const
int	get_pathnum () const
EMBytes	get_data_pickle () const
void	set_data_pickle (std::string vf)
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)
	return the FFT amplitude which is greater than thres % More...
void	set_attr_dict_explicit (const Dict &new_dict)
	Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances. More...

Function Documentation

calc_center_density()

float EMData::calc_center_density

(

)

Calculates the density value at the peak of the image histogram, sort of like the mode of the density.

Returns

The density value at the peak of the image histogram.

Definition at line 251 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        float center = get_attr("mean");
        float sigma = get_attr("sigma");
        float ds = sigma / 2;
        size_t size = (size_t)nx * ny * nz;
        float *d = get_data();
        float sigma1 = sigma / 20;
        float sigma2 = sigma / 1000;
 
        while (ds > sigma1) {
                double sum = 0;
                int norm = 0;
 
                for (size_t i = 0; i < size; ++i) {
                        if (fabs(d[i] - center) < ds) {
                                sum += d[i];
                                norm++;
                        }
                }
                if (!norm) {
                        break;
                }
                float mean = (float)(sum / norm);
                if (fabs(mean - center) < sigma2) {
                        ds *= 0.5f;
                }
                center = mean;
        }
        EXITFUNC;
 
        return center;
}

References ENTERFUNC, EXITFUNC, get_attr(), get_data(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

calc_center_of_mass()

FloatPoint EMData::calc_center_of_mass

(

const float

threshold = 0

)

Calculate the center of mass with a threshold (Default 0, so only positive values are considered)

Author

Steve Ludtke

Date

Fri Jun 6th 2008

Definition at line 572 of file emdata_metadata.cpp.

{
        float *data = get_data();
 
        //float sigma = get_attr("sigma");
        //float mean = get_attr("mean");
        float m = 0.0;
 
        FloatPoint com(0,0,0);
        for (int i = 0; i < nx; ++i) {
                for (int j = 0; j < ny; ++j) {
                        int j2 = nx * j;
                        for (int k = 0; k < nz; ++k) {
                                size_t l = i + j2 + (size_t)k * nxy;
                                if (data[l] >= threshold) {             // threshold out noise (and negative density)
                                        com[0] += i * data[l];
                                        com[1] += j * data[l];
                                        com[2] += k * data[l];
                                        m += data[l];
                                }
                        }
                }
        }
 
        com[0] /= m;
        com[1] /= m;
        com[2] /= m;
 
        return com;
}

References get_data(), EMAN::EMData::nx, EMAN::EMData::nxy, EMAN::EMData::ny, and EMAN::EMData::nz.

calc_highest_locations()

vector< Pixel > EMData::calc_highest_locations

(

float

threshold

)

const

Calculate and return a sorted list of pixels whose values are above a specified threshold.

The pixels are sorted from high to low.

Parameters

threshold

The specified pixel value. Returned pixels should have higher values than it.

Returns

A sorted list of pixels with their values, and locations. Their values are higher than threshold.

Definition at line 620 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        vector<Pixel> result;
 
        int di = 1;
        if (is_complex() && !is_ri()) {
                di = 2;
        }
 
        int nxy = nx * ny;
        float * data = get_data();
 
        for (int j = 0; j < nz; ++j) {
                size_t cur_z = (size_t)j * nxy;
 
                for (int k = 0; k < ny; ++k) {
                        size_t cur_y = k * nx + cur_z;
 
                        for (int l = 0; l < nx; l += di) {
                                float v =data[l + cur_y];
                                if (v > threshold) {
                                        result.push_back(Pixel(l, k, j, v));
                                }
                        }
                }
        }
        
        std::sort(result.begin(), result.end());
        std::reverse(result.begin(), result.end());
 
        EXITFUNC;
        return result;
}

References ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), EMAN::EMData::nx, EMAN::EMData::nxy, EMAN::EMData::ny, and EMAN::EMData::nz.

calc_max_index()

size_t EMData::calc_max_index

(

)

const

Calculates the index of maximum-value pixel when assuming all pixels are in a 1D array.

Returns

Index of the maximum-value pixel.

Definition at line 612 of file emdata_metadata.cpp.

{
        IntPoint max_location = calc_max_location();
        size_t i = max_location[0] + max_location[1] * nx + (size_t)max_location[2] * nx * ny;
        return i;
}

References calc_max_location(), EMAN::EMData::nx, and EMAN::EMData::ny.

calc_max_location()

IntPoint EMData::calc_max_location

(

)

const

Calculates the coordinates of the maximum-value pixel.

Returns

The coordinates of the maximum-value pixel.

Definition at line 363 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        int di = 1;
        if (is_complex() && !is_ri()) {
                di = 2;
        }
 
        float max = -FLT_MAX;
        int max_x = 0;
        int max_y = 0;
        int max_z = 0;
        int nxy = nx * ny;
        float * data = get_data();
 
        for (int j = 0; j < nz; ++j) {
                size_t cur_z = (size_t)j * nxy;
 
                for (int k = 0; k < ny; ++k) {
                        size_t cur_y = k * nx + cur_z;
 
                        for (int l = 0; l < nx; l += di) {
                                float t = data[l + cur_y];
                                if (t > max) {
                                        max_x = l;
                                        max_y = k;
                                        max_z = j;
                                        max = t;
                                }
                        }
                }
        }
 
        EXITFUNC;
        return IntPoint(max_x, max_y, max_z);
}

References ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), EMAN::EMData::nx, EMAN::EMData::nxy, EMAN::EMData::ny, and EMAN::EMData::nz.

Referenced by calc_max_index().

calc_max_location_wrap()

IntPoint EMData::calc_max_location_wrap	(	const int	maxshiftx = -1,
		const int	maxshifty = -1,
		const int	maxshiftz = -1,
		float *	value = 0
	)

Calculates the wrapped coordinates of the maximum value This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc If *value is provided, it will be set to the value at the max location.

Returns

the wrapped coordinates of the maximum

Author

David Woolford

Date

Fri Jun 6th 2008

Definition at line 402 of file emdata_metadata.cpp.

{
        int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz;
        if (maxdx == -1) maxshiftx = get_xsize()/4;
        if (maxdy == -1) maxshifty = get_ysize()/4;
        if (maxdz == -1) maxshiftz = get_zsize()/4;
 
        float max_value = -FLT_MAX;
 
        IntPoint peak(0,0,0);
        
#ifdef EMAN2_USING_CUDA //CUDA
        if(EMData::usecuda == 1 && cudarwdata){
        
                CudaPeakInfo* soln = calc_max_location_wrap_cuda(cudarwdata, nx, ny, nz, maxdx, maxdy, maxdz);
                
                peak[0] = soln->px;
                peak[1] = soln->py;
                peak[2] = soln->pz;
                free(soln);
                
//              cout << "x " << peak[0] << " y " << peak[1] << " z " << peak[2] << endl;
                return peak;
        }
#endif
        for (int k = -maxshiftz; k <= maxshiftz; k++) {
                for (int j = -maxshifty; j <= maxshifty; j++) {
                        for (int i = -maxshiftx; i <= maxshiftx; i++) {
 
                                float value = get_value_at_wrap(i,j,k);
 
                                if (value > max_value) {
                                        max_value = value;
                                        peak[0] = i;
                                        peak[1] = j;
                                        peak[2] = k;
                                }
                        }
                }
        }
        if (value) *value=max_value;
 
        return peak;
}

References calc_max_location_wrap_cuda(), get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, CudaPeakInfo::px, CudaPeakInfo::py, and CudaPeakInfo::pz.

calc_max_location_wrap_intp()

vector< float > EMData::calc_max_location_wrap_intp	(	const int	maxshiftx = -1,
		const int	maxshifty = -1,
		const int	maxshiftz = -1
	)

Calculates the wrapped coordinates of the maximum value, and uses quadration intp to subpixel prec This function is useful in the context of Fourier correlation you can call this function to find the correct translational shift when using calc_ccf etc.

Returns

the wrapped coordinates of the maximum

Author

John Flanagan

Date

Mon Mar 7th 2011

#ifdef EMAN2_USING_CUDA //CUDA if(cudarwdata){

    CudaPeakInfo* soln = calc_max_location_wrap_cuda(cudarwdata, nx, ny, nz, maxdx, maxdy, maxdz);

    peak[0] = soln->px;
    peak[1] = soln->py;
    peak[2] = soln->pz;
    free(soln);

cout << "x " << peak[0] << " y " << peak[1] << " z " << peak[2] << endl; return peak; } #endif

I guess I could use GSL, but this is faster.... float x1 = float(peak[0]) - 1.0f; float x2 = float(peak[0]); float x3 = float(peak[0]) + 1.0f; float y1 = float(peak[1]) - 1.0f; float y2 = float(peak[1]); float y3 = float(peak[1]) + 1.0f; float z1 = float(peak[2]) - 1.0f; float z2 = float(peak[2]); float z3 = float(peak[2]) + 1.0f;

float yx1 = get_value_at_wrap(x1,y2,z2); float yx2 = get_value_at_wrap(x2,y2,z2); float yx3 = get_value_at_wrap(x3,y2,z2); float yy1 = get_value_at_wrap(x2,y1,z2); float yy2 = get_value_at_wrap(x2,y2,z2); float yy3 = get_value_at_wrap(x2,y3,z2); float yz1 = get_value_at_wrap(x2,y2,z1); float yz2 = get_value_at_wrap(x2,y2,z2); float yz3 = get_value_at_wrap(x2,y2,z3);

Fit peak in X to y = ax^2 + bx +c float bx = ((yx1 - yx2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yx2-yx3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float ax = ((yx1 - yx2) - bx*(x1 - x2))/(x1*x1 - x2*x2); Find minima float xintp = -bx/(2*ax);

Fit peak in X to y = ax^2 + bx +c float by = ((yy1 - yy2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yy2-yy3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float ay = ((yy1 - yy2) - by*(x1 - x2))/(x1*x1 - x2*x2); Find minima float yintp = -by/(2*ay);

Fit peak in X to y = ax^2 + bx +c float bz = ((yz1 - yz2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2) - (yz2-yz3))/(-(x2 - x3) + (x1 - x2)*(x2*x2 - x3*x3)/(x1*x1 - x2*x2)); float az = ((yz1 - yz2) - bz*(x1 - x2))/(x1*x1 - x2*x2); Find minima float zintp = -bz/(2*az);

vector<float> mydata; mydata.push_back(xintp); mydata.push_back(yintp); mydata.push_back(zintp); mydata.push_back(max_value);

Definition at line 447 of file emdata_metadata.cpp.

{
        int maxshiftx = maxdx, maxshifty = maxdy, maxshiftz = maxdz;
        if (maxdx == -1) maxshiftx = get_xsize()/4;
        if (maxdy == -1) maxshifty = get_ysize()/4;
        if (maxdz == -1) maxshiftz = get_zsize()/4;
 
        float max_value = -FLT_MAX;
        float is3d=(get_zsize()==1?0:1);
        maxshiftz=maxshiftz*is3d;
 
        IntPoint peak(0,0,0);
 
// NOT yet working......
        for (int k = -maxshiftz; k <= maxshiftz; k++) {
                for (int j = -maxshifty; j <= maxshifty; j++) {
                        for (int i = -maxshiftx; i <= maxshiftx; i++) {
 
                                float value = get_value_at_wrap(i,j,k);
 
                                if (value > max_value) {
                                        max_value = value;
                                        peak[0] = i;
                                        peak[1] = j;
                                        peak[2] = k;
                                }
                        }
                }
        }
        
//      printf("%d,%d,%d\t%f\n",peak[0], peak[1], peak[2], max_value);
        // compute the center of mass
        float cmx = 0.0; float cmy = 0.0f; float cmz = 0.0f;
        float sval = 0.0f;
        for (float x = float(peak[0])-2.0f; x <= float(peak[0])+2.0f; x++) {
                for (float y = float(peak[1])-2.0f; y <= float(peak[1])+2.0f; y++) {
                        for (float z = float(peak[2])-is3d*2.0f; z <= float(peak[2])+is3d*2.0f; z++) {
                                //Compute center of mass
                                float val = get_value_at_wrap(x,y,z);
                                
//                              printf("%.2f,%.2f, %.2f\t%.2f,%.2f,%.2f\n",x, y, val, cmx, cmy, sval);
                                if (val>0){
                                        cmx += x*val;
                                        cmy += y*val;
                                        cmz += z*val;
                                        sval += val;
                                }
                        }
                }
        }
        cmx /= sval;
        cmy /= sval;
        cmz /= sval;
 
        vector<float> mydata;
        mydata.push_back(cmx);
        mydata.push_back(cmy);
        mydata.push_back(cmz);
        mydata.push_back(max_value);
 
        return mydata;
}

References get_value_at_wrap(), get_xsize(), get_ysize(), get_zsize(), x, and y.

calc_min_index()

size_t EMData::calc_min_index

(

)

const

Calculates the index of minimum-value pixel when assuming all pixels are in a 1D array.

Returns

Index of the minimum-value pixel.

Definition at line 604 of file emdata_metadata.cpp.

{
        IntPoint min_location = calc_min_location();
        size_t i = min_location[0] + min_location[1] * nx + (size_t)min_location[2] * nx * ny;
        return i;
}

References calc_min_location(), EMAN::EMData::nx, and EMAN::EMData::ny.

calc_min_location()

IntPoint EMData::calc_min_location

(

)

const

Calculates the coordinates of the minimum-value pixel.

Returns

The coordinates of the minimum-value pixel.

Definition at line 325 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        int di = 1;
        if (is_complex() && !is_ri()) {
                di = 2;
        }
 
        float min = FLT_MAX;
        int min_x = 0;
        int min_y = 0;
        int min_z = 0;
        int nxy = nx * ny;
        float * data = get_data();
 
        for (int j = 0; j < nz; ++j) {
                size_t cur_z = (size_t)j * nxy;
 
                for (int k = 0; k < ny; ++k) {
                        size_t cur_y = k * nx + cur_z;
 
                        for (int l = 0; l < nx; l += di) {
                                float t = data[l + cur_y];
                                if (t < min) {
                                        min_x = l;
                                        min_y = k;
                                        min_z = j;
                                        min = t;
                                }
                        }
                }
        }
 
        return IntPoint(min_x, min_y, min_z);
}

References ENTERFUNC, get_data(), is_complex(), is_ri(), EMAN::EMData::nx, EMAN::EMData::nxy, EMAN::EMData::ny, and EMAN::EMData::nz.

Referenced by calc_min_index().

calc_n_highest_locations()

vector< Pixel > EMData::calc_n_highest_locations

(

int

n

)

Calculate and return a sorted list of N highest pixels in the map.

Parameters

n	The number of highest value pixels should be returned.

Returns

A sorted list of N pixels with their values, and locations.

Definition at line 656 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        vector<Pixel> result;
 
        int di = 1;
        if (is_complex() && !is_ri()) {
                di = 2;
        }
 
        // initialize with n elements
        float * data = get_data();
        for ( int i=0; i<n; i++) result.push_back(Pixel(0,0,0,-data[0]));
 
        int nxy = nx * ny;
 
        for (int j = 0; j < nz; ++j) {
                size_t cur_z = (size_t)j * nxy;
 
                for (int k = 0; k < ny; ++k) {
                        size_t cur_y = k * nx + cur_z;
 
                        for (int l = 0; l < nx; l += di) {
                                float v =data[l + cur_y];
                                if (v<result[n-1].value) continue;
                                for (vector<Pixel>::iterator i=result.begin(); i<result.end(); i++) {
                                        if (v>(*i).value) { result.insert(i,Pixel(l, k, j, v)); result.pop_back(); break; }
                                }
                        }
                }
        }
 
        EXITFUNC;
        return result;
}

References ENTERFUNC, EXITFUNC, get_data(), is_complex(), is_ri(), EMAN::EMData::nx, EMAN::EMData::nxy, EMAN::EMData::ny, and EMAN::EMData::nz.

calc_sigma_diff()

float EMData::calc_sigma_diff

(

)

Calculates sigma above and below the mean and returns the difference between them.

Returns

The difference between sigma above and below the mean.

Definition at line 288 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        float *d = get_data();
        float mean = get_attr("mean");
        float sigma = get_attr("sigma");
 
        double sum_up = 0;
        double sum_down = 0;
        int nup = 0;
        int ndown = 0;
 
        size_t size = (size_t)nx * ny * nz;
 
        for (size_t i = 0; i < size; ++i) {
                if (d[i] > mean) {
                        sum_up += Util::square(d[i] - mean);
                        nup++;
                }
                else {
                        sum_down += Util::square(mean - d[i]);
                        ndown++;
                }
        }
 
        float sigup = std::sqrt((float)sum_up / nup);
        float sigdown = std::sqrt((float)sum_down / ndown);
        float sig_diff = fabs(sigup - sigdown) / sigma;
 
 
        EXITFUNC;
        return sig_diff;
 
}

References ENTERFUNC, EXITFUNC, get_attr(), get_data(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, sqrt(), and EMAN::Util::square().

clearupdate()

void clearupdate ( )

inline

turn off updates.

Useful to avoid wasteful recacling stats

Definition at line 149 of file emdata_metadata.h.

{
        flags &= ~EMDATA_NEEDUPD;
        changecount--;
}

del_attr()

void EMData::del_attr

(

const string &

attr_name

)

Delete the attribute from dictionary.

Parameters

attr_name

the attribute name to be removed

Definition at line 1200 of file emdata_metadata.cpp.

{
        attr_dict.erase(attr_name);
}

References EMAN::EMData::attr_dict, and EMAN::Dict::erase().

Referenced by del_attr_dict().

del_attr_dict()

void EMData::del_attr_dict

(

const vector< string > &

del_keys

)

Delete the attributes from the dictionary.

Parameters

del_keys

the attrutes' names to be removed

Definition at line 1205 of file emdata_metadata.cpp.

{
        vector<string>::const_iterator it;
        for(it=del_keys.begin(); it!=del_keys.end(); ++it) {
                this->del_attr(*it);
        }
}

References del_attr().

find_pixels_with_value()

vector< Pixel > EMData::find_pixels_with_value

(

float

val

)

Find pixels in the image with exactly the specified values.

Parameters

val	The value to look for

Returns

An array of pixels with the specified values

Definition at line 693 of file emdata_metadata.cpp.

{
        ENTERFUNC;
        
        if ( is_complex() ) throw ImageFormatException("Error - find_pixels_with_value real only");
 
        vector<Pixel> result;
 
        for (int k = 0; k < nz; k++) {
                for (int j = 0; j < ny; j++) {
                        for (int i = 0; i < nx; i++) {
                                if (get_value_at(i,j,k)==val) result.push_back(Pixel(i,j,k,val));
                        }
                }
        }
 
        EXITFUNC;
        return result;
}

References ENTERFUNC, EXITFUNC, get_value_at(), ImageFormatException, is_complex(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

get_2dcview()

MCArray2D EMData::get_2dcview

(

)

const

Get complex image raw pixel data in a 2D multi-array format.

The array shares the memory space with the image data.

It should be used on 2D image only.

Returns

2D multi-array format of the raw data.

Definition at line 973 of file emdata_metadata.cpp.

{
        const int ndims = 2;
        if (get_ndim() != ndims) {
                throw ImageDimensionException("2D only");
        }
        boost::array<std::size_t,ndims> dims = {{(size_t)nx/2, (size_t)ny}};
        std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
        MCArray2D marray(cdata, dims, boost::fortran_storage_order());
        return marray;
}

References get_data(), get_ndim(), ImageDimensionException, EMAN::EMData::nx, and EMAN::EMData::ny.

get_2dview()

MArray2D EMData::get_2dview

(

)

const

Get image raw pixel data in a 2D multi-array format.

The array shares the memory space with the image data. Notice: the subscription order is d[y][x] in Python, it's d[x][y] in C++

It should be used on 2D image only.

Returns

2D multi-array format of the raw data.

Definition at line 952 of file emdata_metadata.cpp.

{
        const int ndims = 2;
        if (get_ndim() != ndims) {
                throw ImageDimensionException("2D only");
        }
        boost::array<std::size_t,ndims> dims = {{(size_t)nx, (size_t)ny}};
        MArray2D marray(get_data(), dims, boost::fortran_storage_order());
        return marray;
}

References get_data(), get_ndim(), ImageDimensionException, EMAN::EMData::nx, and EMAN::EMData::ny.

get_3dcview()

MCArray3D EMData::get_3dcview

(

)

const

Get complex image raw pixel data in a 3D multi-array format.

The array shares the memory space with the image data.

It should be used on 3D image only.

Returns

3D multi-array format of the raw data.

Definition at line 986 of file emdata_metadata.cpp.

{
        const int ndims = 3;
        boost::array<std::size_t,ndims> dims = {{(size_t)nx/2, (size_t)ny, (size_t)nz}};
        std::complex<float>* cdata = reinterpret_cast<std::complex<float>*>(get_data());
        MCArray3D marray(cdata, dims, boost::fortran_storage_order());
        return marray;
}

References get_data(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

get_3dview()

MArray3D EMData::get_3dview

(

)

const

Get image raw pixel data in a 3D multi-array format.

The array shares the memory space with the image data. Notice: the subscription order is d[z][y][x] in Python, it's d[x][y][z] in C++ –grant Tang

It should be used on 3D image only.

Returns

3D multi-array format of the raw data.

Definition at line 964 of file emdata_metadata.cpp.

{
        const int ndims = 3;
        boost::array<std::size_t,ndims> dims = {{(size_t)nx, (size_t)ny, (size_t)nz}};
        MArray3D marray(get_data(), dims, boost::fortran_storage_order());
        return marray;
}

References get_data(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

get_amplitude_thres()

float EMData::get_amplitude_thres

(

float

thres

)

return the FFT amplitude which is greater than thres %

Exceptions

ImageFormatException

If the image is not a complex image.

Returns

The FFT amplitude which is greater than thres %.

Definition at line 1326 of file emdata_metadata.cpp.

{
 
        if (thres < 0 || thres > 1){
                LOGERR("threshold bust be between 0 and 1.");
                throw InvalidValueException(thres, "thres: 0 <= thres <= 1");
        }
                
        EMData * amps = get_fft_amplitude();
        vector<float> ampvector = amps->get_data_as_vector();
        // yes I realize this may be slow if the map is big, but then again this function is only suited for tomo alignments, which if you have a big map will be VERY slow anyways!
        sort (ampvector.begin(), ampvector.end()); 
        int thresidx = int(thres * ampvector.size());
        float thresamp =  ampvector[thresidx];
 
        return thresamp;
}

References get_fft_amplitude(), InvalidValueException, and LOGERR.

get_attr()

EMObject EMData::get_attr

(

const string &

attr_name

)

const

The generic way to get any image header information given a header attribute name.

If the attribute does not exist, it will raise an exception.

Parameters

attr_name

The header attribute name.

Returns

The attribute value.

Exceptions

NotExistingObjectException

when attribute not exist

Definition at line 1006 of file emdata_metadata.cpp.

{
        ENTERFUNC;
        
        if ((flags & EMDATA_NEEDUPD) && (key != "is_fftpad") && (key != "xform.align2d")){update_stat();} //this gives a spped up of 7.3% according to e2speedtest
                
        size_t size = (size_t)nx * ny * nz;
        if (key == "kurtosis") {
                float mean = attr_dict["mean"];
                float sigma = attr_dict["sigma"];
 
                float *data = get_data();
                double kurtosis_sum = 0;
 
                for (size_t k = 0; k < size; ++k) {
                        float t = (data[k] - mean) / sigma;
                        float tt = t * t;
                        kurtosis_sum += tt * tt;
                }
 
                float kurtosis = (float)(kurtosis_sum / size - 3.0);
                return kurtosis;
        }
        else if (key == "skewness") {
                float mean = attr_dict["mean"];
                float sigma = attr_dict["sigma"];
 
                float *data = get_data();
                double skewness_sum = 0;
                for (size_t k = 0; k < size; ++k) {
                        float t = (data[k] - mean) / sigma;
                        skewness_sum +=  t * t * t;
                }
                float skewness = (float)(skewness_sum / size);
                return skewness;
        }
        else if (key == "moment_inertia") {
                double moment=0;
                if (ny==1 && nz==1) throw ImageFormatException("Error - cannot calculate moment of inertia of 1-D image");
                if (nz==1) {
                        for (int y=0; y<ny; y++) {
                                for (int x=0; x<nx; x++) {
                                        double v=get_value_at(x,y);
                                        if (v<=0) continue;
                                        moment+=v*(double)Util::hypot2sq(x-nx/2,y-ny/2);
                                }
                        }
                }
                else {
                        for (int z=0; z<nz; z++) {
                                for (int y=0; y<ny; y++) {
                                        for (int x=0; x<nx; x++) {
                                                double v=get_value_at(x,y,z);
                                                if (v<=0) continue;
                                                moment+=v*(double)Util::hypot3sq(x-nx/2,y-ny/2,z-nz/2);
                                        }
                                }
                        }
                }
                return (float)moment;
        }
        else if (key == "radius_gyration") {
                double moment=0;
                double mass=0;
                if (ny==1 && nz==1) throw ImageFormatException("Error - cannot calculate moment of inertia of 1-D image");
                if (nz==1) {
                        for (int y=0; y<ny; y++) {
                                for (int x=0; x<nx; x++) {
                                        double v=get_value_at(x,y);
                                        if (v<=0) continue;
                                        mass+=v;
                                        moment+=v*(double)Util::hypot2sq(x-nx/2,y-ny/2);
                                }
                        }
                }
                else {
                        for (int z=0; z<nz; z++) {
                                for (int y=0; y<ny; y++) {
                                        for (int x=0; x<nx; x++) {
                                                double v=get_value_at(x,y,z);
                                                if (v<=0) continue;
                                                mass+=v;
                                                moment+=v*(double)Util::hypot3sq(x-nx/2,y-ny/2,z-nz/2);
                                        }
                                }
                        }
                }
                return (float)(std::sqrt(moment/mass));
        }
        else if (key == "median")
        {
                if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
                size_t n = size;
                float* tmp = new float[n];
                float* d = get_data();
                if (tmp == 0 ) throw BadAllocException("Error - could not create deep copy of image data");
//              for(size_t i=0; i < n; ++i) tmp[i] = d[i]; // should just be a memcpy
                std::copy(d, d+n, tmp);
                qsort(tmp, n, sizeof(float), &greaterthan);
                float median;
                if (n%2==1) median = tmp[n/2];
                else median = (tmp[n/2-1]+tmp[n/2])/2.0f;
                delete [] tmp;
                return median;
        }
        else if (key == "nonzero_median")
        {
                if ( is_complex() ) throw ImageFormatException("Error - can not calculate the median of a complex image");
                vector<float> tmp;
                size_t n = size;
                float* d = get_data();
                for( size_t i = 0; i < n; ++i ) {
                        if ( d[i] != 0 ) tmp.push_back(d[i]);
                }
                sort(tmp.begin(), tmp.end());
                unsigned int vsize = tmp.size();
                float median;
                if (vsize%2==1) median = tmp[vsize/2];
                else median = (tmp[vsize/2-1]+tmp[vsize/2])/2.0f;
                return median;
        }
        else if (key == "changecount") return EMObject(changecount);
        else if (key == "nx") {
                return nx;
        }
        else if (key == "ny") {
                return ny;
        }
        else if (key == "nz") {
                return nz;
        }
 
        if(attr_dict.has_key(key)) {
                return attr_dict[key];
        }
        else {
                throw NotExistingObjectException(key, "The requested key does not exist");
        }
 
        EXITFUNC;
}

References EMAN::EMData::attr_dict, BadAllocException, EMAN::EMData::changecount, copy(), EMAN::EMData::EMDATA_NEEDUPD, ENTERFUNC, EXITFUNC, EMAN::EMData::flags, get_data(), get_value_at(), greaterthan(), EMAN::Dict::has_key(), EMAN::Util::hypot2sq(), EMAN::Util::hypot3sq(), ImageFormatException, is_complex(), NotExistingObjectException, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, sqrt(), EMAN::EMData::update_stat(), x, and y.

Referenced by calc_center_density(), EMAN::EMData::calc_hist(), calc_sigma_diff(), is_fftpadded(), is_FH(), is_flipped(), is_shuffled(), EMAN::KMeansAnalyzer::reseed(), and EMAN::KMeansAnalyzer::update_centers().

get_attr_default()

EMObject get_attr_default	(	const string &	attr_name,
		const EMObject &	em_obj = EMObject()
	)		const

The generic way to get any image header information given a header attribute name.

If the attribute does not exist, it will return a default EMObject() object, which will be converted to None in Python. Or return any object user submit.

Parameters

attr_name	The header attribute name.
em_obj	the default attribute to return when this attr_name not exist in attr_dict

Returns

The attribute value, default to None.

Referenced by EMAN::EMData::calc_radial_dist(), and EMAN::KMeansAnalyzer::reclassify().

get_attr_dict()

Dict EMData::get_attr_dict

(

)

const

Get the image attribute dictionary containing all the image attribute names and attribute values.

Returns

The image attribute dictionary containing all attribute names and values.

Definition at line 1162 of file emdata_metadata.cpp.

{
        if(rdata) {
                update_stat();
        }
 
        Dict tmp=Dict(attr_dict);
        tmp["nx"]=nx;
        tmp["ny"]=ny;
        tmp["nz"]=nz;
        tmp["changecount"]=changecount;
 
        return tmp;
}

References EMAN::EMData::attr_dict, EMAN::EMData::changecount, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::rdata, and EMAN::EMData::update_stat().

get_changecount()

int get_changecount ( ) const

inline

Definition at line 915 of file emdata_metadata.h.

{
        return changecount;
}

get_circle_mean()

float EMData::get_circle_mean

(

)

Calculates the circular edge mean by applying a circular mask on 'this' image.

Returns

The circular edge mean.

Definition at line 773 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        static bool busy = false;
        static EMData *mask = 0;
 
        while (busy);
        busy = true;
 
        if (!mask || !EMUtil::is_same_size(this, mask)) {
                if (!mask) {
                        mask = new EMData();
                }
                mask->set_size(nx, ny, nz);
                mask->to_one();
 
                float radius = (float)(ny / 2 - 2);
                mask->process_inplace("mask.sharp", Dict("inner_radius", radius - 1,
                                                                           "outer_radius", radius + 1));
 
        }
        double n = 0,s=0;
        float *d = mask->get_data();
        float * data = get_data();
        size_t size = (size_t)nx*ny*nz;
        for (size_t i = 0; i < size; ++i) {
                if (d[i]) { n+=1.0; s+=data[i]; }
        }
 
 
        float result = (float)(s/n);
        busy = false;
 
        EXITFUNC;
        return result;
}

References EMAN::EMData::EMData(), ENTERFUNC, EXITFUNC, get_data(), EMAN::EMUtil::is_same_size(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

get_const_data()

const float * get_const_data ( ) const

inline

Get the image pixel density data in a 1D float array - const version of get_data.

Returns

The image pixel density data.

Definition at line 84 of file emdata_metadata.h.

{ return get_data(); }

References get_data().

Referenced by EMAN::EMData::unwrap().

get_ctf()

Ctf * EMData::get_ctf

(

)

const

Get ctf parameter of this image.

Returns

The ctf parameter.

Definition at line 822 of file emdata_metadata.cpp.

{
        if(attr_dict.has_key("ctf")) {
                EMAN1Ctf * ctf = new EMAN1Ctf();
                ctf->from_vector(attr_dict["ctf"]);
 
                return dynamic_cast<Ctf *>(ctf);
        }
        else {
                return 0;
        }
}

References EMAN::EMData::attr_dict, EMAN::EMAN1Ctf::from_vector(), and EMAN::Dict::has_key().

get_data()

float * get_data ( ) const

inline

Get the image pixel density data in a 1D float array.

Returns

The image pixel density data.

Definition at line 78 of file emdata_metadata.h.

{ return rdata; }

References rdata.

Referenced by absi(), EMAN::EMData::add_incoherent(), EMAN::EMData::apply_radial_func(), EMAN::EMData::calc_az_dist(), EMAN::EMData::calc_ccfx(), calc_center_density(), calc_center_of_mass(), EMAN::EMData::calc_dist(), calc_highest_locations(), EMAN::EMData::calc_hist(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), EMAN::EMData::calc_radial_dist(), calc_sigma_diff(), EMAN::EMData::clip_inplace(), cmplx(), EMAN::EMData::common_lines(), EMAN::EMData::common_lines_real(), EMAN::EMData::cut_slice(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), EMAN::EMData::dot_rotate_translate(), EMAN::EMData::extract_box(), get_2dcview(), get_2dview(), get_3dcview(), get_3dview(), get_attr(), get_circle_mean(), get_col(), get_const_data(), get_data_as_vector(), get_data_pickle(), get_edge_mean(), get_fft_amplitude(), get_fft_phase(), get_row(), EMAN::EMData::get_top_half(), get_value_at(), get_value_at_wrap(), EMAN::EMData::little_big_dot(), log(), log10(), mult_value_at_fast(), EMAN::EMData::oneDfftPolar(), operator()(), phase(), EMAN::OutlierProcessor::process_inplace(), read_binedimage(), render_amp24(), render_ap24(), ri2ap(), ri2inten(), EMAN::EMData::rotate_x(), set_data_pickle(), set_value_at(), set_value_at_fast(), EMAN::EMData::setup4slice(), sget_value_at(), sqrt(), to_value(), EMAN::EMData::uncut_slice(), EMAN::EMData::unwrap_largerR(), and EMAN::EMData::update_stat().

get_data_as_vector()

vector< float > get_data_as_vector ( ) const

inline

Get the pixel data as a vector.

Returns

a vector containing the pixel data.

Definition at line 585 of file emdata_metadata.h.

                                                {
        size_t size = get_size();
        vector<float> v(size);
        float* data = get_data();
        std::copy(data,data+size,v.begin());
        return v;
}

References copy(), get_data(), and get_size().

get_data_pickle()

EMBytes EMData::get_data_pickle

(

)

const

Definition at line 1294 of file emdata_metadata.cpp.

{
//      vector<float> vf;
//      vf.resize(nx*ny*nz);
//      std::copy(rdata, rdata+nx*ny*nz, vf.begin());
 
        EMBytes vf;
        vf.assign((const char *)get_data(),nx*ny*nz*sizeof(float));
 
        return vf;
}

References get_data(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

get_edge_mean()

float EMData::get_edge_mean

(

)

const

Calculates the mean pixel values around the (1 pixel) edge of the image.

Returns

The mean pixel values around the (1 pixel) edge.

Definition at line 713 of file emdata_metadata.cpp.

{
        ENTERFUNC;
#ifdef EMAN2_USING_CUDA
        if(EMData::usecuda == 1 && cudarwdata){
                
                        return get_edgemean_cuda(cudarwdata, nx, ny, nz);
                        
        }
#endif
        int di = 0;
        double edge_sum = 0;
        float edge_mean = 0;
        size_t nxy = nx * ny;
        float * data = get_data();
        if (nz == 1) {
                for (int i = 0, j = (ny - 1) * nx; i < nx; ++i, ++j) {
                        edge_sum += data[i] + data[j];
                }
                for (size_t i = 0, j = nx - 1; i < nxy; i += nx, j += nx) {
                        edge_sum += data[i] + data[j];
                }
                edge_mean = (float)edge_sum / (nx * 2 + ny * 2);
        }
        else {
                if (nx == ny && nx == nz * 2 - 1) {
                        for (size_t j = (nxy * (nz - 1)); j < nxy * nz; ++j, ++di) {
                                edge_sum += data[j];
                        }
                }
                else {
                        for (size_t i = 0, j = (nxy * (nz - 1)); i < nxy; ++i, ++j, ++di) {
                                edge_sum += data[i] + data[j];
                        }
                }
 
                int nxy2 = nx * (ny - 1);
                for (int k = 1; k < nz - 1; ++k) {
                        size_t k2 = k * nxy;
                        size_t k3 = k2 + nxy2;
                        for (int i = 0; i < nx; ++i, ++di) {
                                edge_sum += data[i + k2] + data[i + k3];
                        }
                }
                for (int k = 1; k < nz - 1; ++k) {
                        size_t k2 = k * nxy;
                        size_t k3 = nx - 1 + k2;
                        for (int i = 1; i < ny - 1; ++i, ++di) {
                                edge_sum += data[i * nx + k2] + data[i * nx + k3];
                        }
                }
 
                edge_mean = (float)edge_sum / (di * 2);
        }
        EXITFUNC;
 
        return edge_mean;
}

References ENTERFUNC, EXITFUNC, get_data(), get_edgemean_cuda(), EMAN::EMData::nx, EMAN::EMData::nxy, EMAN::EMData::ny, and EMAN::EMData::nz.

Referenced by EMAN::EMData::calc_fast_sigma_image(), and EMAN::EMData::make_rotational_footprint_e1().

get_fft_amplitude()

EMData * EMData::get_fft_amplitude

(

)

This file is a part of "emdata.h", to use functions in this file, you should "#include "emdata.h", NEVER directly include this file.

return the amplitudes of the FFT including the left half

Exceptions

ImageFormatException

If the image is not a complex image.

Returns

The current FFT image's amplitude image.

Definition at line 91 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        if (!is_complex()) {
                LOGERR("complex image expected. Input image is real image.");
                throw ImageFormatException("complex image expected. Input image is a real image.");
        }
 
        ri2ap();
 
        int nx2 = nx - 2;
        EMData *dat = copy_head();
        dat->set_size(nx2, ny, nz);
        dat->to_zero();
 
        float *d = dat->get_data();
        float *data = get_data();
        int ndim = get_ndim();
 
        size_t idx1, idx2, idx3;
        if (ndim == 3) {
                for (int k = 1; k < nz; ++k) {
                        for (int j = 1; j < ny; ++j) {
                                for (int i = 0; i < nx2/2; ++i) {
                                        idx1 = (size_t)k*nx2*ny+j*nx2+nx2/2+i;
                                        idx2 = (size_t)k*nx*ny+j*nx+2*i;
                                        idx3 = (size_t)(nz-k)*nx2*ny+(ny-j)*nx2+nx2/2-i;
                                        d[idx1] = data[idx2];
                                        d[idx3] = data[idx2];
                                }
                        }
                }
        }
        else if (ndim == 2) {
                for (int j = 1; j < ny; ++j) {
                        for (int i = 0; i < nx2/2; ++i) {
                                d[j*nx2+nx2/2+i] = data[j*nx+2*i];
                                d[(ny-j)*nx2+nx2/2-i] = data[j*nx+2*i];
                        }
                }
        }
 
        dat->update();
        dat->set_complex(false);
        if(dat->get_ysize()==1 && dat->get_zsize()==1) {
                dat->set_complex_x(false);
        }
        dat->set_ri(false);
 
        EXITFUNC;
        return dat;
}

References copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageFormatException, is_complex(), LOGERR, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, and ri2ap().

Referenced by get_amplitude_thres().

get_fft_amplitude2D()

EMData * EMData::get_fft_amplitude2D

(

)

return the amplitudes of the 2D FFT including the left half PRB

Exceptions

ImageFormatException

If the image is not a complex image.

Returns

The current FFT image's amplitude image.

Definition at line 50 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
//      int ndim = get_ndim();
        if (!is_complex()) {
                LOGERR("complex image expected. Input image is real image.");
                throw ImageFormatException("complex image expected. Input image is a real image.");
        }
        if (nz>1) {
                LOGERR("2D image expected. Input image is 3D");
                throw ImageFormatException("2D odd square complex image"
                        " expected Input image is 3D.");
        }
 
        int nx2 = nx/2;
 
        EMData *dat = copy_head();
 
        dat->set_size(nx2, ny, nz);
        dat->to_zero();
 
        float temp=0;
 
        for (int j = 0; j < ny; j++) {
                for (int i = 0; i < nx2; i++) {
                        temp = (*this)(2*i,j)*(*this)(2*i,j);
                        temp += (*this)(2*i+1,j)*(*this)(2*i+1,j);
                        (*dat)(i,j) = std::sqrt(temp);
                }
        }
 
        dat->update();
        dat->set_complex(false);
        dat->set_ri(false);
 
        EXITFUNC;
        return dat;
}

References copy_head(), ENTERFUNC, EXITFUNC, ImageFormatException, is_complex(), LOGERR, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, and sqrt().

get_fft_phase()

EMData * EMData::get_fft_phase

(

)

return the phases of the FFT including the left half

Exceptions

ImageFormatException

If the image is not a complex image.

Returns

The current FFT image's phase image.

Definition at line 146 of file emdata_metadata.cpp.

{
        ENTERFUNC;
 
        if (!is_complex()) {
                LOGERR("complex image expected. Input image is real image.");
                throw ImageFormatException("complex image expected. Input image is a real image.");
        }
 
        ri2ap();
 
        int nx2 = nx - 2;
        EMData *dat = copy_head();
        dat->set_size(nx2, ny, nz);
        dat->to_zero();
 
        float *d = dat->get_data();
        float * data = get_data();
 
        int ndim = get_ndim();
        size_t idx1, idx2, idx3;
        if (ndim == 3) {
                for (int k = 1; k < nz; ++k) {
                        for (int j = 1; j < ny; ++j) {
                                for (int i = 0; i < nx2/2; ++i) {
                                        idx1 = (size_t)k*nx2*ny+j*nx2+nx2/2+i;
                                        idx2 = (size_t)k*nx*ny+j*nx+2*i+1;
                                        idx3 = (size_t)(nz-k)*nx2*ny+(ny-j)*nx2+nx2/2-i;
                                        d[idx1] = data[idx2];
                                        d[idx3] = -data[idx2];
                                }
                        }
                }
        }
        else if (ndim == 2) {
                for (int j = 1; j < ny; ++j) {
                        for (int i = 0; i < nx2/2; ++i) {
                                d[j*nx2+nx2/2+i] = data[j*nx+2*i+1];
                                d[(ny-j)*nx2+nx2/2-i] = -data[j*nx+2*i+1];
                        }
                }
        }
 
        dat->update();
        dat->set_complex(false);
        if(dat->get_ysize()==1 && dat->get_zsize()==1) {
                dat->set_complex_x(false);
        }
        dat->set_ri(false);
 
        EXITFUNC;
        return dat;
}

References copy_head(), ENTERFUNC, EXITFUNC, get_data(), get_ndim(), ImageFormatException, is_complex(), LOGERR, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, and ri2ap().

get_flags()

int get_flags ( ) const

inline

Definition at line 905 of file emdata_metadata.h.

{
        return flags;
}

get_ndim()

int get_ndim ( ) const

inline

Get image dimension.

Returns

image dimension.

Definition at line 596 of file emdata_metadata.h.

{
        if (nz <= 1) {
                if (ny <= 1) {
                        return 1;
                }
                else {
                        return 2;
                }
        }
 
        return 3;
}

Referenced by EMAN::EMData::apply_radial_func(), EMAN::EMData::calc_az_dist(), EMAN::EMData::calc_ccfx(), EMAN::EMData::calc_dist(), EMAN::EMData::calc_fast_sigma_image(), EMAN::EMData::cut_slice(), do_ift(), EMAN::EMData::do_radon(), EMAN::EMData::dot_rotate_translate(), get_2dcview(), get_2dview(), get_col(), get_fft_amplitude(), get_fft_phase(), get_row(), EMAN::EMData::get_top_half(), EMAN::EMData::little_big_dot(), render_amp24(), render_ap24(), EMAN::EMData::rotate_x(), EMAN::EMData::setup4slice(), EMAN::EMData::uncut_slice(), EMAN::EMData::unwrap(), and EMAN::EMData::window_center().

get_path()

string get_path ( ) const

inline

Definition at line 954 of file emdata_metadata.h.

{
        return path;
}

get_pathnum()

int get_pathnum ( ) const

inline

Definition at line 959 of file emdata_metadata.h.

{
        return pathnum;
}

get_size()

size_t get_size ( ) const

inline

Get the number of allocated floats in the image (nx*ny*nz)

Returns

nx*ny*nz

Definition at line 577 of file emdata_metadata.h.

{
        return (size_t)nx*(size_t)ny*(size_t)nz;
}

Referenced by get_data_as_vector(), and to_value().

get_sizes()

IntSize get_sizes ( ) const

inline

Definition at line 568 of file emdata_metadata.h.

{
        return IntSize(get_xsize(), get_ysize(), get_zsize());
}

References get_xsize(), get_ysize(), and get_zsize().

get_supp_pickle()

int EMData::get_supp_pickle

(

)

const

Definition at line 1316 of file emdata_metadata.cpp.

{
        return 0;
}

get_transform()

Transform get_transform ( ) const

inline

Get the 3D orientation of 'this' image.

Returns

The 3D orientation of 'this' image.

Definition at line 320 of file emdata_metadata.h.

{
        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;
}

get_translation()

Vec3f get_translation ( ) const

inline

Get 'this' image's translation vector from the original location.

Returns

'this' image's translation vector from the original location.

Definition at line 289 of file emdata_metadata.h.

{
        return all_translation;
}

get_xoff()

int get_xoff ( ) const

inline

Definition at line 925 of file emdata_metadata.h.

{
        return xoff;
}

get_xsize()

int get_xsize ( ) const

inline

Get the image x-dimensional size.

Returns

Image x-dimensional size.

Definition at line 544 of file emdata_metadata.h.

{
        return nx;
}

Referenced by absi(), EMAN::KMeansAnalyzer::analyze(), bispecRotTransInvDirect(), bispecRotTransInvN(), calc_max_location_wrap(), calc_max_location_wrap_intp(), get_sizes(), EMAN::EMData::getResolution(), EMAN::EMData::make_footprint(), phase(), real2complex(), and EMAN::EMData::unwrap_largerR().

get_yoff()

int get_yoff ( ) const

inline

Definition at line 930 of file emdata_metadata.h.

{
        return yoff;
}

get_ysize()

int get_ysize ( ) const

inline

Get the image y-dimensional size.

Returns

Image y-dimensional size.

Definition at line 553 of file emdata_metadata.h.

{
        return ny;
}

Referenced by absi(), EMAN::KMeansAnalyzer::analyze(), calc_max_location_wrap(), calc_max_location_wrap_intp(), get_sizes(), phase(), EMAN::BispecSliceProcessor::process(), real2complex(), and EMAN::EMData::unwrap_largerR().

get_zoff()

int get_zoff ( ) const

inline

Definition at line 935 of file emdata_metadata.h.

{
        return zoff;
}

get_zsize()

int get_zsize ( ) const

inline

Get the image z-dimensional size.

Returns

Image z-dimensional size.

Definition at line 562 of file emdata_metadata.h.

{
        return nz;
}

Referenced by absi(), EMAN::KMeansAnalyzer::analyze(), calc_max_location_wrap(), calc_max_location_wrap_intp(), get_sizes(), phase(), and real2complex().

has_attr()

bool has_attr ( const string &  key ) const

inline

Ask if the header has a particular attribute.

Parameters

key	the header attribute name

Returns

whether or not the header has the name as a key/value entry

Definition at line 498 of file emdata_metadata.h.

                                              {
        return attr_dict.has_key(key);
}

Referenced by has_ctff(), is_fftpadded(), is_FH(), is_shuffled(), and EMAN::KMeansAnalyzer::reseed().

has_ctff()

bool has_ctff ( ) const

inline

check whether the image physical file has the CTF info or not.

Returns

True if it has the CTF information. Otherwise, false.

Definition at line 158 of file emdata_metadata.h.

{
        if (this->has_attr("ctf")) {
                return true;
        }
        else {
                return false;
        }
}

References has_attr().

is_complex()

bool is_complex ( ) const

inline

Is this a complex image?

Returns

Whether this is a complex image or not.

Definition at line 648 of file emdata_metadata.h.

{
        if(attr_dict.has_key("is_complex")) {
                if (int(attr_dict["is_complex"])) {
                        return true;
                }
                else {
                        return false;
                }
        }
        else {
                return false;
        }
}

Referenced by EMAN::EMData::add_incoherent(), EMAN::EMData::apply_radial_func(), EMAN::EMData::calc_az_dist(), EMAN::EMData::calc_ccf(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), EMAN::EMData::calc_radial_dist(), EMAN::EMData::cconj(), EMAN::TomoWedgeCccCmp::cmp(), EMAN::TomoWedgeFscCmp::cmp(), EMAN::EMData::cut_slice(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), find_pixels_with_value(), get_attr(), get_fft_amplitude(), get_fft_amplitude2D(), get_fft_phase(), is_real(), log(), log10(), EMAN::TestUtil::make_image_file_by_mode(), real2complex(), render_amp24(), render_ap24(), ri2ap(), ri2inten(), set_complex(), EMAN::EMData::setup4slice(), sqrt(), EMAN::MrcIO::to_mrcmode(), to_one(), to_zero(), EMAN::TransformProcessor::transform(), EMAN::EMData::uncut_slice(), EMAN::EMData::update_stat(), EMAN::TestUtil::verify_image_file_by_mode(), and EMAN::EMData::window_center().

is_complex_x()

bool is_complex_x ( ) const

inline

Is this image a 1D FFT image in X direction?

Returns

Whether this image is a 1D FFT image in X direction.

Definition at line 727 of file emdata_metadata.h.

{
        if(attr_dict.has_key("is_complex_x")) {
                if (int(attr_dict["is_complex_x"])) {
                        return true;
                }
                else {
                        return false;
                }
        }
        else {
                return false;
        }
}

Referenced by EMAN::EMData::calc_ccfx(), and set_complex_x().

is_fftodd()

bool is_fftodd ( ) const

inline

Does this image correspond to a (real-space) odd nx?

Returns

Whether this image has a (real-space) odd nx.

Definition at line 864 of file emdata_metadata.h.

{
        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;
        }
}

Referenced by EMAN::EMData::cconj(), do_fft(), do_fft_inplace(), do_ift(), do_ift_inplace(), set_fftodd(), EMAN::FourierReconstructorSimple2D::setup(), EMAN::FourierReconstructor::setup(), EMAN::FourierReconstructor::setup_seed(), EMAN::FourierReconstructor::setup_seedandweights(), and EMAN::EMData::window_center().

is_fftpadded()

bool is_fftpadded ( ) const

inline

Is this image already extended along x for ffts?

Returns

Whether this image is extended along x for ffts.

Definition at line 831 of file emdata_metadata.h.

{
        if (flags & EMDATA_PAD) {
                return true;
        }
 
        if(has_attr("is_fftpad")) {
                return get_attr("is_fftpad");
        }
 
        return false;
 
}

References get_attr(), and has_attr().

Referenced by do_fft(), do_fft_inplace(), set_fftpad(), and EMAN::EMData::window_center().

is_FH()

bool is_FH ( ) const

inline

Is this a FH image?

Returns

Whether this is a FH image or not.

Definition at line 631 of file emdata_metadata.h.

{  //     PRB
        if (flags & EMDATA_FH) {
                return true;
        }
 
        if(has_attr("is_fh")) {
                return get_attr("is_fh");
        }
 
        return false;
}

References get_attr(), and has_attr().

Referenced by set_FH().

is_flipped()

bool is_flipped ( ) const

inline

Is this image flipped?

Returns

Whether this image is flipped or not.

Definition at line 761 of file emdata_metadata.h.

{
        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;
 
}

References get_attr().

Referenced by set_flipped().

is_real()

bool is_real ( ) const

inline

Is this a real image?

Returns

Whether this is image is real (not complex) or not.

Definition at line 667 of file emdata_metadata.h.

{
        return !is_complex();
}

References is_complex().

Referenced by absi(), EMAN::EMData::convolute(), EMAN::EMData::EMData(), phase(), and EMAN::TransformProcessor::transform().

is_ri()

bool is_ri ( ) const

inline

Is this image a real/imaginary format complex image?

Returns

Whether this image is real/imaginary format complex image.

Definition at line 797 of file emdata_metadata.h.

{
        if(attr_dict.has_key("is_complex_ri")) {
                if (int(attr_dict["is_complex_ri"])) {
                        return true;
                }
                else {
                        return false;
                }
        }
        else {
                return false;
        }
}

Referenced by absi(), EMAN::EMData::calc_az_dist(), calc_highest_locations(), calc_max_location(), calc_min_location(), calc_n_highest_locations(), EMAN::EMData::calc_radial_dist(), EMAN::EMData::cconj(), do_ift(), do_ift_inplace(), phase(), ri2ap(), ri2inten(), set_ri(), and EMAN::EMData::update_stat().

is_shuffled()

bool is_shuffled ( ) const

inline

Has this image been shuffled?

Returns

Whether this image has been shuffled to put origin in the center.

Definition at line 614 of file emdata_metadata.h.

{  //     PRB
        if (flags & EMDATA_SHUFFLE) {
                return true;
        }
 
        if(has_attr("is_shuffled")) {
                return get_attr("is_shuffled");
        }
 
        return false;
}

References get_attr(), and has_attr().

Referenced by set_shuffled().

mask_contig_region()

vector< Vec3i > mask_contig_region	(	const float &	val,
		const Vec3i &	seed
	)

read_data()

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
	)

Read the image pixel data in native byte order from a disk file.

The image should already have the correct dimensions.

Parameters

fsp	The filename to read the image data from
loc	Location to seek to in the file before writing (size_t)
area	The image region you want to read, default 0 means read the whole image
file_nx	Image x size.
file_ny	Image y size.
file_nz	Image z size.

Author

Steve Ludtke

Date

Mon Jun 23, 2008

scale_pixel()

void EMData::scale_pixel

(

float

scale_factor

)

const

Scale the angstrom per pixel of this image by a uniform amount Alters the EMData metadata I had to make this function public for access from the Processors (David Woolford)

Author

Unknown

Definition at line 1280 of file emdata_metadata.cpp.

{
        attr_dict["apix_x"] = ((float) attr_dict["apix_x"]) * scale;
        attr_dict["apix_y"] = ((float) attr_dict["apix_y"]) * scale;
        attr_dict["apix_z"] = ((float) attr_dict["apix_z"]) * scale;
        if (attr_dict.has_key("ctf")) {
                Ctf *ctf=(Ctf *)attr_dict["ctf"];
                ctf->apix*=scale;
                attr_dict["ctf"]=ctf;
                if(ctf) {delete ctf; ctf=0;}
        }
}

References EMAN::Ctf::apix, EMAN::EMData::attr_dict, EMAN::Dict::has_key(), and EMAN::EMData::scale().

set_attr()

void set_attr	(	const string &	key,
		EMObject	val
	)

Set a header attribute's value.

Parameters

key	The header attribute name.
val	The attribute value.

Referenced by EMAN::KMeansAnalyzer::analyze(), EMAN::EMData::compute_missingwedge(), ri2inten(), set_fftodd(), set_fftpad(), set_FH(), set_flipped(), and set_shuffled().

set_attr_dict()

void set_attr_dict

(

const Dict &

new_dict

)

Merge the new values with the existing dictionary.

Parameters

new_dict

The new attribute dictionary.

set_attr_dict_explicit()

void set_attr_dict_explicit ( const Dict &  new_dict )

private

Make the attributes of this EMData exactly equal to the argument dictionary Originally introduced because set_attr_dict does automatic resizing, which is undersirable in some circumstances.

Parameters

new_dict

The attribute dictionary that will become this image's attribute dictionary.

set_attr_python()

void set_attr_python	(	const string &	key,
		EMObject	val
	)

Set a header attribute's value from Python.

Parameters

key	The header attribute name.
val	The attribute value.

set_changecount()

void set_changecount ( int  c )

inline

Definition at line 920 of file emdata_metadata.h.

{
        changecount = c;
}

set_complex()

void set_complex ( bool  is_complex )

inline

Mark this image as a complex image.

Parameters

is_complex

If true, a complex image. If false, a real image.

Definition at line 712 of file emdata_metadata.h.

{
        if (is_complex) {
                attr_dict["is_complex"] = int(1);
        }
        else {
                attr_dict["is_complex"] = int(0);
        }
}

References is_complex().

Referenced by do_fft_inplace(), do_ift_inplace(), and read_binedimage().

set_complex_size()

void set_complex_size	(	int	nx,
		int	ny = 1,
		int	nz = 1
	)

Resize 'this' complex image.

Parameters

nx	x size of this image.
ny	y size of this image.
nz	z size of this image.

Definition at line 393 of file emdata_metadata.h.

                                                  {
        set_size(nx*2, ny, nz);
}

References set_size().

set_complex_x()

void set_complex_x ( bool  is_complex_x )

inline

Marks this image a 1D FFT image in X direction.

Parameters

is_complex_x

If true, a 1D FFT image in X direction; If false, not such an image.

Definition at line 747 of file emdata_metadata.h.

{
        if (is_complex_x) {
                attr_dict["is_complex_x"] = int(1);
        }
        else {
                attr_dict["is_complex_x"] = int(0);
        }
}

References is_complex_x().

Referenced by do_fft_inplace(), and do_ift_inplace().

set_ctf()

void set_ctf

(

Ctf *

ctf

)

Set the CTF parameter of this image.

Parameters

ctf	The CTF parameter object.

set_data() [1/2]

void set_data ( float *  data )

inline

Definition at line 106 of file emdata_metadata.h.

                                  {
        rdata = data;
}

References rdata.

set_data() [2/2]

void set_data ( float *  data, const int  x, const int  y, const int  z  )

inline

Set the data explicitly data pointer must be allocated using malloc!

Parameters

data	a pointer to the pixel data which is stored in memory. Takes possession
x	the number of pixels in the x direction
y	the number of pixels in the y direction
z	the number of pixels in the z direction

Definition at line 93 of file emdata_metadata.h.

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

References rdata, update(), x, and y.

set_data_pickle()

void EMData::set_data_pickle

(

std::string

vf

)

Definition at line 1307 of file emdata_metadata.cpp.

{
//      if (rdata) printf("rdata exists\n");
//      rdata = (float *)malloc(nx*ny*nz*sizeof(float));
//      std::copy(vf.begin(), vf.end(), rdata);
        EMUtil::em_memcpy(get_data(),vf.data(),(size_t)nx*ny*nz*sizeof(float));
 
}

References EMAN::EMUtil::em_memcpy(), get_data(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

set_fftodd()

void set_fftodd ( bool  is_fftodd )

inline

Mark this image as having (real-space) odd nx.

Parameters

is_fftodd

If true, mark as nx odd; If false, mark as nx not odd.

Definition at line 882 of file emdata_metadata.h.

{
        if (is_fftodd) {
                set_attr("is_fftodd", int(1));
        }
        else {
                set_attr("is_fftodd", int(0));
        }
}

References is_fftodd(), and set_attr().

Referenced by do_fft_inplace(), and read_binedimage().

set_fftpad()

void set_fftpad ( bool  is_fftpadded )

inline

Mark this image as already extended along x for ffts.

Parameters

is_fftpadded

If true, mark as padded along x; If false, mark as not padded along x.

Definition at line 850 of file emdata_metadata.h.

{
        if (is_fftpadded) {
                set_attr("is_fftpad", int(1));
        }
        else {
                set_attr("is_fftpad", int(0));
        }
}

References is_fftpadded(), and set_attr().

Referenced by do_fft_inplace(), do_ift_inplace(), and read_binedimage().

set_FH()

void set_FH ( bool  is_FH )

inline

Mark this complex image as a FH image.

Parameters

is_FH

If true, a FH image. If false, not a FH image.

Definition at line 695 of file emdata_metadata.h.

{ // PRB
        if (is_FH) {
//              flags |=  EMDATA_FH;
                set_attr("is_fh", (int)1);
        }
        else {
//              flags &= ~EMDATA_FH;
                set_attr("is_fh", (int)0);
        }
}

References is_FH(), and set_attr().

set_flags()

void set_flags ( int  f )

inline

Definition at line 910 of file emdata_metadata.h.

{
        flags = f;
}

set_flipped()

void set_flipped ( bool  is_flipped )

inline

Mark this image as flipped.

Parameters

is_flipped

If true, mark this image as flipped; If false, mark this image as not flipped.

Definition at line 782 of file emdata_metadata.h.

{
        if (is_flipped) {
                set_attr("is_flipped", (int)1);
        }
        else {
                set_attr("is_flipped", (int)0);
        }
}

References is_flipped(), and set_attr().

set_nxc()

void set_nxc ( int  nxc )

inline

Set the number of complex elements along x.

Parameters

nxc	is the number of complex elements along x.

Definition at line 896 of file emdata_metadata.h.

{
        attr_dict["nxc"] = nxc;
}

set_path()

void set_path ( const string &  new_path )

inline

Set the path.

Parameters

new_path

The new path.

Definition at line 401 of file emdata_metadata.h.

{
        path = new_path;
}

set_pathnum()

void set_pathnum ( int  n )

inline

Set the number of paths.

Parameters

n	The number of paths.

Definition at line 410 of file emdata_metadata.h.

{
        pathnum = n;
}

set_ri()

void set_ri ( bool  is_ri )

inline

Mark this image as a real/imaginary format complex image.

Parameters

is_ri

If true, mark as real/imaginary format; If false, mark as amp/phase format.

Definition at line 817 of file emdata_metadata.h.

{
        if (is_ri) {
                attr_dict["is_complex_ri"] = int(1);
        }
        else {
                attr_dict["is_complex_ri"] = int(0);
        }
}

References is_ri().

Referenced by do_fft_inplace(), do_ift_inplace(), read_binedimage(), ri2ap(), to_one(), and to_zero().

set_rotation() [1/2]

void set_rotation ( const Transform &  t3d )

inline

Define the 3D orientation of this particle Orientation information is extracted from a Transform object and stored internally in EMAN (az,alt,phi) format.

Parameters

t3d	a Transform object containing the particle orientation

Definition at line 356 of file emdata_metadata.h.

{
        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"];;
}

set_rotation() [2/2]

void set_rotation ( float  az, float  alt, float  phi  )

inline

Define the 3D orientation of this particle, also used to indicate relative rotations for reconstructions.

Parameters

az	'az' Euler angle in EMAN convention.
alt	'alt' Euler angle in EMAN convention.
phi	'phi' Euler angle in EMAN convention.

Definition at line 342 of file emdata_metadata.h.

{
    attr_dict["orientation_convention"] = "EMAN";
        attr_dict["euler_alt"]=alt;
        attr_dict["euler_az"]=az;
        attr_dict["euler_phi"]=phi;
}

set_shuffled()

void set_shuffled ( bool  is_shuffled )

inline

Mark this image as a shuffled image.

Parameters

is_shuffled

If true, a shuffled image. If false, not a shuffled image.

Definition at line 677 of file emdata_metadata.h.

{ // 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);
        }
}

References is_shuffled(), and set_attr().

set_size()

void set_size	(	int	nx,
		int	ny = 1,
		int	nz = 1,
		bool	noalloc = false
	)

Resize this EMData's main board memory pointer.

Parameters

nx	x size of this image.
ny	y size of this image.
nz	z size of this image.

Exceptions

BadAllocException

if memory allocation returns a null pointer

Referenced by bispecRotTransInvN(), EMAN::EMData::clip_inplace(), EMAN::EMData::common_lines(), EMAN::EMData::common_lines_real(), do_fft_inplace(), EMAN::EMData::EMData(), EMAN::EMData::operator=(), read_binedimage(), and set_complex_size().

set_supp_pickle()

void EMData::set_supp_pickle

(

int

i

)

Definition at line 1321 of file emdata_metadata.cpp.

{
        this->supp = 0;
}

References EMAN::EMData::supp.

set_translation() [1/2]

void set_translation ( const Vec3f &  t )

inline

Set 'this' images' translation vector from the original location.

Parameters

t	The new translation vector.

Definition at line 299 of file emdata_metadata.h.

{
        all_translation = t;
}

set_translation() [2/2]

void set_translation ( float  dx, float  dy, float  dz  )

inline

Set 'this' images' translation vector from the original location.

Parameters

dx	The translation distance in x direction.
dy	The translation distance in y direction.
dz	The translation distance in z direction.

Definition at line 311 of file emdata_metadata.h.

{
        all_translation = Vec3f(dx, dy, dz);
}

set_xyzoff()

void set_xyzoff ( int  x, int  y, int  z  )

inline

Definition at line 940 of file emdata_metadata.h.

{
        xoff = x;
        yoff = y;
        zoff = z;
}

References x, and y.

update()

void update ( )

inline

Mark EMData as changed, statistics, etc will be updated at need.

Definition at line 138 of file emdata_metadata.h.

{
        flags |= EMDATA_NEEDUPD;
        changecount++;
#ifdef FFT_CACHING
        if (fftcache!=0) { delete fftcache; fftcache=0; }
#endif //FFT_CACHING
 
}

Referenced by EMAN::EMData::add_incoherent(), EMAN::EMData::apply_radial_func(), EMAN::EMData::clip_inplace(), EMAN::EMData::common_lines(), EMAN::EMData::common_lines_real(), EMAN::EMData::cut_slice(), do_fft_inplace(), do_ift_inplace(), EMAN::EMData::EMData(), mult_value_at_fast(), EMAN::RotateInFSProcessor::process_inplace(), read_binedimage(), ri2ap(), ri2inten(), EMAN::EMData::rotate_x(), set_data(), set_value_at(), set_value_at_fast(), to_one(), to_value(), to_zero(), and EMAN::EMData::unwrap_largerR().

write_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
	)

Dump the image pixel data in native byte order to a disk file.

Parameters

fsp	The filename to write the image data to
loc	Location to seek to in the file before writing (size_t)
area	The image region you want to read, default 0 means read the whole image
file_nx	Image x size.
file_ny	Image y size.
file_nz	Image z size.

Author

Steve Ludtke

Date

Mon Jun 23, 2008