a function or class that is CUDA enabled

Classes
class	EMAN::TranslationalAligner
	Translational 2D Alignment using cross correlation. More...
class	EMAN::RotationalAligner
	rotational alignment using angular correlation More...
class	EMAN::RotateTranslateAligner
	rotational, translational alignment More...
class	EMAN::RotateFlipAligner
	rotational and flip alignment More...
class	EMAN::RotateTranslateFlipAligner
	rotational, translational and flip alignment More...
class	EMAN::Rotate180Processor
	Rotate by 180 using pixel swapping, works for 2D only. More...
class	EMAN::TransformProcessor
	Transform the image using a Transform object. More...
class	EMAN::IntTranslateProcessor
	Translate the image an integer amount Uses EMData::clip_inplace (inplace) and EMData::get_clip (out of place) to do the translation. More...
class	EMAN::BinarizeFourierProcessor
	A thresholding processor for Fourier images based on the amplitude component. More...
Functions
EMData *	EMAN::EMData::do_fft () const
	For fft, wavelet, insert data.
EMData *	EMAN::EMData::do_ift ()
	return the inverse fourier transform (IFT) image of the current image.
void	EMAN::EMData::ri2ap ()
	convert the complex image from real/imaginary to amplitude/phase
void	EMAN::EMData::ap2ri ()
	convert the complex image from amplitude/phase to real/imaginary
void	EMAN::EMData::ri2inten ()
	convert the complex image from real/imaginary to Intensity/0.
void	EMAN::EMData::insert_clip (const EMData *const block, const IntPoint &origin)
	Insert a clip into this image.
	EMAN::EMData::EMData (const EMData &that)
	Construct from an EMData (copy constructor).
EMData &	EMAN::EMData::operator= (const EMData &that)
	EMData assignment operator Performs a deep copy.
EMData *	EMAN::EMData::get_clip (const Region &area, const float fill=0) const
	Get an inclusive clip.
EMData *	EMAN::EMData::calc_ccf (EMData *with, fp_flag fpflag=CIRCULANT, bool center=false)
	Calculate Cross-Correlation Function (CCF).
EMData *	EMAN::EMData::calc_ccfx (EMData *const with, int y0=0, int y1=-1, bool nosum=false)
	Calculate Cross-Correlation Function (CCF) in the x-direction and adds them up, result in 1D.
EMData *	EMAN::EMData::make_rotational_footprint (bool unwrap=true)
	Makes a 'rotational footprint', which is an 'unwound' autocorrelation function.
EMData *	EMAN::EMData::unwrap (int r1=-1, int r2=-1, int xs=-1, int dx=0, int dy=0, bool do360=false, bool weight_radial=true) const
	Maps to polar coordinates from Cartesian coordinates.
EMData *	do_fft () const
	$Id$
EMData *	do_ift ()
	return the inverse fourier transform (IFT) image of the current image.
void	ri2ap ()
	convert the complex image from real/imaginary to amplitude/phase
void	ap2ri ()
	convert the complex image from amplitude/phase to real/imaginary
void	ri2inten ()
	convert the complex image from real/imaginary to Intensity/0.
void	insert_clip (const EMData *const block, const IntPoint &origin)
	Insert a clip into this image.

---

Function Documentation

void ap2ri

(

)

convert the complex image from amplitude/phase to real/imaginary

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

void EMData::ap2ri

(

)

[inherited]

convert the complex image from amplitude/phase to real/imaginary

Definition at line 884 of file emdata_transform.cpp.

