This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Functions | |
EMData * | copy () const |
Make a copy of this image including both data and header. | |
EMData * | copy_head () const |
Make an image with a copy of the current image's header. | |
void | add (float f, int keepzero=0) |
add a number to each pixel value of the image. | |
void | add (const EMData &image) |
add a same-size image to this image pixel by pixel. | |
void | addsquare (const EMData &image) |
add the squared value of each pixel from a same-size image to this image. | |
void | sub (float f) |
subtract a float number to each pixel value of the image. | |
void | sub (const EMData &image) |
subtract a same-size image from this image pixel by pixel. | |
void | subsquare (const EMData &image) |
subtract the squared value of each pixel from a same-size image to this image. | |
void | mult (int n) |
multiply an integer number to each pixel value of the image. | |
void | mult (float f) |
multiply a float number to each pixel value of the image. | |
void | mult (const EMData &image, bool prevent_complex_multiplication=false) |
multiply each pixel of this image with each pixel of some other same-size image. | |
void | mult_complex_efficient (const EMData &em, const int radius) |
void | div (float f) |
make each pixel value divided by a float number. | |
void | div (const EMData &image) |
make each pixel value divided by pixel value of another same-size image. | |
void | to_zero () |
Set all the pixel value = 0. | |
void | to_one () |
set all the pixel values = 1. | |
void | to_value (const float &value) |
set all the pixel values to a value. | |
float | dot (EMData *with) |
Dot product 2 images. | |
EMData * | get_row (int row_index) const |
Get one row of a 1D/2D image. | |
void | set_row (const EMData *data, int row_index) |
Set one row of a 1D/2D image. | |
EMData * | get_col (int col_index) const |
Get one column of a 2D images. | |
void | set_col (const EMData *data, int col_index) |
Set one column of a 2D image. | |
float | get_value_at (int x, int y, int z) const |
Get the pixel density value at coordinates (x,y,z). | |
float | get_value_at_index (int i) |
Get the pixel density value at index i. | |
float | get_value_at (int x, int y) const |
Get the pixel density value at coordinates (x,y). | |
float | get_value_at (size_t i) const |
Get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array. | |
std::complex< float > | get_complex_at (const int &x, const int &y) const |
Get complex<float> value at x,y. | |
std::complex< float > | get_complex_at (const int &x, const int &y, const int &z) const |
Get complex<float> value at x,y,z. | |
size_t | get_complex_index (const int &x, const int &y, const int &z) const |
Get complex<float> index for coords x,y,z. | |
size_t | get_complex_index (int x, int y, int z, const int &subx0, const int &suby0, const int &subz0, const int &fullnx, const int &fullny, const int &fullnz) const |
size_t | get_complex_index_fast (const int &x, const int &y, const int &z) const |
void | set_complex_at (const int &x, const int &y, const std::complex< float > &val) |
Set complex<float> value at x,y. | |
void | set_complex_at (const int &x, const int &y, const int &z, const std::complex< float > &val) |
Set complex<float> value at x,y,z. | |
size_t | add_complex_at (const int &x, const int &y, const int &z, const std::complex< float > &val) |
Add complex<float> value at x,y,z. | |
size_t | add_complex_at_fast (const int &x, const int &y, const int &z, const std::complex< float > &val) |
size_t | add_complex_at (int x, int y, int z, const int &subx0, const int &suby0, const int &subz0, const int &fullnx, const int &fullny, const int &fullnz, const std::complex< float > &val) |
Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume. | |
float | get_value_at_wrap (int x, int y, int z) const |
Get the pixel density value at coordinates (x,y,z). | |
float | get_value_at_wrap (int x, int y) const |
Get the pixel density value at coordinates (x,y). | |
float | get_value_at_wrap (int x) const |
Get the pixel density value at coordinates (x). | |
float | sget_value_at (int x, int y, int z) const |
A safer, slower way to get the pixel density value at coordinates (x,y,z). | |
float | sget_value_at (int x, int y) const |
A safer, slower way to get the pixel density value at coordinates (x,y). | |
float | sget_value_at (size_t i) const |
A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array. | |
float | sget_value_at_interp (float x, float y) const |
Get pixel density value at interpolation of (x,y). | |
float | sget_value_at_interp (float x, float y, float z) const |
Get the pixel density value at interpolation of (x,y,z). | |
void | set_value_at (int x, int y, int z, float v) |
Set the pixel density value at coordinates (x,y,z). | |
void | set_value_at_fast (int x, int y, int z, float v) |
Set the pixel density value at coordinates (x,y,z). | |
void | set_value_at_index (int i, float v) |
Set the pixel density value at index. | |
void | set_value_at (int x, int y, float v) |
Set the pixel density value at coordinates (x,y). | |
void | set_value_at_fast (int x, int y, float v) |
Set the pixel density value at coordinates (x,y). | |
void | set_value_at (int x, float v) |
Set the pixel density value at coordinate (x). | |
void | set_value_at_fast (int x, float v) |
Set the pixel density value at coordinate (x). | |
void | free_memory () |
Free memory associated with this EMData Called in destructor and in assignment operator. | |
void | free_rdata () |
Free rdata memory associated with this EMData Called in CUDA. | |
EMData & | operator+= (float n) |
EMData & | operator-= (float n) |
EMData & | operator *= (float n) |
EMData & | operator/= (float n) |
EMData & | operator+= (const EMData &em) |
EMData & | operator-= (const EMData &em) |
EMData & | operator *= (const EMData &em) |
EMData & | operator/= (const EMData &em) |
bool | operator== (const EMData &that) const |
bool | equal (const EMData &that) const |
compare the equality of two EMData object based on their pixel values | |
float & | operator() (const int ix, const int iy, const int iz) const |
Overload operator() for array indexing. | |
float & | operator() (const int ix, const int iy) const |
float & | operator() (const size_t ix) const |
void | set_array_offsets (const int xoff_=0, const int yoff_=0, const int zoff_=0) |
Set the array offsets. | |
void | set_array_offsets (vector< int > offsets) |
vector< int > | get_array_offsets () |
std::complex< float > & | cmplx (const int ix, const int iy, const int iz) |
Return reference to complex elements. | |
std::complex< float > & | cmplx (const int ix, const int iy) |
std::complex< float > & | cmplx (const int ix) |
EMData * | power (int n) const |
return a image to the power of n | |
EMData * | sqrt () const |
return square root of current image | |
EMData * | log () const |
return natural logarithm image for a image | |
EMData * | log10 () const |
return base 10 logarithm image for a image | |
EMData * | real () const |
return real part of a complex image as a real image format, if this image is a real image, return a copy of this image. | |
EMData * | imag () const |
return imaginary part of a complex image as a real image format. | |
EMData * | absi () const |
For a real image, it returns a same size image with abs() of each pixel. | |
EMData * | amplitude () const |
return amplitude part of a complex image as a real image format | |
EMData * | phase () const |
return phase part of a complex image as a real image format | |
EMData * | real2complex (float img=0.0f) const |
create a complex image from a real image, this complex image is in real/imaginary format |
|
For a real image, it returns a same size image with abs() of each pixel. For a complex image, it returns a image in size (nx/2,ny,nz), the pixel value output[i]=sqrt(input[i]*input[i]+input[i+1]*input[i+1])
|
|
add a same-size image to this image pixel by pixel.
|
|
add a number to each pixel value of the image. Image may be real or complex.
|
|
Add complex<float> value at x,y,z assuming that 'this' is a subvolume from a larger virtual volume. Requires that parameters often stored in the header as: subvolume_x0,y0,z0 and subvolume_full_nx,ny,nz be passed in as parameters. Otherwise similar to add_complex_at. It will return the index into the subvolume float array at which the complex began, or nx*ny*nz if out of range
|
|
Add complex<float> value at x,y,z. This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. It will return the index into the float array at which the complex began, or nx*ny*nz if out of range
|
|
Definition at line 337 of file emdata_core.h. References nx, ny, rdata, x, and y. 00337 { 00338 //if (x>=nx/2 || y>ny/2 || z>nz/2 || x<=-nx/2 || y<-ny/2 || z<-nz/2) return nxyz; 00339 00340 size_t idx; 00341 if (x<0) { 00342 idx=-x*2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy; 00343 rdata[idx]+=(float)val.real(); 00344 rdata[idx+1]-=(float)val.imag(); 00345 return idx; 00346 } 00347 00348 idx=x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy; 00349 rdata[idx]+=(float)val.real(); 00350 rdata[idx+1]+=(float)val.imag(); 00351 00352 return idx; 00353 }
|
|
add the squared value of each pixel from a same-size image to this image.
|
|
return amplitude part of a complex image as a real image format
Referenced by EMAN::EMAN1Ctf::calc_amplitude(), and EMAN::EMAN1Ctf::calc_ctf1(). |
|
Definition at line 693 of file emdata_core.h. References get_data(), nx, ny, and OutofRangeException. 00693 { 00694 ptrdiff_t pos = 2*(ix-xoff); 00695 #ifdef BOUNDS_CHECKING 00696 if (pos < 0 || pos >= (size_t)nx*ny*nz) 00697 throw OutofRangeException(0, (size_t)nx*ny*nz-1, pos, "EMData"); 00698 #endif // BOUNDS_CHECKING 00699 float* begin = get_data() + pos; 00700 return *(reinterpret_cast<std::complex<float>* >(begin)); 00701 }
|
|
Definition at line 682 of file emdata_core.h. References get_data(), nx, ny, and OutofRangeException. 00682 { 00683 ptrdiff_t pos = 2*(ix-xoff)+(iy-yoff)*nx; 00684 #ifdef BOUNDS_CHECKING 00685 if (pos < 0 || pos >= (size_t)nx*ny*nz) 00686 throw OutofRangeException(0, (size_t)nx*ny*nz-1, pos, "EMData"); 00687 #endif // BOUNDS_CHECKING 00688 float* begin = get_data() + pos; 00689 return *(reinterpret_cast<std::complex<float>* >(begin)); 00690 }
|
|
Return reference to complex elements.
Definition at line 671 of file emdata_core.h. References get_data(), nx, ny, and OutofRangeException. 00671 { 00672 ptrdiff_t pos = 2*(ix-xoff)+((iy-yoff)+(iz-zoff)*ny)*(size_t)nx; 00673 #ifdef BOUNDS_CHECKING 00674 if (pos < 0 || pos >= (size_t)nx*ny*nz) 00675 throw OutofRangeException(0, (size_t)nx*ny*nz-1, pos, "EMData"); 00676 #endif // BOUNDS_CHECKING 00677 float* begin = get_data() + pos; 00678 return *(reinterpret_cast<std::complex<float>* >(begin)); 00679 }
|
|
Make a copy of this image including both data and header.
Referenced by EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::Transform::detect_problem_keys(), EMAN::Dict::Dict(), EMAN::EMData::get_attr(), get_data_as_vector(), EMAN::FloatPoint::operator=(), EMAN::Dict::operator=(), EMAN::RotateInFSProcessor::process(), EMAN::RotateInFSProcessor::process_inplace(), EMAN::MedianShrinkProcessor::process_inplace(), EMAN::WatershedProcessor::process_inplace(), EMAN::MrcIO::transpose(), EMAN::SpiderIO::write_single_header(), EMAN::RT3DSymmetryAligner::xform_align_nbest(), EMAN::RT3DSphereAligner::xform_align_nbest(), and EMAN::RT3DGridAligner::xform_align_nbest(). |
|
Make an image with a copy of the current image's header.
|
|
make each pixel value divided by pixel value of another same-size image.
|
|
make each pixel value divided by a float number.
Referenced by EMAN::Util::calc_least_square_fit(), and EMAN::EMAN2Ctf::compute_1d(). |
|
Dot product 2 images. The 2 images must be of same size. If 'evenonly' is true, only calculates pixels with even positions assuming all pixels are in a single array. If 'evenonly' is false, calculates all pixels. Shortcut for cmp("dot")
Referenced by EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::EMData::little_big_dot(), EMAN::EMData::make_footprint(), and EMAN::EMUtil::vertical_acf(). |
|
compare the equality of two EMData object based on their pixel values
|
|
Free memory associated with this EMData Called in destructor and in assignment operator.
Referenced by EMAN::FourierPixelInserter3D::~FourierPixelInserter3D(), EMAN::FourierPlaneReconstructor::~FourierPlaneReconstructor(), EMAN::FourierReconstructor::~FourierReconstructor(), and EMAN::ReconstructorVolumeData::~ReconstructorVolumeData(). |
|
Free rdata memory associated with this EMData Called in CUDA.
|
|
Definition at line 661 of file emdata_core.h. 00661 {
00662 vector<int> offsets;
00663 offsets.push_back(xoff);
00664 offsets.push_back(yoff);
00665 offsets.push_back(zoff);
00666 return offsets;
00667 }
|
|
Get one column of a 2D images.
|
|
Get complex<float> value at x,y,z. This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
|
|
Get complex<float> value at x,y. This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny image, a nx+2 x ny image will be produced, and values using this function can go from -nx/2-1 to nx/2+1 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
|
|
|
|
Get complex<float> index for coords x,y,z. This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. Note that if a pixel is accessed at this location, a complex conjugate may be required if x<0, and this fact is not returned.
|
|
Definition at line 285 of file emdata_core.h. 00285 { 00286 // if (abs(x)>=nx/2 || abs(y)>ny/2 || abs(z)>nz/2) return nxyz; 00287 if (x<0) { 00288 return (size_t)x*-2+(y<=0?-y:ny-y)*(size_t)nx+(z<=0?-z:nz-z)*(size_t)nxy; 00289 } 00290 return x*2+(y<0?ny+y:y)*(size_t)nx+(z<0?nz+z:z)*(size_t)nxy; 00291 }
|
|
Get one row of a 1D/2D image.
|
|
Get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array. The validity of i is not checked.
Definition at line 237 of file emdata_core.h. References get_data(). Referenced by EMAN::RotateInFSProcessor::process_inplace(), and EMAN::Util::svdcmp(). 00238 { 00239 return get_data()[i]; 00240 }
|
|
Get the pixel density value at coordinates (x,y). 2D only. The validity of x, y is not checked.
Definition at line 224 of file emdata_core.h. References get_data(), x, and y.
|
|
Get the pixel density value at coordinates (x,y,z). The validity of x, y, and z is not checked.
Definition at line 204 of file emdata_core.h. References get_data(), nx, x, and y. 00205 { 00206 return get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy]; 00207 }
|
|
Get the pixel density value at index i.
Definition at line 212 of file emdata_core.h. References rdata. 00213 { 00214 return *(rdata + i); 00215 }
|
|
Get the pixel density value at coordinates (x). Should only be called on 1D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
|
|
Get the pixel density value at coordinates (x,y). Should only be called on 2D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
|
|
Get the pixel density value at coordinates (x,y,z). Should only be called on 3D images - no errors are thrown Wraps pixel values if they are negative - i.e. is circulant For example, if x = -1, then the pixel at nx-1 is returned
|
|
return imaginary part of a complex image as a real image format.
Referenced by EMAN::fourierproduct(), and EMAN::periodogram(). |
|
return natural logarithm image for a image
Referenced by EMAN::LowpassAutoBProcessor::create_radial_func(), EMAN::Util::Crosrng_e(), EMAN::Util::Crosrng_ew(), EMAN::Util::Crosrng_ms(), EMAN::Util::Crosrng_ms_delta(), EMAN::Util::Crosrng_msg(), EMAN::Util::Crosrng_msg_m(), EMAN::Util::Crosrng_msg_s(), EMAN::Util::Crosrng_msg_vec(), EMAN::Util::Crosrng_ns(), EMAN::Util::Crosrng_psi(), EMAN::Util::Crosrng_sm_psi(), EMAN::Util::Frngs(), EMAN::Util::Frngs_inv(), EMAN::EMData::log(), EMAN::PointArray::pdb2mrc_by_summation(), EMAN::NewLowpassGaussProcessor::process_inplace(), EMAN::PointArray::projection_by_summation(), EMAN::Util::pw_extract(), EMAN::PointArray::replace_by_summation(), EMAN::PointArray::set_from_density_map(), slaed0_(), slaed6_(), slartg_(), and sstedc_(). |
|
return base 10 logarithm image for a image
Referenced by EMAN::Processor::EMFourierFilterFunc(), EMAN::EMData::log10(), main(), EMAN::SNRProcessor::process_inplace(), EMAN::LogProcessor::process_pixel(), and EMAN::NewFourierProcessor::setbutterworthdefaults(). |
|
multiply each pixel of this image with each pixel of some other same-size image.
Referenced by mult(). |
|
multiply a float number to each pixel value of the image.
|
|
multiply an integer number to each pixel value of the image.
Definition at line 101 of file emdata_core.h. References mult(). Referenced by EMAN::nnSSNR_ctfReconstructor::insert_padfft_slice(), EMAN::nn4_ctf_rectReconstructor::insert_padfft_slice(), EMAN::nn4_ctfReconstructor::insert_padfft_slice(), EMAN::nnSSNR_Reconstructor::insert_padfft_slice(), EMAN::nn4_rectReconstructor::insert_padfft_slice(), EMAN::nn4Reconstructor::insert_padfft_slice(), EMAN::EMData::insert_rect_slice(), EMAN::EMData::insert_rect_slice_ctf(), EMAN::EMData::insert_rect_slice_ctf_applied(), EMAN::EMData::nn(), EMAN::EMData::nn_ctf(), EMAN::EMData::nn_ctf_applied(), EMAN::EMData::onelinenn_ctf(), EMAN::EMData::onelinenn_ctf_applied(), and EMAN::EMData::onelinenn_mult(). 00102 { 00103 mult((float)n); 00104 }
|
|
|
|
|
|
|
|
Definition at line 639 of file emdata_core.h. References get_data(), nx, ny, and OutofRangeException. 00639 { 00640 ptrdiff_t pos = ix - xoff; 00641 #ifdef BOUNDS_CHECKING 00642 if (pos < 0 || pos >= (size_t)nx*ny*nz) 00643 throw OutofRangeException(0, (size_t)nx*ny*nz-1, pos, "EMData"); 00644 #endif // BOUNDS_CHECKING 00645 return *(get_data() + pos); 00646 }
|
|
Definition at line 627 of file emdata_core.h. References get_data(), nx, ny, and OutofRangeException. 00627 { 00628 ptrdiff_t pos = (ix - xoff) + (iy-yoff)*nx; 00629 #ifdef BOUNDS_CHECKING 00630 if (pos < 0 || pos >= (size_t)nx*ny*nz) 00631 { 00632 throw OutofRangeException(0, (size_t)nx*ny*nz-1, pos, "EMData"); 00633 } 00634 #endif // BOUNDS_CHECKING 00635 return *(get_data() + pos); 00636 }
|
|
Overload operator() for array indexing.
Definition at line 617 of file emdata_core.h. References get_data(), nx, ny, and OutofRangeException. 00617 { 00618 ptrdiff_t pos = (size_t)(ix-xoff) + ((iy-yoff) + (size_t)(iz-zoff)*ny)*nx; 00619 #ifdef BOUNDS_CHECKING 00620 if (pos < 0 || pos >= (size_t)nx*ny*nz) { 00621 throw OutofRangeException(0, (size_t)nx*ny*nz-1, pos, "EMData"); 00622 } 00623 #endif // BOUNDS_CHECKING 00624 return *(get_data() + pos); 00625 }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return phase part of a complex image as a real image format
Referenced by EMAN::TestImageSinewaveCircular::process_inplace(), EMAN::TestImageSinewave::process_inplace(), EMAN::TestImageSphericalWave::process_inplace(), EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::TestImageFourierNoiseGaussian::process_inplace(), and EMAN::Util::tf(). |
|
return a image to the power of n
Referenced by EMAN::WienerFourierReconstructor::do_compare_slice_work(), EMAN::FourierReconstructor::do_compare_slice_work(), EMAN::Util::pack_complex_to_real(), and EMAN::periodogram(). |
|
return real part of a complex image as a real image format, if this image is a real image, return a copy of this image.
Referenced by EMAN::fourierproduct(), and EMAN::periodogram(). |
|
create a complex image from a real image, this complex image is in real/imaginary format
|
|
Definition at line 656 of file emdata_core.h. Referenced by EMAN::EMArray< T >::set_array_offsets(). 00656 { 00657 set_array_offsets(offsets[0],offsets[1],offsets[2]); 00658 }
|
|
Set the array offsets.
Definition at line 650 of file emdata_core.h. 00651 { 00652 xoff=xoff_; yoff=yoff_; zoff=zoff_; 00653 }
|
|
Set one column of a 2D image.
|
|
Set complex<float> value at x,y,z. This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny x nz image, a nx+2 x ny x nz image will be produced, and values using this function can go from -nx/2 to nx/2 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
|
|
Set complex<float> value at x,y. This assumes the image is a standard real/imaginary image with the complex origin in the first memory location. If you take the fft of a real nx x ny image, a nx+2 x ny image will be produced, and values using this function can go from -nx/2-1 to nx/2+1 and -ny/2 to ny/2. It will automatically deal with wraparound and complex conjugate issues for -x. This function differs from cmplx() which will interpret x,y directly as pixel coordinates
|
|
Set one row of a 1D/2D image.
|
|
Set the pixel density value at coordinate (x). 1D image only.
Definition at line 564 of file emdata_core.h. References get_data(), nx, OutofRangeException, and x. Referenced by EMAN::RotateInFSProcessor::process_inplace(). 00565 { 00566 if( x>=nx || x<0 ) 00567 { 00568 throw OutofRangeException(0, nx-1, x, "x dimension index"); 00569 } 00570 else 00571 { 00572 get_data()[x] = v; 00573 flags |= EMDATA_NEEDUPD; 00574 changecount++; 00575 } 00576 }
|
|
Set the pixel density value at coordinates (x,y). 2D image only.
Definition at line 523 of file emdata_core.h. References get_data(), nx, ny, OutofRangeException, x, and y. 00524 { 00525 if( x>=nx || x<0 ) 00526 { 00527 throw OutofRangeException(0, nx-1, x, "x dimension index"); 00528 } 00529 else if( y>=ny || y<0 ) 00530 { 00531 throw OutofRangeException(0, ny-1, y, "y dimension index"); 00532 } 00533 else 00534 { 00535 get_data()[x + y * nx] = v; 00536 flags |= EMDATA_NEEDUPD; 00537 changecount++; 00538 } 00539 }
|
|
Set the pixel density value at coordinates (x,y,z). This implementation does bounds checking.
Definition at line 465 of file emdata_core.h. References get_data(), nx, ny, OutofRangeException, x, and y. 00466 { 00467 if( x>=nx || x<0 ) 00468 { 00469 throw OutofRangeException(0, nx-1, x, "x dimension index"); 00470 } 00471 else if( y>=ny || y<0 ) 00472 { 00473 throw OutofRangeException(0, ny-1, y, "y dimension index"); 00474 } 00475 else if( z>=nz || z<0 ) 00476 { 00477 throw OutofRangeException(0, nz-1, z, "z dimension index"); 00478 } 00479 else 00480 { 00481 get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy] = v; 00482 flags |= EMDATA_NEEDUPD; 00483 changecount++; 00484 } 00485 }
|
|
Set the pixel density value at coordinate (x). 1D image only.
Definition at line 584 of file emdata_core.h. References get_data(). 00585 { 00586 get_data()[x] = v; 00587 flags |= EMDATA_NEEDUPD; 00588 changecount++; 00589 }
|
|
Set the pixel density value at coordinates (x,y). 2D image only. The validity of x, y, is not checked.
Definition at line 549 of file emdata_core.h. References get_data(), x, and y. 00550 { 00551 get_data()[x + y * nx] = v; 00552 flags |= EMDATA_NEEDUPD; 00553 changecount++; 00554 }
|
|
Set the pixel density value at coordinates (x,y,z). The validity of x, y, and z is not checked. This implementation has no bounds checking.
Definition at line 497 of file emdata_core.h. References get_data(), nx, x, and y. 00498 { 00499 get_data()[(size_t)x + (size_t)y * (size_t)nx + (size_t)z * (size_t)nxy] = v; 00500 flags |= EMDATA_NEEDUPD; 00501 changecount++; 00502 }
|
|
Set the pixel density value at index.
Definition at line 510 of file emdata_core.h. References rdata. 00511 { 00512 *(rdata + i) = v; 00513 }
|
|
A safer, slower way to get the pixel density value given an index 'i' assuming the pixles are stored in a 1D array. The validity of i is checked. If i is out of range, return 0;
|
|
A safer, slower way to get the pixel density value at coordinates (x,y). 2D only. The validity of x, y is checked. If the coordinates are out of range, return 0;
|
|
A safer, slower way to get the pixel density value at coordinates (x,y,z). The validity of x, y, and z is checked. If the coordinates are out of range, return 0;
|
|
Get the pixel density value at interpolation of (x,y,z). The validity of x, y, and z is checked.
|
|
Get pixel density value at interpolation of (x,y). The validity of x, y is checked.2D image only.
|
|
|
subtract a same-size image from this image pixel by pixel.
|
|
subtract a float number to each pixel value of the image.
Referenced by EMAN::WienerFourierReconstructor::do_insert_slice_work(), EMAN::FourierReconstructor::setup(), and EMAN::FourierReconstructor::setup_seed(). |
|
subtract the squared value of each pixel from a same-size image to this image.
|
|
set all the pixel values = 1.
|
|
set all the pixel values to a value.
|
|
Set all the pixel value = 0.
|