References ap2ri(), emdata_ap2ri(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::is_complex(), EMAN::EMData::is_ri(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::set_ri(), and EMAN::EMData::update().

Referenced by EMAN::CtfAverager::add_image(), EMAN::EMData::apply_radial_func(), EMAN::EMData::calc_mutual_correlation(), EMAN::OptVarianceCmp::cmp(), EMAN::EMData::common_lines(), EMAN::EMData::convolute(), EMAN::EMData::do_ift(), EMAN::EMData::do_ift_inplace(), EMAN::EMData::mult(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::AddRandomNoiseProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::GaussFFTProjector::project3d(), and EMAN::EMData::ri2inten().

{
        ENTERFUNC;

        if (!is_complex() || is_ri()) {
                return;
        }

#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred()) {
                EMDataForCuda tmp = get_data_struct_for_cuda();
                emdata_ap2ri(&tmp);
                set_ri(true);
                gpu_update();
                EXITFUNC;
                return;
        }
#endif

        Util::ap2ri(get_data(), nx * ny * nz);
        set_ri(true);
        update();
        EXITFUNC;
}

EMData * EMData::calc_ccf	(	EMData *	with,
		fp_flag	fpflag = CIRCULANT,
		bool	center = false
	)			[inherited]

Calculate Cross-Correlation Function (CCF).

Calculate the correlation of two 1-, 2-, or 3-dimensional images. Note: this method internally just calls the correlation function from fundamentals.h.

Parameters:

[in]	with	The image used to calculate the CCF. If 'with' is NULL, the autocorrelation function is computed instead.
[in]	fpflag	Specify how periodicity (or normalization) should be handled. See fundamentals.h The default is "CIRCULANT". for specific flags.
	center	whether or not to center the image (bring bottom left corner to center)

Returns:

Real-space image.

Exceptions:

ImageDimensionException

if nx > 1 and nx < 2*radius + 1

Definition at line 1408 of file emdata.cpp.

References EMAN::EMData::clip_inplace(), EMAN::convolution(), EMAN::correlation(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::EMData::nx, EMAN::EMData::ny, and EMAN::EMData::nz.

Referenced by EMAN::TranslationalAligner::align(), EMAN::EMData::calc_flcf(), EMAN::TomoDotCmp::cmp(), EMAN::EMData::make_rotational_footprint(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest().

{
        ENTERFUNC;
        if( with == 0 ) {
                EXITFUNC;
                return convolution(this,this,fpflag, center);
        }
        else if ( with == this ){ // this if statement is not necessary, the correlation function tests to see if with == this
                EXITFUNC;
                return correlation(this, this, fpflag,center);
        }
        else {
                
#ifdef EMAN2_USING_CUDA
                if (gpu_operation_preferred()) {
                        EXITFUNC;
                        return calc_ccf_cuda(with,false,center);
                }
#endif
                
                // If the argument EMData pointer is not the same size we automatically resize it
                bool undoresize = false;
                int wnx = with->get_xsize(); int wny = with->get_ysize(); int wnz = with->get_zsize();
                if ( wnx != nx || wny != ny || wnz != nz ) {
                        Region r((wnx-nx)/2, (wny-ny)/2, (wnz-nz)/2,nx,ny,nz);
                        with->clip_inplace(r);
                        undoresize = true;
                }

                EMData* cor = correlation(this, with, fpflag, center);

                // If the argument EMData pointer was resized, it is returned to its original dimensions
                if ( undoresize ) {
                        Region r((nx-wnx)/2, (ny-wny)/2,(nz-wnz)/2,wnx,wny,wnz);
                        with->clip_inplace(r);
                }

                EXITFUNC;
                return cor;
        }
}

EMData * EMData::calc_ccfx	(	EMData *const	with,
		int	y0 = 0,
		int	y1 = -1,
		bool	nosum = false
	)			[inherited]

Calculate Cross-Correlation Function (CCF) in the x-direction and adds them up, result in 1D.

WARNING: this routine will modify the 'this' and 'with' to contain 1D fft's without setting some flags. This is an optimization for rotational alignment.

Parameters:

	with	The image used to calculate CCF.
	y0	Starting position in x-direction.
	y1	Ending position in x-direction. '-1' means the end of the row.
	nosum	If true, returns an image y1-y0+1 pixels high.

See also:

calc_ccf()

Exceptions:

	NullPointerException	If input image 'with' is NULL.
	ImageFormatException	If 'with' and 'this' are not same size.
	ImageDimensionException	If 'this' image is 3D.

Returns:

The result image containing the CCF.

Definition at line 1450 of file emdata.cpp.

References EMAN::EMData::EMData(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, ImageFormatException, EMAN::EMData::is_complex_x(), EMAN::EMUtil::is_same_size(), LOGERR, NullPointerException, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::set_size(), EMAN::EMData::to_zero(), and EMAN::EMData::update().

Referenced by EMAN::RTFExhaustiveAligner::align(), EMAN::RotatePrecenterAligner::align(), EMAN::RotationalAligner::align_180_ambiguous(), and EMAN::EMData::make_footprint().

{
        ENTERFUNC;

#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred() ) {
                EXITFUNC;
                return calc_ccfx_cuda(with,y0,y1,no_sum);
        }
#endif

        if (!with) {
                LOGERR("NULL 'with' image. ");
                throw NullPointerException("NULL input image");
        }

        if (!EMUtil::is_same_size(this, with)) {
                LOGERR("images not same size: (%d,%d,%d) != (%d,%d,%d)",
                           nx, ny, nz,
                           with->get_xsize(), with->get_ysize(), with->get_zsize());
                throw ImageFormatException("images not same size");
        }
        if (get_ndim() > 2) {
                LOGERR("2D images only");
                throw ImageDimensionException("2D images only");
        }

        if (y1 <= y0) {
                y1 = ny;
        }

        if (y0 >= y1) {
                y0 = 0;
        }

        if (y0 < 0) {
                y0 = 0;
        }

        if (y1 > ny) {
                y1 = ny;
        }
        if (is_complex_x() || with->is_complex_x() ) throw; // Woops don't support this anymore!

        static int nx_fft = 0;
        static int ny_fft = 0;
        static EMData f1;
        static EMData f2;
        static EMData rslt;

        int height = y1-y0;
        int width = (nx+2-(nx%2));
        if (width != nx_fft || height != ny_fft ) {
                f1.set_size(width,height);
                f2.set_size(width,height);
                rslt.set_size(nx,height);
                nx_fft = width;
                ny_fft = height;
        }

        float *d1 = get_data();
        float *d2 = with->get_data();
        float *f1d = f1.get_data();
        float *f2d = f2.get_data();
        for (int j = 0; j < height; j++) {
                EMfft::real_to_complex_1d(d1 + j * nx, f1d+j*width, nx);
                EMfft::real_to_complex_1d(d2 + j * nx, f2d+j*width, nx);
        }

        for (int j = 0; j < height; j++) {
                float *f1a = f1d + j * width;
                float *f2a = f2d + j * width;

                for (int i = 0; i < width / 2; i++) {
                        float re1 = f1a[2*i];
                        float re2 = f2a[2*i];
                        float im1 = f1a[2*i+1];
                        float im2 = f2a[2*i+1];

                        f1d[j*width+i*2] = re1 * re2 + im1 * im2;
                        f1d[j*width+i*2+1] = im1 * re2 - re1 * im2;
                }
        }

        float* rd = rslt.get_data();
        for (int j = y0; j < y1; j++) {
                EMfft::complex_to_real_1d(f1d+j*width, rd+j*nx, nx);
        }

        if (no_sum) {
                rslt.update(); // This is important in terms of the copy - the returned object won't have the correct flags unless we do this
                EXITFUNC;
                return new EMData(rslt);
        } else {
                EMData *cf = new EMData(nx,1,1);
                cf->to_zero();
                float *c = cf->get_data();
                for (int j = 0; j < height; j++) {
                        for(int i = 0; i < nx; ++i) {
                                c[i] += rd[i+j*nx];
                        }
                }
                cf->update();
                EXITFUNC;
                return cf;
        }
}

EMData* do_fft

(

)

const

$Id$

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 fast fourier transform (FFT) image of the current image. the current image is not changed. The result is in real/imaginary format.

Returns:

The FFT of the current image in real/imaginary format.

EMData * EMData::do_fft

(

)

const [inherited]

For fft, wavelet, insert data.

$Id$ 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 fast fourier transform (FFT) image of the current image. the current image is not changed. The result is in real/imaginary format.

Returns:

The FFT of the current image in real/imaginary format.

Definition at line 153 of file emdata_transform.cpp.

References EMAN::EMData::copy_head(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageFormatException, EMAN::EMData::is_complex(), LOGERR, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::set_complex(), EMAN::EMData::set_complex_x(), EMAN::EMData::set_fftodd(), EMAN::EMData::set_fftpad(), EMAN::EMData::set_ri(), EMAN::EMData::set_size(), and EMAN::EMData::update().

Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::EMData::bispecRotTransInvDirect(), EMAN::EMData::bispecRotTransInvN(), EMAN::EMData::calc_mutual_correlation(), EMAN::FRCCmp::cmp(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::TomoDotCmp::cmp(), EMAN::EMData::common_lines(), EMAN::EMData::convolute(), EMAN::MatchSFProcessor::create_radial_func(), EMAN::EMData::FourInterpol(), EMAN::EMData::FourTruncate(), main(), EMAN::EMData::make_footprint(), EMAN::TestUtil::make_image_file_by_mode(), EMAN::FFTResampleProcessor::process(), EMAN::Wiener2DFourierProcessor::process(), EMAN::Wiener2DAutoAreaProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), and EMAN::GaussFFTProjector::project3d().

{
        ENTERFUNC;

#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred()) {
                EXITFUNC;
                return do_fft_cuda();
        }
#endif

        if ( is_complex() ) {
                LOGERR("real image expected. Input image is complex image.");
                throw ImageFormatException("real image expected. Input image is complex image.");
        }

        int nxreal = nx;
        int offset = 2 - nx%2;
        int nx2 = nx + offset;
        EMData* dat = copy_head();
        dat->set_size(nx2, ny, nz);
        //dat->to_zero();  // do not need it, real_to_complex will do it right anyway
        if (offset == 1) dat->set_fftodd(true);
        else             dat->set_fftodd(false);

        float *d = dat->get_data();
        //std::cout<<" do_fft "<<rdata[5]<<"  "<<d[5]<<std::endl;
        EMfft::real_to_complex_nd(get_data(), d, nxreal, ny, nz);

        dat->update();
        dat->set_fftpad(true);
        dat->set_complex(true);
        if(dat->get_ysize()==1 && dat->get_zsize()==1) dat->set_complex_x(true);
        dat->set_ri(true);

        EXITFUNC;
        return dat;
}

EMData* do_ift

(

)

return the inverse fourier transform (IFT) image of the current image.

the current image may be changed if it is in amplitude/phase format as opposed to real/imaginary format - if this change is performed it is not undone.

Exceptions:

ImageFormatException

If the image is not a complex image.

Returns:

The current image's inverse fourier transform image.

EMData * EMData::do_ift

(

)

[inherited]

return the inverse fourier transform (IFT) image of the current image.

the current image may be changed if it is in amplitude/phase format as opposed to real/imaginary format - if this change is performed it is not undone.

Exceptions:

ImageFormatException

If the image is not a complex image.

Returns:

The current image's inverse fourier transform image.

Definition at line 240 of file emdata_transform.cpp.

References EMAN::EMData::ap2ri(), EMAN::EMData::copy_head(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageFormatException, EMAN::EMData::is_complex(), EMAN::EMData::is_fftodd(), EMAN::EMData::is_ri(), LOGERR, LOGWARN, EMAN::EMData::mult(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::rdata, EMAN::EMData::set_complex(), EMAN::EMData::set_complex_x(), EMAN::EMData::set_fftodd(), EMAN::EMData::set_fftpad(), EMAN::EMData::set_ri(), EMAN::EMData::set_size(), and EMAN::EMData::update().

Referenced by EMAN::EMData::calc_mutual_correlation(), EMAN::OptVarianceCmp::cmp(), EMAN::EMData::convolute(), EMAN::EMData::FH2Real(), EMAN::CtfAverager::finish(), EMAN::CtfCWautoAverager::finish(), main(), EMAN::EMData::make_footprint(), EMAN::PointArray::pdb2mrc_by_nfft(), EMAN::Wiener2DFourierProcessor::process(), EMAN::FileFourierProcessor::process_inplace(), EMAN::SNRProcessor::process_inplace(), EMAN::AmpweightFourierProcessor::process_inplace(), EMAN::FourierAnlProcessor::process_inplace(), EMAN::FourierProcessor::process_inplace(), EMAN::ImageProcessor::process_inplace(), and EMAN::GaussFFTProjector::project3d().

{
        ENTERFUNC;

#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred()) {
                EXITFUNC;
                return do_ift_cuda();
        }
#endif

        if (!is_complex()) {
                LOGERR("complex image expected. Input image is real image.");
                throw ImageFormatException("complex image expected. Input image is real image.");
        }

        if (!is_ri()) {
                LOGWARN("run IFT on AP data, only RI should be used. Converting.");
        }

        get_data(); // Required call if GPU caching is being used. Otherwise harmless
        EMData* dat = copy_head();
        dat->set_size(nx, ny, nz);
        ap2ri();

        float *d = dat->get_data();
        int ndim = get_ndim();

        /* Do inplace IFT on a image copy, because the complex to real transform of
         * nd will destroy its input array even for out-of-place transforms.
         */
        memcpy((char *) d, (char *) rdata, nx * ny * nz * sizeof(float));

        int offset = is_fftodd() ? 1 : 2;
        //cout << "Sending offset " << offset << " " << nx-offset << endl;
        if (ndim == 1) {
                EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz);
        } else {
                EMfft::complex_to_real_nd(d, d, nx - offset, ny, nz);

#ifndef CUDA_FFT
                size_t row_size = (nx - offset) * sizeof(float);
                for (int i = 1; i < ny * nz; i++) {
                        memmove((char *) &d[i * (nx - offset)], (char *) &d[i * nx], row_size);
                }
#endif
        }

        dat->set_size(nx - offset, ny, nz);     //remove the padding
#if defined     FFTW2 || defined FFTW3  || defined CUDA_FFT //native fft and ACML already done normalization
        // SCALE the inverse FFT
        float scale = 1.0f / ((nx - offset) * ny * nz);
        dat->mult(scale);
#endif  //FFTW2 || FFTW3
        dat->set_fftodd(false);
        dat->set_fftpad(false);
        dat->set_complex(false);
        if(dat->get_ysize()==1 && dat->get_zsize()==1)  dat->set_complex_x(false);
        dat->set_ri(false);
        dat->update();


        EXITFUNC;
        return dat;
}

EMData::EMData

(

const EMData &

that

)

[inherited]

Construct from an EMData (copy constructor).

Performs a deep copy

Parameters:

that

the EMData to copy

Definition at line 123 of file emdata.cpp.

References data, EMAN::EMUtil::em_malloc(), EMAN::EMUtil::em_memcpy(), EMAN::EMData::EMData(), EMAN::EMData::EMDATA_GPU_RO_NEEDS_UPDATE, ENTERFUNC, EMAN::EMData::flags, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::rdata, EMAN::EMData::rot_fp, EMAN::EMData::totalalloc, and UnexpectedBehaviorException.

                                 :
#ifdef EMAN2_USING_CUDA
                cuda_cache_handle(-1),
#endif //EMAN2_USING_CUDA
                attr_dict(that.attr_dict), rdata(0), supp(0), flags(that.flags), changecount(that.changecount), nx(that.nx), ny(that.ny), nz(that.nz),
                nxy(that.nx*that.ny), xoff(that.xoff), yoff(that.yoff), zoff(that.zoff),all_translation(that.all_translation),  path(that.path),
                pathnum(that.pathnum), rot_fp(0)
{
        ENTERFUNC;

        float* data = that.rdata;
        size_t num_bytes = nx*ny*nz*sizeof(float);
        if (data && num_bytes != 0)
        {
                rdata = (float*)EMUtil::em_malloc(num_bytes);
                EMUtil::em_memcpy(rdata, data, num_bytes);
        }
#ifdef EMAN2_USING_CUDA
        if (num_bytes != 0 && that.cuda_cache_handle != -1 && that.gpu_rw_is_current()) {
                float * cuda_data = that.get_cuda_data();
                CudaDataLock lock2(&that);
                set_size_cuda(nx,ny,nz);
                float *cd = get_cuda_data();
                CudaDataLock lock1(this);
                cudaError_t error = cudaMemcpy(cd,cuda_data,num_bytes,cudaMemcpyDeviceToDevice);
                if ( error != cudaSuccess ) throw UnexpectedBehaviorException("cudaMemcpy failed in EMData copy construction with error: " + string(cudaGetErrorString(error)));
        }
        // This is a bit of hack
        flags |= EMDATA_GPU_RO_NEEDS_UPDATE;
#endif //EMAN2_USING_CUDA
        if (that.rot_fp != 0) rot_fp = new EMData(*(that.rot_fp));

        EMData::totalalloc++;

        ENTERFUNC;
}

EMData * EMData::get_clip	(	const Region &	area,
		const float	fill = 0
	)			const [inherited]

Get an inclusive clip.

Pads to fill if larger than this image.

Parameters:

	area	The clip area, can be 2D/3D
	fill	the value to assign new pixels outside the area of the original image

Exceptions:

ImageDimensionException

if any of the dimensions of the argument region are negative

Returns:

The clip image.

Definition at line 543 of file emdata.cpp.

References EMAN::EMData::attr_dict, EMAN::EMData::EMData(), ENTERFUNC, EXITFUNC, EMAN::Region::get_ndim(), EMAN::EMData::get_ndim(), EMAN::Dict::has_key(), ImageDimensionException, EMAN::EMData::insert_clip(), LOGERR, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::Region::origin, EMAN::EMData::path, EMAN::EMData::pathnum, EMAN::EMData::set_path(), EMAN::EMData::set_pathnum(), EMAN::EMData::set_size(), EMAN::EMData::set_xyz_origin(), EMAN::Region::size, EMAN::EMData::to_value(), and EMAN::EMData::update().

Referenced by EMAN::EMData::calc_fast_sigma_image(), main(), EMAN::EMData::make_footprint(), EMAN::ScaleTransformProcessor::process(), EMAN::IntTranslateProcessor::process(), EMAN::SNRProcessor::process_inplace(), EMAN::CutoffBlockProcessor::process_inplace(), and EMAN::EMData::window_center().

{
        ENTERFUNC;
        if (get_ndim() != area.get_ndim()) {
                LOGERR("cannot get %dD clip out of %dD image", area.get_ndim(),get_ndim());
                return 0;
        }

        EMData *result = new EMData();

        // Ensure that all of the metadata of this is stored in the new object
        // Originally added to ensure that euler angles were retained when preprocessing (zero padding) images
        // prior to insertion into the 3D for volume in the reconstruction phase (see reconstructor.cpp/h).
        result->attr_dict = this->attr_dict;
        int zsize = (int)area.size[2];
        if (zsize == 0 && nz <= 1) {
                zsize = 1;
        }
        int ysize = (ny<=1 && (int)area.size[1]==0 ? 1 : (int)area.size[1]);

        if ( (int)area.size[0] < 0 || ysize < 0 || zsize < 0 )
        {
                // Negative image dimensions not supported - added retrospectively by d.woolford (who didn't write get_clip but wrote clip_inplace)
                throw ImageDimensionException("New image dimensions are negative - this is not supported in the the get_clip operation");
        }

#ifdef EMAN2_USING_CUDA
        // Strategy is always to prefer using the GPU if possible
        bool use_gpu = false;
        if ( gpu_operation_preferred() ) {
                result->set_size_cuda((int)area.size[0], ysize, zsize);
                //CudaDataLock lock(this); // Just so we never have to recopy this data to and from the GPU
                result->get_cuda_data(); // Force the allocation - set_size_cuda is lazy
                // Setting the value is necessary seeing as cuda data is not automatically zeroed
                result->to_value(fill); // This will automatically use the GPU.
                use_gpu = true;
        } else { // cpu == True
                result->set_size((int)area.size[0], ysize, zsize);
                if (fill != 0.0) { result->to_value(fill); };
        }
#else
        result->set_size((int)area.size[0], ysize, zsize);
        if (fill != 0.0) { result->to_value(fill); };
#endif //EMAN2_USING_CUDA

        int x0 = (int) area.origin[0];
        x0 = x0 < 0 ? 0 : x0;

        int y0 = (int) area.origin[1];
        y0 = y0 < 0 ? 0 : y0;

        int z0 = (int) area.origin[2];
        z0 = z0 < 0 ? 0 : z0;

        int x1 = (int) (area.origin[0] + area.size[0]);
        x1 = x1 > nx ? nx : x1;

        int y1 = (int) (area.origin[1] + area.size[1]);
        y1 = y1 > ny ? ny : y1;

        int z1 = (int) (area.origin[2] + area.size[2]);
        z1 = z1 > nz ? nz : z1;
        if (z1 <= 0) {
                z1 = 1;
        }

        result->insert_clip(this,-((IntPoint)area.origin));

        if( attr_dict.has_key("apix_x") && attr_dict.has_key("apix_y") &&
                attr_dict.has_key("apix_z") )
        {
                if( attr_dict.has_key("origin_x") && attr_dict.has_key("origin_y") &&
                    attr_dict.has_key("origin_z") )
                {
                        float xorigin = attr_dict["origin_x"];
                        float yorigin = attr_dict["origin_y"];
                        float zorigin = attr_dict["origin_z"];

                        float apix_x = attr_dict["apix_x"];
                        float apix_y = attr_dict["apix_y"];
                        float apix_z = attr_dict["apix_z"];

                        result->set_xyz_origin(xorigin + apix_x * area.origin[0],
                                                                   yorigin + apix_y * area.origin[1],
                                                               zorigin + apix_z * area.origin[2]);
                }
        }

#ifdef EMAN2_USING_CUDA
        if (use_gpu) result->gpu_update();
        else result->update();
#else
        result->update();
#endif // EMAN2_USING_CUDA


        result->set_path(path);
        result->set_pathnum(pathnum);

        EXITFUNC;
        return result;
}

void insert_clip	(	const EMData *const	block,
		const IntPoint &	origin
	)

Insert a clip into this image.

Very robust clip insertion code works in all way you might think possible

Parameters:

	block	An image block.
	origin	The origin location to insert the clip. ( )

void EMData::insert_clip	(	const EMData *const	block,
		const IntPoint &	origin
	)			[inherited]

Insert a clip into this image.

Very robust clip insertion code works in all way you might think possible

Parameters:

	block	An image block.
	origin	The origin location to insert the clip. ( )

Definition at line 1706 of file emdata_transform.cpp.

References EMAN::EMUtil::em_memcpy(), EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::Region::origin, EMAN::Region::size, UnexpectedBehaviorException, and EMAN::EMData::update().

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

                                                                           {
        int nx1 = block->get_xsize();
        int ny1 = block->get_ysize();
        int nz1 = block->get_zsize();

        Region area(origin[0], origin[1], origin[2],nx1, ny1, nz1);

        int x0 = (int) area.origin[0];
        x0 = x0 < 0 ? 0 : x0;

        int y0 = (int) area.origin[1];
        y0 = y0 < 0 ? 0 : y0;

        int z0 = (int) area.origin[2];
        z0 = z0 < 0 ? 0 : z0;

        int x1 = (int) (area.origin[0] + area.size[0]);
        x1 = x1 > nx ? nx : x1;

        int y1 = (int) (area.origin[1] + area.size[1]);
        y1 = y1 > ny ? ny : y1;

        int z1 = (int) (area.origin[2] + area.size[2]);
        z1 = z1 > nz ? nz : z1;
        if (z1 <= 0) {
                z1 = 1;
        }

        int xd0 = (int) (area.origin[0] < 0 ? -area.origin[0] : 0);
        int yd0 = (int) (area.origin[1] < 0 ? -area.origin[1] : 0);
        int zd0 = (int) (area.origin[2] < 0 ? -area.origin[2] : 0);

        if (x1 < x0 || y1 < y0 || z1 < z0) return; // out of bounds, this is fine, nothing happens

        size_t clipped_row_size = (x1-x0) * sizeof(float);
        int src_secsize =  nx1 * ny1;
        int dst_secsize = nx * ny;

#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred()) {
//              cudaMemcpy3DParms copyParams = {0};
//              copyParams.srcPtr   = make_cudaPitchedPtr((void*)get_cuda_data(), nx*sizeof(float), nx, ny);
//              cout << "Src pos is " << x0 << " " << y0 << " " << z0 << endl;
//              copyParams.srcPos  = make_cudaPos(x0,y0,z0);
//              cout << "Extent is " << x1-x0 << " " << y1-y0 << " " << z1-z0 << endl;
//              cudaExtent extent = make_cudaExtent(x1-x0,y1-y0,z1-z0);
//              int rnx = result->get_xsize();
//              int rny = result->get_ysize();
//              copyParams.dstPtr = make_cudaPitchedPtr((void*)result->get_cuda_data(),rnx*sizeof(float),rnx,rny );
//              cout << "Dest pos is " << xd0 << " " << yd0 << " " << zd0 << endl;
//              copyParams.dstPos  = make_cudaPos(xd0,yd0,zd0);
//              copyParams.extent   = extent;
//              copyParams.kind     = cudaMemcpyDeviceToDevice;
//              cudaError_t error =  cudaMemcpy3D(&copyParams);
//              if ( error != cudaSuccess) {
//                      string e = cudaGetErrorString(error);
//                      throw UnexpectedBehaviorException("CudaMemcpy3D failed with error: " + e);
//              }
                get_cuda_data();
                CudaDataLock lock(this);
                block->get_cuda_data();
                CudaDataLock lock2(block);
                for (int i = 0; i < (z1-z0); i++) {
                        float* ldst = get_cuda_data() + (z0+i) * dst_secsize + y0 * nx + x0;
                        float* lsrc = block->get_cuda_data() + (zd0+i) * src_secsize + yd0 * nx1 + xd0;


//                      float* ldst = result->get_cuda_data() + (zd0+i) * dst_secsize + yd0 * (int)area.size[0] + xd0;
//                      float* lsrc = get_cuda_data() + (z0+i) * src_secsize + y0 * nx + x0;
                        cudaError_t error =  cudaMemcpy2D( ldst, (nx)*sizeof(float), lsrc,nx1*sizeof(float), clipped_row_size, (y1-y0), cudaMemcpyDeviceToDevice );
                        if ( error != cudaSuccess) {
                                string e = cudaGetErrorString(error);
                                throw UnexpectedBehaviorException("cudaMemcpy2D failed in get_clip with error: " + e);
                        }
                }
                gpu_update();
                EXITFUNC;
                return;
        }
#endif
        float *src = block->get_data() + zd0 * src_secsize + yd0 * nx1 + xd0;
        float *dst = get_data() + z0 * dst_secsize + y0 * nx + x0;

//              float *src = get_data() + z0 * src_secsize + y0 * nx + x0;
//              float *dst = result->get_data();
//              dst += zd0 * dst_secsize + yd0 * (int)area.size[0] + xd0;

        int src_gap = src_secsize - (y1-y0) * nx1;
        int dst_gap = dst_secsize - (y1-y0) * nx;
        for (int i = z0; i < z1; i++) {
                for (int j = y0; j < y1; j++) {
                        EMUtil::em_memcpy(dst, src, clipped_row_size);
                        src += nx1;
                        dst += nx;
                }
                src += src_gap;
                dst += dst_gap;
        }

        update();
        EXITFUNC;
}

EMData * EMData::make_rotational_footprint

(

bool

unwrap = true

)

[inherited]

Makes a 'rotational footprint', which is an 'unwound' autocorrelation function.

generally the image should be edge-normalized and masked before using this.

Parameters:

unwrap

RFP undergoes polar->cartesian x-form

Exceptions:

ImageFormatException

If image size is not even.

Returns:

The rotaional footprint image.

Definition at line 1610 of file emdata.cpp.

References EMAN::EMData::calc_ccf(), EMAN::CIRCULANT, EMAN::EMData::EMData(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_edge_mean(), EMAN::EMData::rot_fp, EMAN::EMData::sub(), EMAN::EMData::unwrap(), and EMAN::EMData::update_stat().

Referenced by EMAN::RotationalAligner::align_180_ambiguous(), and main().

                                                      {
        ENTERFUNC;
        update_stat();
        // Note that rotational_footprint caching saves a large amount of time
        // but this is at the expense of memory. Note that a policy is hardcoded here,
        // that is that caching is only employed when premasked is false and unwrap
        // is true - this is probably going to be what is used in most scenarios
        // as advised by Steve Ludtke - In terms of performance this caching doubles the metric
        // generated by e2speedtest.
        if ( rot_fp != 0 && unwrap == true) {
                return new EMData(*rot_fp);
        }

        EMData* ccf = this->calc_ccf(this,CIRCULANT,true);
        ccf->sub(ccf->get_edge_mean());
        //ccf->process_inplace("xform.phaseorigin.tocenter"); ccf did the centering
        EMData *result = ccf->unwrap();
        delete ccf; ccf = 0;

        EXITFUNC;
        if ( unwrap == true)
        { // this if statement reflects a strict policy of caching in only one scenario see comments at beginning of function block

// Note that the if statement at the beginning of this function ensures that rot_fp is not zero, so there is no need
// to throw any exception
// if ( rot_fp != 0 ) throw UnexpectedBehaviorException("The rotational foot print is only expected to be cached if it is not NULL");

// Here is where the caching occurs - the rot_fp takes ownsherhip of the pointer, and a deep copied EMData object is returned.
// The deep copy invokes a cost in terms of CPU cycles and memory, but prevents the need for complicated memory management (reference counting)
                rot_fp = result;
                return new EMData(*rot_fp);
        }
        else return result;
}

EMData & EMData::operator=

(

const EMData &

that

)

[inherited]

EMData assignment operator Performs a deep copy.

Parameters:

that

the EMData to copy

Definition at line 160 of file emdata.cpp.

References EMAN::EMData::all_translation, EMAN::EMData::attr_dict, EMAN::EMData::changecount, data, EMAN::EMUtil::em_memcpy(), EMAN::EMData::EMData(), EMAN::EMData::EMDATA_GPU_RO_NEEDS_UPDATE, ENTERFUNC, EXITFUNC, EMAN::EMData::flags, EMAN::EMData::free_memory(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::path, EMAN::EMData::pathnum, EMAN::EMData::rdata, EMAN::EMData::rot_fp, EMAN::EMData::set_size(), UnexpectedBehaviorException, EMAN::EMData::xoff, EMAN::EMData::yoff, and EMAN::EMData::zoff.

{
        ENTERFUNC;

        if ( this != &that )
        {
                free_memory(); // Free memory sets nx,ny and nz to 0

                // Only copy the rdata if it exists, we could be in a scenario where only the header has been read
                float* data = that.rdata;
                size_t num_bytes = that.nx*that.ny*that.nz*sizeof(float);
                if (data && num_bytes != 0)
                {
                        nx = 1; // This prevents a memset in set_size
                        set_size(that.nx,that.ny,that.nz);
                        EMUtil::em_memcpy(rdata, data, num_bytes);
                }

                flags = that.flags;

                all_translation = that.all_translation;

                path = that.path;
                pathnum = that.pathnum;
                attr_dict = that.attr_dict;

                xoff = that.xoff;
                yoff = that.yoff;
                zoff = that.zoff;

#ifdef EMAN2_USING_CUDA
                free_cuda_memory();
                // There should also be the case where we deal with ro data...
                if (num_bytes != 0 && that.cuda_cache_handle != -1 && that.gpu_rw_is_current()) {
                        float * cuda_data = that.get_cuda_data();
                        CudaDataLock lock1(&that);
                        set_size_cuda(that.nx, that.ny, that.nz);
                        float *cd = get_cuda_data();
                        CudaDataLock lock2(this);
                        cudaError_t error = cudaMemcpy(cd,cuda_data,num_bytes,cudaMemcpyDeviceToDevice);
                        if ( error != cudaSuccess ) throw UnexpectedBehaviorException("cudaMemcpy failed in operator= with error: " + string(cudaGetErrorString(error)));
                }
                // This is a bit of hack
                flags &= EMDATA_GPU_RO_NEEDS_UPDATE;
#endif //EMAN2_USING_CUDA

                changecount = that.changecount;

                if (that.rot_fp != 0) rot_fp = new EMData(*(that.rot_fp));
                else rot_fp = 0;
        }
        EXITFUNC;
        return *this;
}

void ri2ap

(

)

convert the complex image from real/imaginary to amplitude/phase

void EMData::ri2ap

(

)

[inherited]

convert the complex image from real/imaginary to amplitude/phase

Definition at line 940 of file emdata_transform.cpp.

References data, emdata_ri2ap(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::is_complex(), EMAN::EMData::is_ri(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::set_ri(), and EMAN::EMData::update().

Referenced by EMAN::EMData::add_incoherent(), EMAN::PhaseCmp::cmp(), EMAN::OptVarianceCmp::cmp(), EMAN::EMData::get_fft_amplitude(), EMAN::EMData::get_fft_phase(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), EMAN::BinarizeFourierProcessor::process_inplace(), EMAN::RealToFFTProcessor::process_inplace(), EMAN::ComplexPixelProcessor::process_inplace(), EMAN::EMData::render_amp24(), and EMAN::EMData::render_ap24().

{
        ENTERFUNC;

        if (!is_complex() || !is_ri()) {
                return;
        }
#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred()) {
                EMDataForCuda tmp = get_data_struct_for_cuda();
                emdata_ri2ap(&tmp);
                set_ri(false);
                gpu_update();
                EXITFUNC;
                return;
        }
#endif

        float * data = get_data();

        size_t size = nx * ny * nz;
        for (size_t i = 0; i < size; i += 2) {
#ifdef  _WIN32
                float f = (float)_hypot(data[i], data[i + 1]);
#else
                float f = (float)hypot(data[i], data[i + 1]);
#endif
                if (data[i] == 0 && data[i + 1] == 0) {
                        data[i + 1] = 0;
                }
                else {
                        data[i + 1] = atan2(data[i + 1], data[i]);
                }
                data[i] = f;
        }

        set_ri(false);
        update();
        EXITFUNC;
}

void ri2inten

(

)

convert the complex image from real/imaginary to Intensity/0.

This conversion cannot be reversed, and the image remains marked as R/I

void EMData::ri2inten

(

)

[inherited]

convert the complex image from real/imaginary to Intensity/0.

This conversion cannot be reversed, and the image remains marked as R/I

Definition at line 909 of file emdata_transform.cpp.

References EMAN::EMData::ap2ri(), data, emdata_ri2inten(), ENTERFUNC, EXITFUNC, EMAN::EMData::get_data(), EMAN::EMData::is_complex(), EMAN::EMData::is_ri(), EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::nz, EMAN::EMData::set_attr(), and EMAN::EMData::update().

Referenced by EMAN::CTFSNRWeightProcessor::process_inplace().

{
        ENTERFUNC;

        if (!is_complex()) return;
        if (!is_ri()) ap2ri();

#ifdef EMAN2_USING_CUDA
        if (gpu_operation_preferred()) {
                EMDataForCuda tmp = get_data_struct_for_cuda();
                emdata_ri2inten(&tmp);
                set_attr("is_intensity", int(1));
                gpu_update();
                EXITFUNC;
                return;
        }
#endif

        float * data = get_data();
        size_t size = nx * ny * nz;
        for (size_t i = 0; i < size; i += 2) {
                data[i]=data[i]*data[i]+data[i+1]*data[i+1];
                data[i+1]=0;
        }

        set_attr("is_intensity", int(1));
        update();
        EXITFUNC;
}

EMData * EMData::unwrap	(	int	r1 = -1,
		int	r2 = -1,
		int	xs = -1,
		int	dx = 0,
		int	dy = 0,
		bool	do360 = false,
		bool	weight_radial = true
	)			const [inherited]

Maps to polar coordinates from Cartesian coordinates.

Optionaly radially weighted. When used with RFP, this provides 1 pixel accuracy at 75% radius. 2D only.

Parameters:

	r1
	r2
	xs
	dx
	dy
	do360	If true, do 0-360 degree mapping. Otherwise, do 0-180 degree mapping.
	weight_radial	if true (default) reights the pixel value by its radius

Exceptions:

	ImageDimensionException	If 'this' image is not 2D.
	UnexpectedBehaviorException	if the dimension of this image and the function arguments are incompatibale - i.e. the return image is less than 0 in some dimension.

Returns:

The image in Cartesian coordinates.

Definition at line 2269 of file emdata.cpp.

References EMAN::Util::bilinear_interpolate(), EMAN::EMData::EMData(), emdata_unwrap(), ENTERFUNC, EXITFUNC, EMAN::Util::fast_floor(), EMAN::EMData::get_const_data(), EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), ImageDimensionException, EMAN::EMData::nx, EMAN::EMData::ny, EMAN::EMData::set_size(), t, unbind_cuda_texture(), UnexpectedBehaviorException, EMAN::EMData::update(), x, and y.

Referenced by EMAN::RTFExhaustiveAligner::align(), EMAN::RotatePrecenterAligner::align(), EMAN::EMData::make_rotational_footprint(), EMAN::EMData::make_rotational_footprint_cmc(), and EMAN::EMData::make_rotational_footprint_e1().

{
        ENTERFUNC;

        if (get_ndim() != 2) {
                throw ImageDimensionException("2D image only");
        }

        int p = 1;
        if (do360) {
                p = 2;
        }

        if (xs < 1) {
                xs = (int) Util::fast_floor(p * M_PI * ny / 4);
                xs -= xs % 8;
                if (xs<=8) xs=16;
        }

        if (r1 < 0) {
                r1 = 4;
        }

#ifdef  _WIN32
        int rr = ny / 2 - 2 - (int) Util::fast_floor(static_cast<float>(_hypot(dx, dy)));
#else
        int rr = ny / 2 - 2 - (int) Util::fast_floor(static_cast<float>(hypot(dx, dy)));
#endif  //_WIN32
        rr-=rr%2;
        if (r2 <= r1 || r2 > rr) {
                r2 = rr;
        }

        if ( (r2-r1) < 0 ) throw UnexpectedBehaviorException("The combination of function the arguments and the image dimensions causes unexpected behavior internally. Use a larger image, or a smaller value of r1, or a combination of both");

#ifdef EMAN2_USING_CUDA
        if ( gpu_operation_preferred() ) {
//              cout << "Binding " << cuda_cache_handle << endl;
                bind_cuda_texture();
                EMData* rslt = new EMData();
                rslt->set_size_cuda(xs,r2-r1,1);
                EMDataForCuda r = rslt->get_data_struct_for_cuda();
//              CudaDataLock lock1(rslt);
                /*EMDataForCuda* tmp = */emdata_unwrap(&r,r1,r2,xs,p,dx,dy,weight_radial,nx,ny);
                unbind_cuda_texture();
//              EMData* e = new EMData();
//              e->set_gpu_rw_data(tmp->data,tmp->nx,tmp->ny,tmp->nz);
//              free(tmp);
                return  rslt;
        }
#endif

        EMData *ret = new EMData();
        ret->set_size(xs, r2 - r1, 1);
        const float *const d = get_const_data();
        float *dd = ret->get_data();
        float pfac = (float)p/(float)xs;

        int nxon2 = nx/2;
        int nyon2 = ny/2;
        for (int x = 0; x < xs; x++) {
                float ang = x * M_PI * pfac;
                float si = sin(ang);
                float co = cos(ang);

                for (int y = 0; y < r2 - r1; y++) {
                        float ypr1 = (float)y + r1;
                        float xx = ypr1 * co + nxon2 + dx;
                        float yy = ypr1 * si + nyon2 + dy;
//                      float t = xx - Util::fast_floor(xx);
//                      float u = yy - Util::fast_floor(yy);
                        float t = xx - (int)xx;
                        float u = yy - (int)yy;
//                      int k = (int) Util::fast_floor(xx) + (int) (Util::fast_floor(yy)) * nx;
                        int k = (int) xx + ((int) yy) * nx;
                        float val = Util::bilinear_interpolate(d[k], d[k + 1], d[k + nx], d[k + nx+1], t,u);
                        if (weight_radial) val *=  ypr1;
                        dd[x + y * xs] = val;
                }

        }
        ret->update();

        EXITFUNC;
        return ret;
}