Classes | |
class | EMAN::Aligner |
Aligner class defines image alignment method. More... | |
class | EMAN::ScaleAlignerABS |
This is an ABS for use in constructing, rt_scale, rt_flip, etc scale aligners. More... | |
class | EMAN::ScaleAligner |
Scale aligner. More... | |
class | EMAN::TranslationalAligner |
Translational 2D Alignment using cross correlation. More... | |
class | EMAN::RotationalAligner |
rotational alignment using angular correlation More... | |
class | EMAN::RotationalAlignerIterative |
rotational alignment using the iterative method (in this case we only do one iteration b/c we are not doing a translation. More... | |
class | EMAN::RotatePrecenterAligner |
rotational alignment assuming centers are correct More... | |
class | EMAN::RotateTranslateAligner |
rotational, translational alignment More... | |
class | EMAN::RotateTranslateScaleAligner |
rotational, translational, scaling alignment More... | |
class | EMAN::RotateTranslateAlignerIterative |
Iterative rotational, translational alignment. More... | |
class | EMAN::RotateTranslateScaleAlignerIterative |
Iterative rotational, translational alignment with scaling. More... | |
class | EMAN::RotateTranslateAlignerPawel |
Rotational, translational alignment by resampling to polar coordinates. More... | |
class | EMAN::RotateTranslateBestAligner |
rotational, translational alignment More... | |
class | EMAN::RotateFlipAligner |
rotational and flip alignment More... | |
class | EMAN::RotateFlipAlignerIterative |
rotational and flip alignment, iterative style More... | |
class | EMAN::RotateTranslateFlipAligner |
rotational, translational and flip alignment More... | |
class | EMAN::RotateTranslateFlipScaleAligner |
rotational, translational, flip, scaling alignment More... | |
class | EMAN::RotateTranslateFlipAlignerIterative |
rotational, translational and flip alignment, iterative style More... | |
class | EMAN::RotateTranslateFlipScaleAlignerIterative |
Iterative rotational, translational alignment with flipping and scaling. More... | |
class | EMAN::RotateTranslateFlipAlignerPawel |
Rotational, translational alignment by resampling to polar coordinates. More... | |
class | EMAN::RTFExhaustiveAligner |
rotational, translational and flip alignment using real-space methods. More... | |
class | EMAN::RTFSlowExhaustiveAligner |
rotational, translational and flip alignment using exhaustive search. More... | |
class | EMAN::SymAlignProcessor |
Aligns a particle with the specified symmetry into the standard orientation for that symmetry. More... | |
class | EMAN::RefineAligner |
refine alignment. More... | |
class | EMAN::RefineAlignerCG |
Conjugate gradient refine alignment. More... | |
class | EMAN::SymAlignProcessorQuat |
Aligns a particle with a specified symetry to its symmetry axis using the simplex multidimensional minimization algorithm. More... | |
class | EMAN::Refine3DAlignerGrid |
Refine alignment. More... | |
class | EMAN::Refine3DAlignerQuaternion |
Refine alignment. More... | |
class | EMAN::RT3DGridAligner |
rotational and translational alignment using a square qrid of Altitude and Azimuth values (the phi range is specifiable) This aligner is ported from the original tomohunter.py - it is less efficient than searching on the sphere (RT3DSphereAligner). More... | |
class | EMAN::RT3DSphereAligner |
3D rotational and translational alignment using spherical sampling, can reduce the search space based on symmetry. More... | |
class | EMAN::RT3DSymmetryAligner |
3D rotational symmetry aligner. More... | |
class | EMAN::FRM2DAligner |
class | EMAN::CUDA_Aligner |
class | EMAN::CUDA_multiref_aligner |
class | EMAN::AmiraIO |
Amira file = ASCII header + binary data. More... | |
class | EMAN::Analyzer |
Analyzer class defines a way to take a List of images as input, and returns a new List of images. More... | |
class | EMAN::KMeansAnalyzer |
KMeansAnalyzer Performs k-means classification on a set of input images (shape/size arbitrary) returned result is a set of classification vectors. More... | |
class | EMAN::SVDAnalyzer |
Singular Value Decomposition from GSL. More... | |
class | EMAN::Averager |
Averager class defines a way to do averaging on a set of images. More... | |
class | EMAN::ImageAverager |
ImageAverager averages a list of images. More... | |
class | EMAN::FourierWeightAverager |
FourierWeightAverager makes an average of a set of images in Fourier space using a per-image radial weight. More... | |
class | EMAN::TomoAverager |
TomoAverager averages a list of volumes in Fourier space. More... | |
class | EMAN::MinMaxAverager |
ImageAverager averages a list of images. More... | |
class | EMAN::AbsMaxMinAverager |
AbsMaxMinAverager averages a list of images to the maximum(or minimum of the absolute pixel value) It optionally makes a sigma image. More... | |
class | EMAN::IterationAverager |
IterationAverager averages images by doing the smoothing iteration. More... | |
class | EMAN::CtfCAutoAverager |
CtfCWautoAverager averages the images with CTF correction with a Wiener filter. More... | |
class | EMAN::CtfCWautoAverager |
CtfCWautoAverager averages the images with CTF correction with a Wiener filter. More... | |
class | EMAN::BoxingTools |
BoxingTools is class for encapsulating common boxing operations that may become expensive if they are implemented in python. More... | |
class | EMAN::BoxSVDClassifier |
class | EMAN::ByteOrder |
ByteOrder defines functions to work on big/little endian byte orders. More... | |
class | EMAN::Cmp |
Cmp class defines image comparison method. More... | |
class | EMAN::CccCmp |
Compute the cross-correlation coefficient between two images. More... | |
class | EMAN::LodCmp |
class | EMAN::SqEuclideanCmp |
Squared Euclidean distance normalized by n between 'this' and 'with'. More... | |
class | EMAN::DotCmp |
Use dot product of 2 same-size images to do the comparison. More... | |
class | EMAN::TomoCccCmp |
This implements the technique of Mike Schmid where by the cross correlation is normalized in an effort to remove the effects of the missing wedge. More... | |
class | EMAN::TomoFscCmp |
This is a FSC comparitor for tomography. More... | |
class | EMAN::QuadMinDotCmp |
This will calculate the dot product for each quadrant of the image and return the worst value. More... | |
class | EMAN::OptVarianceCmp |
Variance between two data sets after various modifications. More... | |
class | EMAN::PhaseCmp |
Amplitude weighted mean phase difference (radians) with optional SNR weight. More... | |
class | EMAN::FRCCmp |
FRCCmp returns a quality factor based on FRC between images. More... | |
class | EMAN::Ctf |
Ctf is the base class for all CTF model. More... | |
class | EMAN::EMAN1Ctf |
EMAN1Ctf is the CTF model used in EMAN1. More... | |
class | EMAN::EMAN2Ctf |
EMAN2Ctf is the default CTF model used in EMAN2. More... | |
class | EMAN::Df3IO |
class | EMAN::DM3IO |
Gatan DM3 file is a hierarchical binary image format. More... | |
class | EMAN::DM4IO |
Gatan DM$ was introduced with the GMS 2.0 release. More... | |
class | EMAN::EMCache< T > |
EMCache is a generic cache that can cache anything defined by 'T'. More... | |
class | EMAN::GlobalCache |
GlobalCache is a Singleton class that handles cache across EMAN. More... | |
class | EMAN::EMData |
EMData stores an image's data and defines core image processing routines. More... | |
class | EMAN::EMData::ClipInplaceVariables |
class | EMAN::EMFTGL |
EMFTGL is an interface for rendering fonts in EMAN2 using FTGL. More... | |
class | EMAN::EMFTGL::EMFTGLFontInstance |
A class for encapsulatiing a particular instance of an FTFont (pointer) Each FTFont is characterised by 5 parameters, them being the font mode, the font file name, the face size, whether or not display lists are being used, and depth (which is redundant, except when the font mode is EXTRUDE). More... | |
class | EMAN::EMFTGL::EMFTGLManager |
A class for managing multiple instances of EMFTGLFontInstances, in particular for caching them, for constructing news ones if they don't exist, and for returning appropriate instances. More... | |
class | EMAN::EmimIO |
EMIM image format = 1 EmimFileHeader + n x (EmimImageHeader + data). More... | |
struct | EMAN::EmimIO::EmimFileHeader |
struct | EMAN::EmimIO::EmimImageHeader |
class | EMAN::EmIO |
EmIO defines I/O operations on EM image format. More... | |
struct | EMAN::EmIO::EMHeader |
class | EMAN::EMConsts |
class | EMAN::EMObject |
EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType. More... | |
class | EMAN::TypeDict |
TypeDict is a dictionary to store <string, EMObject::ObjectType> pair. More... | |
class | EMAN::Dict |
Dict is a dictionary to store <string, EMObject> pair. More... | |
class | EMAN::Dict::iterator |
Non const iterator support for the Dict object This is just a wrapper, everything is inherited from the map<string,EMObject>::iterator so the interface is the same as you would expect i.e for ( Dict::iterator it = params.begin(); it != params.end(); ++it ). More... | |
class | EMAN::Dict::const_iterator |
Const iterator support for the Dict object This is just a wrapper, everything is inherited from the map<string,EMObject>::cons_iterator so the interface is the same as you would expect i.e for ( Dict::const_iterator it = params.begin(); it != params.end(); ++it ). More... | |
class | EMAN::Factory< T > |
Factory is used to store objects to create new instances. More... | |
class | EMAN::FactoryBase |
A class one may inherit from to ensure that the responsibilities of being incorporated into an EMAN2::Factory are met. More... | |
class | EMAN::EMUtil |
struct | EMAN::ImageScore |
class | EMAN::ImageSort |
class | EMAN::E2Exception |
E2Exception class is the parent class of all EMAN2 E2Exceptions. More... | |
class | EMAN::_NotExistingObjectException |
Used when an object type, like an EMObject type, doesn't exist. More... | |
class | EMAN::_ImageFormatException |
Used when an image is not in the expected format. More... | |
class | EMAN::_ImageDimensionException |
Used when an image is not in the expected dimension. More... | |
class | EMAN::_FileAccessException |
Used when a file access error occurs. More... | |
class | EMAN::_ImageReadException |
Used when an error occurs at image reading time. More... | |
class | EMAN::_ImageWriteException |
Used when an error occurs at image writing time. More... | |
class | EMAN::_NullPointerException |
Used when a NULL is given to a pointer that should not be NULL. More... | |
class | EMAN::_TypeException |
Used when a type cast error occurs. More... | |
class | EMAN::_InvalidValueException |
Used when an invalid integer value is given. More... | |
class | EMAN::_InvalidStringException |
Used when an invalid (format) string is given. More... | |
class | EMAN::_OutofRangeException |
Used when the given value is out of range. More... | |
class | EMAN::_InvalidCallException |
class | EMAN::_InvalidParameterException |
class | EMAN::_EmptyContainerException |
Used when an argument container is empty, such as a vector. More... | |
class | EMAN::_BadAllocException |
Used when memory allocation goes wrong... More... | |
class | EMAN::_UnexpectedBehaviorException |
Used when internal behavior is unexpected A generic kind of exception. More... | |
class | EMAN::FitsIO |
MRC file = header + data (nx x ny x nz). More... | |
class | EMAN::Gatan2IO |
Gatan2 Image file = header + data. More... | |
struct | EMAN::Gatan2IO::Gatan2Header |
class | EMAN::IntSize |
IntSize is used to describe a 1D, 2D or 3D rectangular size in integers. More... | |
class | EMAN::FloatSize |
FloatSize is used to describe a 1D, 2D or 3D rectangular size in floating numbers. More... | |
class | EMAN::IntPoint |
IntPoint defines an integer-coordinate point in a 1D/2D/3D space. More... | |
class | EMAN::FloatPoint |
FloatPoint defines a float-coordinate point in a 1D/2D/3D space. More... | |
class | EMAN::Pixel |
Pixel describes a 3D pixel's coordinates and its intensity value. More... | |
class | EMAN::Region |
Region defines a 2D or 3D rectangular region specified by its origin coordinates and all edges' sizes. More... | |
class | EMAN::GLUtil |
class | EMAN::PriorityQueue< ValueT, KeyT > |
Template class for a priority queue. More... | |
class | EMAN::IcosIO |
ICOS file = header + data. More... | |
struct | EMAN::IcosIO::IcosHeader |
class | EMAN::ImageIO |
ImageIO classes are designed for reading/writing various electron micrography image formats, including MRC, IMAGIC, SPIDER, PIF, etc. More... | |
class | EMAN::ImagicIO |
IMAGIC-5 Header File Format. More... | |
struct | EMAN::ImagicIO::ImagicHeader |
class | EMAN::ImagicIO2 |
IMAGIC-5 Header File Format. More... | |
struct | EMAN::ImagicIO2::Imagic4D |
IMAGIC-4D file format http://www.imagescience.de/formats/formats.htm. More... | |
class | EMAN::Interp |
Interp defines the interpolation function used to generate a e^-x^4 function in real space. More... | |
class | EMAN::Isosurface |
class | EMAN::Log |
Log defines a way to output logging information. More... | |
class | EMAN::LstFastIO |
A LSX file is a high performance ASCII file that contains a list of image numbers and file names. More... | |
class | EMAN::LstIO |
A LST file is an ASCII file that contains a list of image file names. More... | |
class | EMAN::CustomVector< type > |
CustomVector has some trivial optimizations of the STL vector. More... | |
class | EMAN::ColorRGBGenerator |
Class to encapsulate an RGB color generator for marching cubes isosurface generator For now you can only color by radius, but in the near future you will be able to color by map, etc. More... | |
class | EMAN::MarchingCubes |
class | EMAN::U3DWriter |
A work in progress by David Woolford. More... | |
class | EMAN::MrcIO |
MRC file = header + data (nx x ny x nz). More... | |
struct | EMAN::MrcIO::MrcHeader |
struct | EMAN::MrcIO::FeiMrcHeader |
Extended MRC format for tomography As used by Fei; original definition of extended header by Dave Agard and Bram Koster Contact Dustin Morado <Dustin.Morado@uth.tmc.edu> for details. More... | |
struct | EMAN::MrcIO::FeiMrcExtHeader |
The extended header used by Fei MRC image. More... | |
class | EMAN::OmapIO |
DSN6 MAP is composed of a series of records which are all 512 bytes long. More... | |
struct | EMAN::OmapIO::OmapHeader |
The data in the header is composed of 256 short integers. More... | |
class | EMAN::PDBReader |
PointArray defines a double array of points with values in a 3D space. More... | |
class | EMAN::PgmIO |
A PGM file = header + data. More... | |
class | EMAN::PifIO |
PIF(Portable Image Format for EM Data) is an image format from Purdue University. More... | |
struct | EMAN::PifIO::PifFileHeader |
struct | EMAN::PifIO::PifColorMap |
struct | EMAN::PifIO::PifImageHeader |
class | EMAN::XYZAligner |
XYZAligner is an aligner template for defining new aligners. More... | |
class | EMAN::XYZAverager |
XYZAverager is an averager template for defining new averagers. More... | |
class | EMAN::XYZCmp |
XYZCmp is a cmp template for defining new cmps. More... | |
class | EMAN::XYZIO |
XYZIO is a sample Image IO class. More... | |
class | EMAN::XYZProcessor |
XYZProcessor is a processor template for defining new processors. More... | |
class | EMAN::XYZProjector |
XYZProjector is an projector template for defining new projectors. More... | |
class | EMAN::XYZReconstructor |
XYZReconstructor is a reconstructor template for defining new reconstructors. More... | |
class | EMAN::PointArray |
PointArray defines a double array of points with values in a 3D space. More... | |
class | EMAN::UnevenMatrix |
a general data structure for a matrix with variable x dim size for different y More... | |
struct | EMAN::UnevenMatrix::Xdim |
struct to define x dimension size for each y, x0 is inclusive, x1 is one after the maximum, [x0, x1), so the corresponding x dim size is (x1-x0) More... | |
class | EMAN::PolarData |
a specialized image class for storing the results of a transform from EMData to polar coordinates, currently support 2D only. More... | |
class | EMAN::Processor |
Typical usage of Processors are as follows:. More... | |
class | EMAN::ImageProcessor |
class | EMAN::FourierProcessor |
base class for Fourier filters More... | |
class | EMAN::FourierAnlProcessor |
Same as FourierProcessor, except first computes the current image radial power spectrum and passes it to the processor (no radial oversampling, number of elements = radius). More... | |
class | EMAN::SNREvalProcessor |
Evaluate individual particle images using a tenchique similar to that used for CTF evaluation. More... | |
class | EMAN::AmpweightFourierProcessor |
Multiplies each Fourier pixel by its amplitude. More... | |
class | EMAN::ConvolutionProcessor |
This processor performs fast convolution in Fourier space. More... | |
class | EMAN::XGradientProcessor |
Determines the partial derivatives in the x direction Does this by constructing edge kernels in real space but convoluting in Fourier space. More... | |
class | EMAN::YGradientProcessor |
class | EMAN::ZGradientProcessor |
class | EMAN::Wiener2DAutoAreaProcessor |
Automatically determines the background for the image then uses this to perform Wiener filters on overlapping subregions of the image, which are then combined using linear interpolation. More... | |
class | EMAN::DistanceSegmentProcessor |
Segment a volume about:homeinto subvolumes based on a center separation value. More... | |
class | EMAN::KmeansSegmentProcessor |
Segment a volume into ~n subvolumes using K-means classification. More... | |
class | EMAN::CtfSimProcessor |
CTF simulation processor. More... | |
class | EMAN::Wiener2DFourierProcessor |
Wiener filter based on a Ctf object either in the image header. More... | |
class | EMAN::LinearRampFourierProcessor |
class | EMAN::LowpassRandomPhaseProcessor |
Lowpass Phase Randomization processor applied in Fourier space. More... | |
class | EMAN::LowpassAutoBProcessor |
processor radial function: if lowpass > 0, f(x) = exp(-x*x/(lowpass*lowpass)); else f(x) = exp(x*x/(lowpass*lowpass)) More... | |
class | EMAN::HighpassAutoPeakProcessor |
This processor attempts to remove the low resolution peak present in all cryoEM data. More... | |
class | EMAN::LinearRampProcessor |
processor radial function: f(x) = slope * x + intercept More... | |
class | EMAN::LoGFourierProcessor |
processor radial function: f(x) = ((x^2 - s^2)/s^4)e^-(x^2/2s^2) More... | |
class | EMAN::DoGFourierProcessor |
processor radial function: f(x) = 1/sqrt(2*pi)*[1/sigma1*exp-(x^2/2*sigma1^2) - 1/sigma2*exp-(x^2/2*sigma2^2)] More... | |
class | EMAN::RealPixelProcessor |
The base class for real space processor working on individual pixels. More... | |
class | EMAN::AbsoluateValueProcessor |
f(x) = |x| More... | |
class | EMAN::FloorValueProcessor |
f(x) = floor(x) More... | |
class | EMAN::BooleanProcessor |
f(x) = 0 if x = 0; f(x) = 1 if x != 0 More... | |
class | EMAN::RecipCarefullyProcessor |
Reciprocal image as if f(x) != 0: f(x) = 1/f(x) else: f(x) = zero_to. More... | |
class | EMAN::ValuePowProcessor |
Do a math power operation on image, f(x) = x ^ pow;. More... | |
class | EMAN::ValueSquaredProcessor |
Do a square operation on image, f(x) = x * x;. More... | |
class | EMAN::ValueSqrtProcessor |
f(x) = sqrt(x) More... | |
class | EMAN::ToZeroProcessor |
f(x) = x if x >= minval; f(x) = 0 if x < minval 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::ApplySymProcessor |
Applies a symmetry to a 3D model. More... | |
class | EMAN::ScaleTransformProcessor |
Scale the image with control over the output dimensions. More... | |
class | EMAN::ClampingProcessor |
f(x) = maxval if f(x) > maxval; f(x) = minval if f(x) < minval More... | |
class | EMAN::NSigmaClampingProcessor |
This function clamps the min and max vals in the image at minval and maxval at mean-n*sigma and mean+n*sigma, respectively. More... | |
class | EMAN::ToMinvalProcessor |
f(x) = x if x >= minval; f(x) = minval if x < minval More... | |
class | EMAN::CutToZeroProcessor |
f(x) = x-minval if x >= minval; f(x) = 0 if x < minval More... | |
class | EMAN::BinarizeProcessor |
f(x) = 0 if x < value; f(x) = 1 if x >= value. More... | |
class | EMAN::BinarizeFourierProcessor |
A thresholding processor for Fourier images based on the amplitude component. More... | |
class | EMAN::CollapseProcessor |
f(x): if v-r<x<v+r -> v; if x>v+r -> x-r; if x<v-r -> x+r More... | |
class | EMAN::LinearXformProcessor |
linear transform processor: f(x) = x * scale + shift More... | |
class | EMAN::ExpProcessor |
f(x) = exp( x / low - high) More... | |
class | EMAN::FiniteProcessor |
f(x) = f(x) if f(x) is finite | to if f(x) is not finite More... | |
class | EMAN::RangeThresholdProcessor |
f(x) = 1 if (low <= x <= high); else f(x) = 0 More... | |
class | EMAN::SigmaProcessor |
f(x) = mean if x<(mean-v2*sigma) or x>(mean+v1*sigma); else f(x) = x; More... | |
class | EMAN::LogProcessor |
f(x) = log10(x) if x > 0; else f(x) = 0 More... | |
class | EMAN::CoordinateProcessor |
CoordinateProcessor applies processing based on a pixel's value and it coordinates. More... | |
class | EMAN::CircularMaskProcessor |
CircularMaskProcessor applies a circular mask to the data.This is the base class for specific circular mask processors.Its subclass must implement process_dist_pixel(). More... | |
class | EMAN::MaskSharpProcessor |
step cutoff to a user-given value in both inner and outer circles. More... | |
class | EMAN::MaskEdgeMeanProcessor |
A step cutoff to the the mean value in a ring centered on the outer radius. More... | |
class | EMAN::MaskNoiseProcessor |
fills masked region More... | |
class | EMAN::MaskGaussProcessor |
a gaussian falloff to zero, radius is the 1/e of the width. More... | |
class | EMAN::MaskGaussNonuniformProcessor |
a gaussian falloff to zero, with nonisotropic widths along x,y,z More... | |
class | EMAN::MaskGaussInvProcessor |
f(x) = f(x) / exp(-radius*radius * gauss_width / (ny*ny)) More... | |
class | EMAN::LinearPyramidProcessor |
Multiplies image by a 'linear pyramid' 1-(|x-xsize/2|*|y-ysize/2|*4/(xsize*ysize)) This is useful in averaging together boxed out regions with 50% overlap. More... | |
class | EMAN::MakeRadiusSquaredProcessor |
overwrites input, f(x) = radius * radius More... | |
class | EMAN::MakeRadiusProcessor |
overwrites input, f(x) = radius More... | |
class | EMAN::ComplexPixelProcessor |
The base class for fourier space processor working on individual pixels. More... | |
class | EMAN::ComplexNormPixel |
Each Fourier pixel will be normalized. More... | |
class | EMAN::AreaProcessor |
AreaProcessor use pixel values and coordinates of a real-space square area. More... | |
class | EMAN::LaplacianProcessor |
Discrete approximation to Laplacian. More... | |
class | EMAN::ZeroConstantProcessor |
Contraction of data, if any nearest neighbor is 0, value -> 0, generally used iteratively. More... | |
class | EMAN::BoxStatProcessor |
BoxStatProcessor files are a kind of neighborhood processors. More... | |
class | EMAN::BoxMedianProcessor |
A processor for noise reduction. More... | |
class | EMAN::BoxSigmaProcessor |
pixel = standard deviation of values surrounding pixel. More... | |
class | EMAN::BoxMaxProcessor |
peak processor: pixel = max of values surrounding pixel. More... | |
class | EMAN::MinusPeakProcessor |
peak processor: pixel = pixel - max of values surrounding pixel. More... | |
class | EMAN::PeakOnlyProcessor |
peak processor -> if npeaks or more surrounding values >= value, value->0 More... | |
class | EMAN::DiffBlockProcessor |
averages over cal_half_width, then sets the value in a local block More... | |
class | EMAN::CutoffBlockProcessor |
Block processor, val1 is dx/dy, val2 is lp freq cutoff in pixels. More... | |
class | EMAN::BooleanShrinkProcessor |
BooleanShrinkProcessor encapsulates code common to MaxShrinkProcessor and MinShrinkProcessor - the processors use more or less identical code, the main difference being the logical operator. More... | |
class | EMAN::MaxShrinkProcessor |
MaxShrinkProcessors shrinks an image by in an integer amount, keeping the maximum pixel value - useful when constructing binary search trees in the marching cubes algorithm. More... | |
struct | EMAN::MaxShrinkProcessor::GreaterThan |
class | EMAN::MinShrinkProcessor |
MinShrinkProcessor shrinks an image by in an integer amount, keeping the minimum pixel value - useful when constructing binary search trees in the marching cubes algorithm. More... | |
struct | EMAN::MinShrinkProcessor::LessThan |
class | EMAN::MeanShrinkProcessor |
MeanShrinkProcessor shrinks an image by in an integer amount (and optionally by 1.5) taking the mean of the pixel neighbourhood. More... | |
class | EMAN::MedianShrinkProcessor |
MeanShrinkProcessor shrinks an image by in an integer amount taking the median of the pixel neighbourhood. More... | |
class | EMAN::FFTResampleProcessor |
FFTResampleProcessor resamples an image by clipping the Fourier Transform This is the same as multipyling the FT by a box window, in real space this is a convolution that will induce rippling. More... | |
class | EMAN::GradientRemoverProcessor |
Gradient remover, does a rough plane fit to find linear gradients. More... | |
class | EMAN::GradientPlaneRemoverProcessor |
Gradient removed by least square plane fit. More... | |
class | EMAN::NonConvexProcessor |
Make a curve or surface non-convex (planar or concave), iteratively. More... | |
class | EMAN::FlattenBackgroundProcessor |
Flattens the background by subtracting the local mean. More... | |
class | EMAN::RampProcessor |
Ramp processor -- Fits a least-squares plane to the picture, and subtracts the plane from the picture. More... | |
class | EMAN::VerticalStripeProcessor |
Tries to fix images scanned on the zeiss for poor ccd normalization. More... | |
class | EMAN::RealToFFTProcessor |
This will replace the image with a full-circle 2D fft amplitude rendering. More... | |
class | EMAN::SigmaZeroEdgeProcessor |
Fill zeroes at edges with nearest horizontal/vertical value. More... | |
class | EMAN::BeamstopProcessor |
Try to eliminate beamstop in electron diffraction patterns. More... | |
class | EMAN::MeanZeroEdgeProcessor |
Fill zeroes at edges with nearest horizontal/vertical value damped towards Mean2. More... | |
class | EMAN::AverageXProcessor |
Average along Y and replace with average. More... | |
class | EMAN::DecayEdgeProcessor |
Decay edges of image to zero. More... | |
class | EMAN::ZeroEdgeRowProcessor |
zero edges of image on top and bottom, and on left and right. More... | |
class | EMAN::ZeroEdgePlaneProcessor |
zero edges of volume on all sides More... | |
class | EMAN::BilateralProcessor |
Bilateral processing on 2D or 3D volume data. More... | |
class | EMAN::NormalizeProcessor |
Base class for normalization processors. More... | |
class | EMAN::NormalizeUnitProcessor |
Normalize an image so its vector length is 1.0. More... | |
class | EMAN::NormalizeUnitSumProcessor |
Normalize an image so its elements sum to 1.0 (fails if mean=0). More... | |
class | EMAN::NormalizeStdProcessor |
do a standard normalization on an image. More... | |
class | EMAN::NormalizeMaskProcessor |
Uses a 1/0 mask defining a region to use for the zero-normalization.if no_sigma is 1, standard deviation not modified. More... | |
class | EMAN::NormalizeRampNormVar |
Normalize the image whilst also removing any ramps. More... | |
class | EMAN::NormalizeByMassProcessor |
Normalize the mass of the image assuming a density of 1.35 g/ml (0.81 Da/A^3). More... | |
class | EMAN::NormalizeEdgeMeanProcessor |
normalizes an image, mean value equals to edge mean. More... | |
class | EMAN::NormalizeCircleMeanProcessor |
normalizes an image, mean value equals to mean of 2 pixel circular border. More... | |
class | EMAN::NormalizeLREdgeMeanProcessor |
normalizes an image, uses 2 pixels on left and right edge More... | |
class | EMAN::NormalizeMaxMinProcessor |
normalizes an image. More... | |
class | EMAN::NormalizeRowProcessor |
normalizes each row in the image individually More... | |
class | EMAN::NormalizeToLeastSquareProcessor |
use least square method to normalize More... | |
class | EMAN::RotationalAverageProcessor |
makes image circularly symmetric. More... | |
class | EMAN::RotationalSubstractProcessor |
subtracts circularly symmetric part of an image. More... | |
class | EMAN::TransposeProcessor |
Transpose a 2D image. More... | |
class | EMAN::FlipProcessor |
flip an image around an axis More... | |
class | EMAN::AddNoiseProcessor |
add noise to an image More... | |
class | EMAN::AddSigmaNoiseProcessor |
add sigma noise, multiply image's sigma value to noise More... | |
class | EMAN::AddRandomNoiseProcessor |
add spectral noise to a complex image More... | |
class | EMAN::FourierToCornerProcessor |
Undo the effects of the FourierToCenterProcessor. More... | |
class | EMAN::FourierToCenterProcessor |
Translates the origin in Fourier space from the corner to the center in y and z Handles 2D and 3D, and handles all combinations of even and oddness Typically you call this function after Fourier transforming a real space image. More... | |
class | EMAN::Phase180Processor |
This class is abstract. More... | |
class | EMAN::PhaseToCenterProcessor |
Translates a cornered image to the center Undoes the PhaseToCornerProcessor. More... | |
class | EMAN::PhaseToCornerProcessor |
Translates a centered image to the corner works for 1D, 2D and 3D images, for all combinations of even and oddness. More... | |
class | EMAN::AutoMask2DProcessor |
Attempts to automatically mask out the particle, excluding other particles in the box, etc. More... | |
class | EMAN::AutoMaskAsymUnit |
Tries to mask out only interesting density. More... | |
class | EMAN::AutoMask3DProcessor |
Tries to mask out only interesting density. More... | |
class | EMAN::AutoMask3D2Processor |
Tries to mask out only interesting density. More... | |
class | EMAN::AddMaskShellProcessor |
Add additional shells/rings to an existing 1/0 mask image. More... | |
class | EMAN::PhaseToMassCenterProcessor |
ToMassCenterProcessor centers image at center of mass, ignores old dx, dy. More... | |
class | EMAN::ToMassCenterProcessor |
ToMassCenterProcessor centers image at center of mass, ignores old dx, dy. More... | |
class | EMAN::ACFCenterProcessor |
Center image using auto convolution with 180 degree rotation. More... | |
class | EMAN::SNRProcessor |
Processor the images by the estimated SNR in each image.if parameter 'wiener' is 1, then wiener processor the images using the estimated SNR with CTF amplitude correction. More... | |
class | EMAN::FileFourierProcessor |
A fourier processor specified in a 2 column text file. More... | |
class | EMAN::SymSearchProcessor |
Identifiy the best symmetry in the given symmetry list for each pixel and then apply the best symmetry to each pixel. More... | |
class | EMAN::StripeXYProcessor |
This processor will remove localized 'striping' along the x/y axes, caused by issues with CCD/CMOS readout. More... | |
class | EMAN::LocalNormProcessor |
This processor attempts to perform a 'local normalization' so low density and high density features will be on a more even playing field in an isosurface display. More... | |
class | EMAN::IndexMaskFileProcessor |
Multiplies the image by the specified file using pixel indices. More... | |
class | EMAN::CoordinateMaskFileProcessor |
Multiplies the image by the specified file using pixel coordinates instead of pixel indices. More... | |
class | EMAN::PaintProcessor |
'paints' a circle into the image at x,y,z with values inside r1 set to v1, values between r1 and r2 will be set to a value between v1 and v2, and values outside r2 will be unchanged More... | |
class | EMAN::DirectionalSumProcessor |
Does a projection in one the axial directions Doesn't support process_inplace (because the output has potentially been compressed in one dimension). More... | |
class | EMAN::WatershedProcessor |
'paints' a circle into the image at x,y,z with values inside r1 set to v1, values between r1 and r2 will be set to a value between v1 and v2, and values outside r2 will be unchanged More... | |
class | EMAN::BinaryOperateProcessor< Type > |
Operates on two images, returning an image containing the maximum/minimum/multiplied pixel (etc, you choose) at each location The actual operation depends on what template argument you use. More... | |
class | EMAN::MaxPixelOperator |
class | EMAN::MinPixelOperator |
class | EMAN::MatchSFProcessor |
Sets the structure factor To match a second provided image/volume. More... | |
class | EMAN::SetSFProcessor |
Sets the structure factor based on a 1D s/intensity curve as an XYData object. More... | |
class | EMAN::SmartMaskProcessor |
Smart mask processor. More... | |
class | EMAN::IterBinMaskProcessor |
Iterative expansion of a binary mask, val1 is number of pixels to expand, if val2!=0 will make a soft Gaussian edge starting after val2 pixels. More... | |
class | EMAN::TestImageProcessor |
Base class for a group of 'processor' used to create test image. More... | |
class | EMAN::TestImagePureGaussian |
Replace a source image as a strict Gaussian. More... | |
class | EMAN::TestImageFourierNoiseGaussian |
Replace a source image as a strict Gaussian. More... | |
class | EMAN::TestImageFourierNoiseProfile |
class | EMAN::CTFSNRWeightProcessor |
class | EMAN::TestImageLineWave |
Treats the pixels as though they are 1D (even if the image is 2D or 3D), inserting a sine wave of pixel period extracted from the parameters (default is 10). More... | |
class | EMAN::TestTomoImage |
Make an image useful for tomographic reconstruction testing this is a 3D phantom image based on the 2D phantom described in Delaney and Bresler, "Globally convergent edge-preserving regularized reconstruction: An application to limited-angle tomography". More... | |
class | EMAN::TestImageGradient |
Put a gradient in the image of the form y = mx+b : "x" is a string indicating any of the image axes, i.e., x,y or z. More... | |
class | EMAN::TestImageAxes |
Make an image consisting of a single cross, with lines going in the axial directions, intersecting at the origin. More... | |
class | EMAN::TestImageGaussian |
Replace a source image as a Gaussian Blob. More... | |
class | EMAN::TestImageScurve |
Replace a source image with a lumpy S-curve used for alignment testing. More... | |
class | EMAN::TestImageSphericalWave |
Replace a source image as a sine wave in specified wave length. More... | |
class | EMAN::TestImageSinewave |
Replace a source image as a sine wave in specified wave length. More... | |
class | EMAN::TestImageSinewaveCircular |
Replace a source image as a circular sine wave in specified wave length. More... | |
class | EMAN::TestImageSquarecube |
Replace a source image as a square or cube depends on 2D or 3D of the source image. More... | |
class | EMAN::TestImageEllipse |
Generate an ellipse or ellipsoid image. More... | |
class | EMAN::TestImageHollowEllipse |
Generate an ellipse/ellipsoid image with an inner hollow ellipse/ellipsoid. More... | |
class | EMAN::TestImageCirclesphere |
Replace a source image as a circle or sphere depends on 2D or 3D of the source image. More... | |
class | EMAN::TestImageNoiseUniformRand |
Replace a source image as a uniform random noise, random number generated from gsl_rng_mt19937, the pixel value is from 0 to 1, [0, 1). More... | |
class | EMAN::TestImageNoiseGauss |
Replace a source image with gaussian distributed random noise If you don't provide a seed at all, it should be seeded using the best available source of randomness( time(0) in this implementation). More... | |
class | EMAN::TestImageCylinder |
Replace a source image with a cylinder. More... | |
class | EMAN::CCDNormProcessor |
Try to normalize the 4 quadrants of a CCD image. More... | |
class | EMAN::WaveletProcessor |
Perform a Wavelet transform using GSL. More... | |
class | EMAN::TomoTiltEdgeMaskProcessor |
A processor designed specifically for tomographic tilt series data. More... | |
class | EMAN::TomoTiltEdgeMaskProcessor::GaussianFunctoid |
class | EMAN::TomoTiltAngleWeightProcessor |
A processor that can be used to weight an image by 1/cos(angle) This processor evolved originally as an experimental tool for weighting tomographic data by the width of its cross section relative to the electron beam. More... | |
class | EMAN::FFTProcessor |
Perform a FFT transform by calling EMData::do_fft() and EMData::do_ift(). More... | |
class | EMAN::RadialProcessor |
Perform a multiplication of real image with a radial table. More... | |
class | EMAN::HistogramBin |
Bins pixel values, similar to calculating a histogram. More... | |
class | EMAN::ModelHelixProcessor |
class | EMAN::ModelEMCylinderProcessor |
class | EMAN::ApplyPolynomialProfileToHelix |
class | EMAN::BinarySkeletonizerProcessor |
class | EMAN::ConvolutionKernelProcessor |
class | EMAN::RotateInFSProcessor |
class | EMAN::Projector |
Projector class defines a method to generate 2D projections from a 3D model. More... | |
class | EMAN::GaussFFTProjector |
Gaussian FFT 3D projection. More... | |
class | EMAN::FourierGriddingProjector |
Fourier gridding projection routine. More... | |
class | EMAN::PawelProjector |
Pawel Penczek's optimized projection routine. More... | |
struct | EMAN::PawelProjector::IPCube |
class | EMAN::MaxValProjector |
Real-space projection which computes the maximum value along each line projection rather than a sum. More... | |
class | EMAN::StandardProjector |
Fast real-space 3D projection. More... | |
class | EMAN::ChaoProjector |
Fast real space projection using Bi-Linear interpolation. More... | |
class | EMAN::Quaternion |
Quaternion is used in Rotation and Transformation to replace Euler angles. More... | |
class | EMAN::Randnum |
The wrapper class for gsl's random number generater. More... | |
class | EMAN::Reconstructor |
Reconstructor class defines a way to do 3D recontruction. More... | |
class | EMAN::ReconstructorVolumeData |
This is a Mixin class A class object encapsulating the volume data required by Reconstructors It basically stores two (pointers) to EMData objectsd stores the dimensions of the image volume. More... | |
class | EMAN::FourierReconstructorSimple2D |
This class originally added for 2D experimentation and prototying. More... | |
class | EMAN::FourierReconstructor |
Fourier space 3D reconstruction The Fourier reconstructor is designed to work in an iterative fashion, where similarity ("quality") metrics are used to determine if a slice should be inserted into the 3D in each subsequent iteration. More... | |
class | EMAN::WienerFourierReconstructor |
Fourier space 3D reconstruction This is a modified version of the normal FourierReconstructor which is aware of the SSNR information stored in individual class-average headers as "ctf_snr_total" and "ctf_wiener_filtered". More... | |
class | EMAN::FourierPlaneReconstructor |
Fourier space 3D reconstruction The Fourier reconstructor is designed to work in an iterative fashion, where similarity ("quality") metrics are used to determine if a slice should be inserted into the 3D in each subsequent iteration. More... | |
class | EMAN::BackProjectionReconstructor |
Real space 3D reconstruction using back projection. More... | |
class | EMAN::nn4Reconstructor |
class | EMAN::nn4_rectReconstructor |
Direct Fourier inversion Reconstructor for extremly rectangular object. More... | |
class | EMAN::nnSSNR_Reconstructor |
class | EMAN::nn4_ctfReconstructor |
nn4_ctf Direct Fourier Inversion Reconstructor More... | |
class | EMAN::nn4_ctf_rectReconstructor |
nn4_ctf_rectDirect Fourier Inversion Reconstructor More... | |
class | EMAN::nnSSNR_ctfReconstructor |
struct | EMAN::point_t |
class | EMAN::newfile_store |
class | EMAN::file_store |
class | EMAN::FourierPixelInserter3D |
FourierPixelInserter3D class defines a way a continuous pixel in 3D is inserted into the discrete 3D volume - there are various schemes for doing this including simply finding the nearest neighbor to more elaborate schemes that involve interpolation using the nearest 8 voxels and so on. More... | |
class | EMAN::FourierInserter3DMode1 |
FourierPixelInserter3DMode1 - encapsulates "method 1" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::FourierInserter3DMode2 |
FourierPixelInserter3DMode2 - encapsulates "method 2" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::FourierInserter3DMode3 |
FourierPixelInserter3DMode3 - encapsulates "method 3" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::FourierInserter3DMode5 |
FourierPixelInserter3DMode5 - encapsulates "method 5" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::FourierInserter3DMode6 |
FourierPixelInserter3DMode6 - encapsulates "method 6" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::FourierInserter3DMode7 |
FourierPixelInserter3DMode7 - encapsulates "method 7" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::FourierInserter3DMode8 |
FourierPixelInserter3DMode8 - encapsulates "method 8" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | EMAN::SalIO |
A SAL image is an image from Perkin Elmer PDS Microdensitometer. More... | |
class | EMAN::SerIO |
SER (Series File Format) is a file format created by Dr. More... | |
struct | EMAN::SerIO::SerHeader |
class | EMAN::SitusIO |
situs is a a Situs-specific format on a cubic lattice. More... | |
class | EMAN::PCAsmall |
Principal component analysis. More... | |
class | EMAN::PCAlarge |
class | EMAN::varimax |
class | EMAN::EMArray< T > |
EMArray -- 1-, 2-, or 3-D array of types T. More... | |
class | EMAN::PCA |
class | EMAN::MirrorProcessor |
mirror an image More... | |
class | EMAN::NewFourierProcessor |
Base class for Fourier processors. More... | |
class | EMAN::NewLowpassTopHatProcessor |
Lowpass top-hat filter processor applied in Fourier space. More... | |
class | EMAN::NewHighpassTopHatProcessor |
Highpass top-hat filter applied in Fourier NewLowpassGaussProcessorspace. More... | |
class | EMAN::NewBandpassTopHatProcessor |
Bandpass top-hat filter processor applied in Fourier space. More... | |
class | EMAN::NewHomomorphicTopHatProcessor |
Homomorphic top-hat filter processor applied in Fourier space. More... | |
class | EMAN::NewLowpassGaussProcessor |
Lowpass Gauss filter processor applied in Fourier space. More... | |
class | EMAN::NewHighpassGaussProcessor |
Highpass Gauss filter processor applied in Fourier space. More... | |
class | EMAN::NewBandpassGaussProcessor |
Bandpass Gauss filter processor applied in Fourier space. More... | |
class | EMAN::NewHomomorphicGaussProcessor |
Homomorphic Gauss filter processor applied in Fourier space. More... | |
class | EMAN::NewInverseGaussProcessor |
Divide by a Gaussian in Fourier space. More... | |
class | EMAN::SHIFTProcessor |
Shift by phase multiplication in Fourier space. More... | |
class | EMAN::InverseKaiserI0Processor |
Divide by a Kaiser-Bessel I0 func in Fourier space. More... | |
class | EMAN::InverseKaiserSinhProcessor |
Divide by a Kaiser-Bessel Sinh func in Fourier space. More... | |
class | EMAN::NewRadialTableProcessor |
Filter with tabulated data in Fourier space. More... | |
class | EMAN::NewLowpassButterworthProcessor |
Lowpass Butterworth filter processor applied in Fourier space. More... | |
class | EMAN::NewHighpassButterworthProcessor |
Highpass Butterworth filter processor applied in Fourier space. More... | |
class | EMAN::NewHomomorphicButterworthProcessor |
Homomorphic Butterworth filter processor applied in Fourier space. More... | |
class | EMAN::NewLowpassTanhProcessor |
Lowpass tanh filter processor applied in Fourier space. More... | |
class | EMAN::NewHighpassTanhProcessor |
Highpass tanh filter processor applied in Fourier space. More... | |
class | EMAN::NewHomomorphicTanhProcessor |
Homomorphic Tanh processor applied in Fourier space. More... | |
class | EMAN::NewBandpassTanhProcessor |
Bandpass tanh processor applied in Fourier space. More... | |
class | EMAN::CTF_Processor |
class | EMAN::SpiderIO |
SPIDER: (System for Processing Image Data from Electron microscopy and Related fields) is an image processing system for electron microscopy. More... | |
struct | EMAN::SpiderIO::SpiderHeader |
class | EMAN::SingleSpiderIO |
Single Spider Image I/O class. More... | |
class | EMAN::Symmetry3D |
Symmetry3D - A base class for 3D Symmetry objects. More... | |
class | EMAN::CSym |
An encapsulation of cyclic 3D symmetry. More... | |
class | EMAN::DSym |
An encapsulation of dihedral 3D symmetry. More... | |
class | EMAN::HSym |
An encapsulation of helical 3D symmetry. More... | |
class | EMAN::PlatonicSym |
A base (or parent) class for the Platonic symmetries. More... | |
class | EMAN::TetrahedralSym |
An encapsulation of tetrahedral symmetry Doctor Phil has this to say about tetrahedral symmetry: " Each Platonic Solid has 2E symmetry elements. More... | |
class | EMAN::OctahedralSym |
An encapsulation of octahedral symmetry Doctor Phil has this to say about the octahedral symmetry: "Each Platonic Solid has 2E symmetry elements. More... | |
class | EMAN::IcosahedralSym |
An encapsulation of icosahedral symmetry Doctor Phil has this to say about icosahedral symmetry: "Each Platonic Solid has 2E symmetry elements. More... | |
class | EMAN::Icosahedral2Sym |
An encapsulation of icosahedral symmetry 222. More... | |
class | EMAN::OrientationGenerator |
An orientation generator is a kind of class that will generate orientations for a given symmetry If one needs to generate orientations in the unit sphere, one simply uses the C1 symmetry. More... | |
class | EMAN::EmanOrientationGenerator |
EmanOrientationGenerator generates orientations quasi-evenly distributed in the asymmetric unit. More... | |
class | EMAN::RandomOrientationGenerator |
Random Orientation Generator - carefully generates uniformly random orientations in any asymmetric unit. More... | |
class | EMAN::EvenOrientationGenerator |
Sparx even orientation generator - see util_sparx.cpp - Util::even_angles(...) This orientation generator is based on work presented in Penczek et al., 1994 P.A. More... | |
class | EMAN::SaffOrientationGenerator |
Saff orientation generator - based on the work of Saff and Kuijlaars, 1997 E.B. More... | |
class | EMAN::OptimumOrientationGenerator |
Optimum orientation generator. More... | |
class | EMAN::TestUtil |
class | EMAN::Transform |
A Transform object is a somewhat specialized object designed specifically for EMAN2/Sparx storage of alignment parameters and euler orientations. More... | |
class | EMAN::Util |
Util is a collection of utility functions. More... | |
class | EMAN::Util::sincBlackman |
class | EMAN::Util::KaiserBessel |
1-D Kaiser-Bessel window function class. More... | |
class | EMAN::Util::KaiserBessel::kbsinh_win |
Sinh window function object. More... | |
class | EMAN::Util::KaiserBessel::kbi0_win |
I0 window function object. More... | |
class | EMAN::Util::FakeKaiserBessel |
class | EMAN::Util::Gaussian |
Gaussian function class. More... | |
struct | EMAN::Util::tmpstruct |
class | EMAN::V4L2IO |
Read-only. More... | |
class | EMAN::Vec4< Type > |
The Vec4 object is a templated object, intended to instantiated with basic types such as int, float, double etc. More... | |
class | EMAN::Vec3< Type > |
The Vec3 object is a templated object, intended to instantiated with basic types such as int, float, double etc. More... | |
class | EMAN::Vec2< Type > |
The Vec2 is precisely the same as Vec3 except it works exclusively in 2D Note there are convenient typedef so one needn't bother about using template terminology typedef Vec2<float> Vec2f; typedef Vec2<int> Vec2i; typedef Vec2double> Vec2d; // Not recommended for use unless precision is addressed in this class. More... | |
class | EMAN::ScreenVector |
class | EMAN::ScreenPoint |
class | EMAN::Vector3 |
class | EMAN::Point3 |
class | EMAN::Matrix3 |
class | EMAN::Vector4 |
class | EMAN::Matrix4 |
class | EMAN::VtkIO |
VtkIO reads/writes VTK image file. More... | |
class | EMAN::XplorIO |
XPLOR image format is in ASCII:. More... | |
class | EMAN::XYData |
XYData defines a 1D (x,y) data set. More... | |
struct | EMAN::XYData::Pair |
Typedefs | |
typedef boost::multi_array_ref< float, 2 > | MArray2D |
typedef boost::multi_array_ref< float, 3 > | MArray3D |
typedef boost::multi_array_ref< std::complex< float >, 2 > | MCArray2D |
typedef boost::multi_array_ref< std::complex< float >, 3 > | MCArray3D |
typedef boost::multi_array< int, 2 > | MIArray2D |
typedef boost::multi_array< int, 3 > | MIArray3D |
typedef Vec4< float > | Vec4f |
typedef Vec4< int > | Vec4i |
typedef Vec4< double > | Vec4d |
typedef Vec3< float > | Vec3f |
typedef Vec3< int > | Vec3i |
typedef Vec3< double > | Vec3d |
typedef Vec2< float > | Vec2f |
typedef Vec2< int > | Vec2i |
typedef Vec2< double > | Vec2d |
Enumerations | |
enum | MapInfoType { NORMAL, ICOS2F_FIRST_OCTANT, ICOS2F_FULL, ICOS2F_HALF, ICOS3F_HALF, ICOS3F_FULL, ICOS5F_HALF, ICOS5F_FULL, ICOS_UNKNOWN } |
enum | fp_flag { CIRCULANT = 1, CIRCULANT_NORMALIZED = 2, PADDED = 3, PADDED_NORMALIZED = 4, PADDED_LAG = 5, PADDED_NORMALIZED_LAG = 6 } |
Fourier Product processing flag. More... | |
enum | fp_type { CORRELATION, CONVOLUTION, SELF_CORRELATION, AUTOCORRELATION } |
enum | kernel_shape { BLOCK = 1, CIRCULAR = 2, CROSS = 3 } |
enum | morph_type { BINARY = 1, GRAYLEVEL = 2 } |
Median filter. More... | |
Functions | |
void | dump_aligners () |
map< string, vector< string > > | dump_aligners_list () |
void | dump_analyzers () |
map< string, vector< string > > | dump_analyzers_list () |
void | dump_averagers () |
map< string, vector< string > > | dump_averagers_list () |
void | dump_cmps () |
map< string, vector< string > > | dump_cmps_list () |
EMData * | operator+ (const EMData &em, float n) |
EMData * | operator- (const EMData &em, float n) |
EMData * | operator * (const EMData &em, float n) |
EMData * | operator/ (const EMData &em, float n) |
EMData * | operator+ (float n, const EMData &em) |
EMData * | operator- (float n, const EMData &em) |
EMData * | operator * (float n, const EMData &em) |
EMData * | operator/ (float n, const EMData &em) |
EMData * | rsub (const EMData &em, float n) |
EMData * | rdiv (const EMData &em, float n) |
EMData * | operator+ (const EMData &a, const EMData &b) |
EMData * | operator- (const EMData &a, const EMData &b) |
EMData * | operator * (const EMData &a, const EMData &b) |
EMData * | operator/ (const EMData &a, const EMData &b) |
bool | operator== (const EMObject &e1, const EMObject &e2) |
bool | operator!= (const EMObject &e1, const EMObject &e2) |
bool | operator== (const Dict &d1, const Dict &d2) |
bool | operator!= (const Dict &d1, const Dict &d2) |
template<class T> | |
void | dump_factory () |
template<class T> | |
map< string, vector< string > > | dump_factory_list () |
IntPoint | operator- (const IntPoint &p) |
bool | operator< (const Pixel &p1, const Pixel &p2) |
bool | operator== (const Pixel &p1, const Pixel &p2) |
bool | operator!= (const Pixel &p1, const Pixel &p2) |
int | multi_processors (EMData *image, vector< string > processornames) |
void | dump_processors () |
map< string, vector< string > > | dump_processors_list () |
map< string, vector< string > > | group_processors () |
void | dump_projectors () |
map< string, vector< string > > | dump_projectors_list () |
Quaternion | operator+ (const Quaternion &q1, const Quaternion &q2) |
Quaternion | operator- (const Quaternion &q1, const Quaternion &q2) |
Quaternion | operator * (const Quaternion &q1, const Quaternion &q2) |
Quaternion | operator * (const Quaternion &q, float s) |
Quaternion | operator * (float s, const Quaternion &q) |
Quaternion | operator/ (const Quaternion &q1, const Quaternion &q2) |
bool | operator== (const Quaternion &q1, const Quaternion &q2) |
bool | operator!= (const Quaternion &q1, const Quaternion &q2) |
EMData * | padfft_slice (const EMData *const slice, const Transform &t, int npad) |
Direct Fourier inversion Reconstructor. | |
void | dump_reconstructors () |
map< string, vector< string > > | dump_reconstructors_list () |
EMData * | periodogram (EMData *f) |
EMData * | fourierproduct (EMData *f, EMData *g, fp_flag flag, fp_type ptype, bool center) |
Fourier product of two images. | |
EMData * | correlation (EMData *f, EMData *g, fp_flag myflag, bool center) |
Correlation of two images. | |
EMData * | convolution (EMData *f, EMData *g, fp_flag myflag, bool center) |
Convolution of two images. | |
EMData * | rsconvolution (EMData *f, EMData *K) |
Real-space convolution of two images. | |
EMData * | rscp (EMData *f) |
Real-space convolution with the K-B window. | |
EMData * | autocorrelation (EMData *f, fp_flag myflag, bool center) |
Image autocorrelation. | |
EMData * | self_correlation (EMData *f, fp_flag myflag, bool center) |
Image self-correlation. | |
EMData * | filt_median_ (EMData *f, int nxk, int nyk, int nzk, kernel_shape myshape) |
EMData * | filt_dilation_ (EMData *f, EMData *K, morph_type mydilation) |
EMData * | filt_erosion_ (EMData *f, EMData *K, morph_type myerosion) |
Dilation filter. | |
void | dump_symmetries () |
dump symmetries, useful for obtaining symmetry information | |
map< string, vector< string > > | dump_symmetries_list () |
dump_symmetries_list, useful for obtaining symmetry information | |
void | dump_orientgens () |
Dumps useful information about the OrientationGenerator factory. | |
map< string, vector< string > > | dump_orientgens_list () |
Can be used to get useful information about the OrientationGenerator factory. | |
Transform | operator * (const Transform &M2, const Transform &M1) |
Matrix times Matrix, a pure mathematical operation. | |
template<typename Type> | |
Vec3f | operator * (const Transform &M, const Vec3< Type > &v) |
Matrix times Vector, a pure mathematical operation. | |
template<typename Type> | |
Vec2f | operator * (const Transform &M, const Vec2< Type > &v) |
Matrix times Vector, a pure mathematical operation. | |
template<typename Type> | |
Vec3f | operator * (const Vec3< Type > &v, const Transform &M) |
Vector times a matrix. | |
template<typename Type, typename Type2> | |
Vec3< Type > | operator+ (const Vec3< Type > &v1, const Vec3< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec3< Type > | operator+ (const Vec3< Type > &v, const Type2 &n) |
template<typename Type, typename Type2> | |
Vec3< Type > | operator- (const Vec3< Type > &v1, const Vec3< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec3< Type > | operator- (const Vec3< Type > &v, const Type2 &n) |
template<typename Type> | |
Vec3< Type > | operator- (const Vec3< Type > &v) |
template<typename Type, typename Type2> | |
Type | operator * (const Vec3< Type > &v1, const Vec3< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec3< Type2 > | operator * (const Type &d, const Vec3< Type2 > &v) |
template<typename Type, typename Type2> | |
Vec3< Type > | operator * (const Vec3< Type > &v, const Type2 &d) |
template<typename Type, typename Type2> | |
Vec3< Type2 > | operator/ (const Type &d, const Vec3< Type2 > &v) |
template<typename Type, typename Type2> | |
Vec3< Type > | operator/ (const Vec3< Type > &v, const Type2 &d) |
template<typename Type, typename Type2> | |
bool | operator== (const Vec3< Type > &v1, const Vec3< Type2 > &v2) |
template<typename Type, typename Type2> | |
bool | operator!= (const Vec3< Type > &v1, const Vec3< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec2< Type > | operator+ (const Vec2< Type > &v1, const Vec2< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec2< Type > | operator+ (const Vec2< Type > &v, const Type2 &n) |
template<typename Type, typename Type2> | |
Vec2< Type > | operator- (const Vec2< Type > &v1, const Vec2< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec2< Type > | operator- (const Vec2< Type > &v, const Type2 &n) |
template<typename Type> | |
Vec2< Type > | operator- (const Vec2< Type > &v) |
template<typename Type, typename Type2> | |
Type | operator * (const Vec2< Type > &v1, const Vec2< Type2 > &v2) |
template<typename Type, typename Type2> | |
Vec2< Type2 > | operator * (const Type &d, const Vec2< Type2 > &v) |
template<typename Type, typename Type2> | |
Vec2< Type > | operator * (const Vec2< Type > &v, const Type2 &d) |
template<typename Type, typename Type2> | |
Vec2< Type2 > | operator/ (const Type &d, const Vec2< Type2 > &v) |
template<typename Type, typename Type2> | |
Vec2< Type > | operator/ (const Vec2< Type > &v, const Type2 &d) |
template<typename Type, typename Type2> | |
bool | operator== (const Vec2< Type > &v1, const Vec2< Type2 > &v2) |
template<typename Type, typename Type2> | |
bool | operator!= (const Vec2< Type > &v1, const Vec2< Type2 > &v2) |
bool | isZero (double in_d, double in_dEps=1e-16) |
ScreenVector | operator * (const double s, const ScreenVector &v) |
std::ostream & | operator<< (std::ostream &os, const ScreenVector &v) |
std::ostream & | operator<< (std::ostream &os, const ScreenPoint &p) |
Vector3 | operator * (const double s, const Vector3 &v) |
double | dot (const Vector3 &w, const Vector3 &v) |
Vector3 | cross (const Vector3 &w, const Vector3 &v) |
double | length (const Vector3 &v) |
Vector3 | unit (const Vector3 &v) |
std::ostream & | operator<< (std::ostream &os, const Vector3 &v) |
Point3 | lerp (const Point3 &p0, const Point3 &p1, double dT) |
std::ostream & | operator<< (std::ostream &os, const Point3 &p) |
Vector3 | operator * (const Vector3 &v, const Matrix3 &m) |
Point3 | operator * (const Point3 &p, const Matrix3 &m) |
std::ostream & | operator<< (std::ostream &os, const Matrix3 &m) |
Vector4 | operator * (const double s, const Vector4 &v) |
double | length (const Vector4 &v) |
Vector4 | unit (const Vector4 &v) |
std::ostream & | operator<< (std::ostream &os, const Vector4 &v) |
std::ostream & | operator<< (std::ostream &os, const Matrix4 &m) |
Variables | |
const int | MAXFFT = 32768 |
These three values give the x,y,z size of the data in pixels (or more appropriately called voxels ). Data: The header is followed by x*y*z unsigned integer bytes of data with a resolution of 8, 16 or 32 bit. The data are written with high order byte first (big-endian). The resolution of the data is determined by the size of the df3-file. That is, if the file is twice (minus header, of course) as long as an 8 bit file then it is assumed to contain 16 bit ints and if it is four times as long 32 bit ints.
|
Definition at line 74 of file emdata.h. Referenced by EMAN::EMData::get_2dview(). |
|
Definition at line 75 of file emdata.h. Referenced by EMAN::EMData::get_3dview(). |
|
Definition at line 76 of file emdata.h. Referenced by EMAN::EMData::get_2dcview(). |
|
Definition at line 77 of file emdata.h. Referenced by EMAN::EMData::get_3dcview(), and EMAN::EMData::get_3dcviewptr(). |
|
|
|
|
|
|
|
|
|
|
Definition at line 699 of file vec3.h. Referenced by EMAN::EMUtil::process_region_io(). |
|
|
|
|
|
|
|
|
|
Fourier Product processing flag. Should the Fourier data be treated as manifestly periodic (CIRCULANT), padded with zeros (PADDED), or padded with a lag (PADDED_LAG). Also, in each of these cases the product may be normalized or not. Pick one, as there is no default.
Definition at line 66 of file fundamentals.h. 00066 { 00067 CIRCULANT = 1, 00068 CIRCULANT_NORMALIZED = 2, 00069 PADDED = 3, 00070 PADDED_NORMALIZED = 4, 00071 PADDED_LAG = 5, 00072 PADDED_NORMALIZED_LAG = 6 00073 };
|
|
Definition at line 76 of file fundamentals.h. 00076 { 00077 CORRELATION, 00078 CONVOLUTION, 00079 SELF_CORRELATION, 00080 AUTOCORRELATION 00081 };
|
|
Definition at line 227 of file fundamentals.h.
|
|
Definition at line 98 of file emobject.h. 00098 { 00099 NORMAL, 00100 ICOS2F_FIRST_OCTANT, 00101 ICOS2F_FULL, 00102 ICOS2F_HALF, 00103 ICOS3F_HALF, 00104 ICOS3F_FULL, 00105 ICOS5F_HALF, 00106 ICOS5F_FULL, 00107 ICOS_UNKNOWN 00108 };
|
|
Median filter.
Definition at line 254 of file fundamentals.h.
|
|
Image autocorrelation.
Definition at line 187 of file fundamentals.h. References AUTOCORRELATION, and fourierproduct(). 00187 { 00188 return fourierproduct(f, NULL, myflag, AUTOCORRELATION, center); 00189 }
|
|
Convolution of two images.
Definition at line 144 of file fundamentals.h. References CONVOLUTION, and fourierproduct(). Referenced by EMAN::EMData::calc_ccf(). 00144 { 00145 return fourierproduct(f, g, myflag, CONVOLUTION, center); 00146 }
|
|
Correlation of two images.
Definition at line 123 of file fundamentals.h. References CORRELATION, and fourierproduct(). Referenced by EMAN::EMData::calc_ccf(), EMAN::Util::constrained_helix(), and EMAN::Util::constrained_helix_test(). 00123 { 00124 return fourierproduct(f, g, myflag, CORRELATION, center); 00125 }
|
|
Definition at line 313 of file vecmath.h. 00313 {
00314 return w ^ v;
00315 }
|
|
Definition at line 309 of file vecmath.h. 00309 {
00310 return w * v;
00311 }
|
|
Definition at line 3665 of file aligner.cpp. 03666 { 03667 dump_factory < Aligner > (); 03668 }
|
|
Definition at line 3670 of file aligner.cpp. 03671 {
03672 return dump_factory_list < Aligner > ();
03673 }
|
|
Definition at line 816 of file analyzer.cpp. 00817 { 00818 dump_factory < Analyzer > (); 00819 }
|
|
Definition at line 821 of file analyzer.cpp. 00822 {
00823 return dump_factory_list < Analyzer > ();
00824 }
|
|
Definition at line 1073 of file averager.cpp. 01074 { 01075 dump_factory < Averager > (); 01076 }
|
|
Definition at line 1078 of file averager.cpp. 01079 {
01080 return dump_factory_list < Averager > ();
01081 }
|
|
Definition at line 1402 of file cmp.cpp. 01403 { 01404 dump_factory < Cmp > (); 01405 }
|
|
Definition at line 1407 of file cmp.cpp. 01408 {
01409 return dump_factory_list < Cmp > ();
01410 }
|
|
Definition at line 834 of file emobject.h. References EMAN::TypeDict::dump(). 00835 { 00836 vector < string > item_names = Factory < T >::get_list(); 00837 00838 for (size_t i = 0; i < item_names.size(); i++) { 00839 T *item = Factory < T >::get(item_names[i]); 00840 printf("%s : %s\n", item->get_name().c_str(),item->get_desc().c_str()); 00841 TypeDict td = item->get_param_types(); 00842 td.dump(); 00843 } 00844 }
|
|
Definition at line 846 of file emobject.h. References EMAN::TypeDict::get_desc(), EMAN::TypeDict::get_type(), EMAN::TypeDict::keys(), and EMAN::TypeDict::size(). 00847 { 00848 vector < string > item_names = Factory < T >::get_list(); 00849 map<string, vector<string> > factory_list; 00850 00851 typename vector<string>::const_iterator p; 00852 for(p = item_names.begin(); p !=item_names.end(); ++p) { 00853 T *item = Factory<T>::get(*p); 00854 00855 string name = item->get_name(); 00856 00857 vector<string> content; 00858 content.push_back(item->get_desc()); 00859 TypeDict td = item->get_param_types(); 00860 vector<string> keys = td.keys(); 00861 for(unsigned int i=0; i<td.size(); ++i) { 00862 content.push_back(keys[i]); 00863 content.push_back( td.get_type(keys[i]) ); 00864 content.push_back( td.get_desc(keys[i]) ); 00865 } 00866 factory_list[name] = content; 00867 } 00868 00869 return factory_list; 00870 }
|
|
Dumps useful information about the OrientationGenerator factory.
Definition at line 153 of file symmetry.cpp. 00154 { 00155 dump_factory < OrientationGenerator > (); 00156 }
|
|
Can be used to get useful information about the OrientationGenerator factory.
Definition at line 158 of file symmetry.cpp. 00159 {
00160 return dump_factory_list < OrientationGenerator > ();
00161 }
|
|
Definition at line 9759 of file processor.cpp. 09760 { 09761 dump_factory < Processor > (); 09762 }
|
|
Definition at line 9764 of file processor.cpp. 09765 {
09766 return dump_factory_list < Processor > ();
09767 }
|
|
Definition at line 2267 of file projector.cpp. 02268 { 02269 dump_factory < Projector > (); 02270 }
|
|
Definition at line 2272 of file projector.cpp. 02273 {
02274 return dump_factory_list < Projector > ();
02275 }
|
|
Definition at line 4069 of file reconstructor.cpp. 04070 { 04071 dump_factory < Reconstructor > (); 04072 }
|
|
Definition at line 4074 of file reconstructor.cpp. 04075 {
04076 return dump_factory_list < Reconstructor > ();
04077 }
|
|
dump symmetries, useful for obtaining symmetry information
Definition at line 64 of file symmetry.cpp. 00065 { 00066 dump_factory < Symmetry3D > (); 00067 }
|
|
dump_symmetries_list, useful for obtaining symmetry information
Definition at line 69 of file symmetry.cpp. 00070 {
00071 return dump_factory_list < Symmetry3D > ();
00072 }
|
|
Definition at line 597 of file rsconvolution.cpp. References EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, EMAN::EMData::set_size(), and EMAN::EMData::to_zero(). 00597 { 00598 00599 int nxf = f->get_xsize(); 00600 int nyf = f->get_ysize(); 00601 int nzf = f->get_zsize(); 00602 00603 int nxk = K->get_xsize(); 00604 int nyk = K->get_ysize(); 00605 int nzk = K->get_zsize(); 00606 00607 if ( nxf < nxk && nyf < nyk && nzf < nzk ) { 00608 // whoops, f smaller than K 00609 swap(f,K); swap(nxf,nxk); swap(nyf,nyk); swap(nzf,nzk); 00610 } else if ( nxk > nxf || nyk > nyf || nzk > nzf ) { 00611 // Incommensurate sizes 00612 throw ImageDimensionException("Two input images are incommensurate."); 00613 } 00614 00615 if ( nxk % 2 != 1 || nyk % 2 != 1 || nzk % 2 != 1 ) { 00616 // Kernel needs to be odd in size 00617 throw ImageDimensionException("Kernel should have odd nx,ny,nz so that the center is well-defined."); 00618 } 00619 00620 int nxk2 = (nxk-1)/2; 00621 int nyk2 = (nyk-1)/2; 00622 int nzk2 = (nzk-1)/2; 00623 00624 if ( mydilation == BINARY ) { 00625 // Check whether two images are truly binary. 00626 for (int iz = 0; iz <= nzf-1; iz++) { 00627 for (int iy = 0; iy <= nyf-1; iy++) { 00628 for (int ix = 0; ix <= nxf-1; ix++) { 00629 int fxyz=(int)(*f)(ix,iy,iz); 00630 if ( fxyz != 0 && fxyz != 1 ) { 00631 throw ImageDimensionException("One of the two images is not binary."); 00632 } 00633 } 00634 } 00635 } 00636 for (int iz = 0; iz <= nzk-1; iz++) { 00637 for (int iy = 0; iy <= nyk-1; iy++) { 00638 for (int ix = 0; ix <= nxk-1; ix++) { 00639 int kxyz=(int)(*K)(ix,iy,iz); 00640 if ( kxyz != 0 && kxyz != 1 ) { 00641 throw ImageDimensionException("One of the two images is not binary."); 00642 } 00643 } 00644 } 00645 } 00646 } 00647 00648 EMData* result = new EMData(); 00649 result->set_size(nxf, nyf, nzf); 00650 result->to_zero(); 00651 00652 for (int iz = 0; iz <= nzf-1; iz++) { 00653 for (int iy = 0; iy <= nyf-1; iy++) { 00654 for (int ix = 0; ix <= nxf-1; ix++) { 00655 // int kzmin = iz-nzk2 < 0 ? 0 : iz-nzk2 ; 00656 // int kzmax = iz+nzk2 > nzf-1 ? nzf-1 : iz+nzk2 ; 00657 // int kymin = iy-nyk2 < 0 ? 0 : iy-nyk2 ; 00658 // int kymax = iy+nyk2 > nyf-1 ? nyf-1 : iy+nyk2 ; 00659 // int kxmin = ix-nxk2 < 0 ? 0 : ix-nxk2 ; 00660 // int kxmax = ix+nxk2 > nxf-1 ? nxf-1 : ix+nxk2 ; 00661 if ( mydilation == BINARY ) { 00662 int fxyz = (int)(*f)(ix,iy,iz); 00663 if ( fxyz == 1 ) { 00664 for (int jz = -nzk2; jz <= nzk2; jz++) { 00665 for (int jy = -nyk2; jy <= nyk2; jy++) { 00666 for (int jx= -nxk2; jx <= nxk2; jx++) { 00667 if ( (int)(*K)(jx+nxk2,jy+nyk2,jz+nzk2) == 1 ) { 00668 int fz = iz+jz; 00669 int fy = iy+jy; 00670 int fx = ix+jx; 00671 if ( fz >= 0 && fz <= nzf-1 && fy >= 0 && fy <= nyf-1 && fx >= 0 && fx <= nxf-1 ) 00672 (*result)(fx,fy,fz) = 1; 00673 } 00674 } 00675 } 00676 } 00677 } 00678 } else if ( mydilation == GRAYLEVEL ) { 00679 float pmax = (*f)(ix,iy,iz)+(*K)(nxk2,nyk2,nzk2); 00680 for (int jz = -nzk2; jz <= nzk2; jz++) { 00681 for (int jy = -nyk2; jy <= nyk2; jy++) { 00682 for (int jx = -nxk2; jx <= nxk2; jx++) { 00683 int fz = iz+jz; 00684 int fy = iy+jy; 00685 int fx = ix+jx; 00686 if ( fz >= 0 && fz <= nzf-1 && fy >= 0 && fy <= nyf-1 && fx >= 0 && fx <= nxf-1 ) { 00687 float kxyz = (*K)(jx+nxk2,jy+nyk2,jz+nzk2); 00688 float fxyz = (*f)(fx,fy,fz); 00689 if ( kxyz+fxyz > pmax ) pmax = kxyz+fxyz; 00690 } 00691 } 00692 } 00693 } 00694 (*result)(ix,iy,iz) = pmax; 00695 } else { 00696 throw ImageDimensionException("Illegal dilation type!"); 00697 } 00698 } 00699 } 00700 } 00701 return result; 00702 }
|
|
Dilation filter.
Definition at line 704 of file rsconvolution.cpp. References EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, EMAN::EMData::set_size(), and EMAN::EMData::to_one(). 00704 { 00705 00706 int nxf = f->get_xsize(); 00707 int nyf = f->get_ysize(); 00708 int nzf = f->get_zsize(); 00709 00710 int nxk = K->get_xsize(); 00711 int nyk = K->get_ysize(); 00712 int nzk = K->get_zsize(); 00713 00714 if ( nxf < nxk && nyf < nyk && nzf < nzk ) { 00715 // whoops, f smaller than K 00716 swap(f,K); swap(nxf,nxk); swap(nyf,nyk); swap(nzf,nzk); 00717 } else if ( nxk > nxf || nyk > nyf || nzk > nzf ) { 00718 // Incommensurate sizes 00719 throw ImageDimensionException("Two input images are incommensurate."); 00720 } 00721 00722 if ( nxk % 2 != 1 || nyk % 2 != 1 || nzk % 2 != 1 ) { 00723 // Kernel needs to be odd in size 00724 throw ImageDimensionException("Kernel should have odd nx,ny,nz so that the center is well-defined."); 00725 } 00726 00727 int nxk2 = (nxk-1)/2; 00728 int nyk2 = (nyk-1)/2; 00729 int nzk2 = (nzk-1)/2; 00730 00731 if ( myerosion == BINARY ) { 00732 // Check whether two images are truly binary. 00733 for (int iz = 0; iz <= nzf-1; iz++) { 00734 for (int iy = 0; iy <= nyf-1; iy++) { 00735 for (int ix = 0; ix <= nxf-1; ix++) { 00736 int fxyz=(int)(*f)(ix,iy,iz); 00737 if ( fxyz != 0 && fxyz != 1 ) { 00738 throw ImageDimensionException("One of the two images is not binary."); 00739 } 00740 } 00741 } 00742 } 00743 for (int iz = 0; iz <= nzk-1; iz++) { 00744 for (int iy = 0; iy <= nyk-1; iy++) { 00745 for (int ix = 0; ix <= nxk-1; ix++) { 00746 int kxyz=(int)(*K)(ix,iy,iz); 00747 if ( kxyz != 0 && kxyz != 1 ) { 00748 throw ImageDimensionException("One of the two images is not binary."); 00749 } 00750 } 00751 } 00752 } 00753 } 00754 00755 EMData* result = new EMData(); 00756 result->set_size(nxf, nyf, nzf); 00757 result->to_one(); 00758 00759 for (int iz = 0; iz <= nzf-1; iz++) { 00760 for (int iy = 0; iy <= nyf-1; iy++) { 00761 for (int ix = 0; ix <= nxf-1; ix++) { 00762 if ( myerosion == BINARY ) { 00763 int fxyz = (int)(*f)(ix,iy,iz); 00764 if ( fxyz == 0 ) { 00765 for (int jz = -nzk2; jz <= nzk2; jz++) { 00766 for (int jy = -nyk2; jy <= nyk2; jy++) { 00767 for (int jx= -nxk2; jx <= nxk2; jx++) { 00768 if ( (int)(*K)(jx+nxk2,jy+nyk2,jz+nzk2) == 1 ) { 00769 int fz = iz+jz; 00770 int fy = iy+jy; 00771 int fx = ix+jx; 00772 if ( fz >= 0 && fz <= nzf-1 && fy >= 0 && fy <= nyf-1 && fx >= 0 && fx <= nxf-1 ) 00773 (*result)(fx,fy,fz) = 0; 00774 } 00775 } 00776 } 00777 } 00778 } 00779 } else if ( myerosion == GRAYLEVEL ) { 00780 float pmin = (*f)(ix,iy,iz)-(*K)(nxk2,nyk2,nzk2); 00781 for (int jz = -nzk2; jz <= nzk2; jz++) { 00782 for (int jy = -nyk2; jy <= nyk2; jy++) { 00783 for (int jx = -nxk2; jx <= nxk2; jx++) { 00784 int fz = iz+jz; 00785 int fy = iy+jy; 00786 int fx = ix+jx; 00787 if ( fz >= 0 && fz <= nzf-1 && fy >= 0 && fy <= nyf-1 && fx >= 0 && fx <= nxf-1 ) { 00788 float kxyz = (*K)(jx+nxk2,jy+nyk2,jz+nzk2); 00789 float fxyz = (*f)(fx,fy,fz); 00790 if ( fxyz-kxyz < pmin ) pmin = fxyz-kxyz; 00791 } 00792 } 00793 } 00794 } 00795 (*result)(ix,iy,iz) = pmin; 00796 } else { 00797 throw ImageDimensionException("Illegal dilation type!"); 00798 } 00799 } 00800 } 00801 } 00802 return result; 00803 }
|
|
Definition at line 559 of file rsconvolution.cpp. References EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, median(), EMAN::EMData::set_size(), and EMAN::EMData::to_zero(). 00559 { 00560 00561 int nxf = f->get_xsize(); 00562 int nyf = f->get_ysize(); 00563 int nzf = f->get_zsize(); 00564 00565 if ( nxk > nxf || nyk > nyf || nzk > nzf ) { 00566 // Kernel should be smaller than the size of image 00567 throw ImageDimensionException("Kernel should be smaller than the size of image."); 00568 } 00569 00570 if ( nxk % 2 != 1 || nyk % 2 != 1 || nzk % 2 != 1 ) { 00571 // Kernel needs to be odd in size 00572 throw ImageDimensionException("Real-space kernel must have odd size so that the center is well-defined."); 00573 } 00574 00575 if ( myshape == CIRCULAR ) { 00576 // For CIRCULAR kernal, size must be same on all dimensions 00577 if ( (nzf != 1 && ( nxk != nyk || nxk != nzk )) || (nzf == 1 && nyf != 1 && nxk != nyk) ) { 00578 throw ImageDimensionException("For CIRCULAR kernal, size must be same on all dimensions."); 00579 } 00580 } 00581 00582 EMData* result = new EMData(); 00583 result->set_size(nxf, nyf, nzf); 00584 result->to_zero(); 00585 00586 for (int iz = 0; iz <= nzf-1; iz++) { 00587 for (int iy = 0; iy <= nyf-1; iy++) { 00588 for (int ix = 0; ix <= nxf-1; ix++) { 00589 (*result)(ix,iy,iz) = median (*f, nxk, nyk, nzk, myshape, iz, iy, ix); 00590 } 00591 } 00592 } 00593 00594 return result; 00595 }
|
|
Fourier product of two images.
Definition at line 181 of file fundamentals.cpp. References abs, AUTOCORRELATION, CIRCULANT, EMAN::EMData::cmplx(), CONVOLUTION, EMAN::EMData::copy(), CORRELATION, EMAN::EMData::depad(), EMAN::EMData::depad_corner(), EMAN::EMData::div(), EMAN::EMData::do_fft_inplace(), EMAN::EMData::do_ift_inplace(), flag, EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), imag(), InvalidValueException, EMAN::EMData::is_complex(), EMAN::EMData::is_fftodd(), EMAN::EMData::is_real(), LOGERR, EMAN::EMData::norm_pad(), nx, ny, real(), SELF_CORRELATION, EMAN::EMData::set_array_offsets(), and EMAN::EMData::update(). Referenced by autocorrelation(), convolution(), correlation(), EMAN::ConvolutionProcessor::process_inplace(), and self_correlation(). 00181 { 00182 //std::complex<float> phase_mult; 00183 // Not only does the value of "flag" determine how we handle 00184 // periodicity, but it also determines whether or not we should 00185 // normalize the results. Here's some convenience bools: 00186 bool donorm = (0 == flag%2) ? true : false; 00187 // the 2x padding is hardcoded for now 00188 int npad = (flag >= 3) ? 2 : 1; // amount of padding used 00189 // g may be NULL. If so, have g point to the same object as f. In that 00190 // case we need to be careful later on not to try to delete g's workspace 00191 // as well as f's workspace, since they will be the same. 00192 bool gexists = true; 00193 if (!g) { g = f; gexists = false; } 00194 if ( f->is_complex() || g->is_complex() ) { 00195 // Fourier input only allowed for circulant 00196 if (CIRCULANT != flag) { 00197 LOGERR("Cannot perform normalization or padding on Fourier type."); 00198 throw InvalidValueException(flag, "Cannot perform normalization or padding on Fourier type."); 00199 } 00200 } 00201 // These are actual dimensions of f (and real-space sizes for ny and nz) 00202 int nx = f->get_xsize(); 00203 int ny = f->get_ysize(); 00204 int nz = f->get_zsize(); 00205 // We manifestly assume no zero-padding here, just the 00206 // necessary extension along x for the fft 00207 if (!f->is_real()) nx = (nx - 2 + (f->is_fftodd() ? 1 : 0)); 00208 00209 // these are padded dimensions 00210 const int nxp = npad*nx; 00211 const int nyp = (ny > 1) ? npad*ny : 1; // don't pad y for 1-d image 00212 const int nzp = (nz > 1) ? npad*nz : 1; // don't pad z for 2-d image 00213 00214 // now one half of the padded, fft-extended size along x 00215 const int lsd2 = (nxp + 2 - nxp%2) / 2; 00216 00217 EMData* fp = NULL; 00218 if (f->is_complex()) { 00219 // If f is already a fourier object then fp is a copy of f. 00220 // (The fp workspace is modified, so we copy f to keep f pristine.) 00221 fp=f->copy(); 00222 } else { 00223 // [normalize] [pad] compute fft 00224 fp = f->norm_pad(donorm, npad); 00225 if (donorm) { 00226 fp->div( sqrtf(nx) * sqrtf(ny) * sqrtf(nz) ); 00227 } 00228 fp->do_fft_inplace(); 00229 } 00230 // The [padded] fft-extended version of g is gp. 00231 EMData* gp = NULL; 00232 if(f==g) { 00233 // g is an alias for f, so gp should be an alias for fp 00234 gp=fp; 00235 } else if (g->is_complex()) { 00236 // g is already a Fourier object, so gp is just an alias for g 00237 // (The gp workspace is not modified, so we don't need a copy.) 00238 gp = g; 00239 } else { 00240 // normal case: g is real and different from f, so compute gp 00241 gp = g->norm_pad(donorm, npad); 00242 if (donorm) { 00243 gp->div( sqrtf(nx) * sqrtf(ny) * sqrtf(nz) ); 00244 } 00245 gp->do_fft_inplace(); 00246 } 00247 // Get complex matrix views of fp and gp; matrices start from 1 (not 0) 00248 fp->set_array_offsets(1,1,1); 00249 gp->set_array_offsets(1,1,1); 00250 00251 // If the center flag is true, put the center of the correlation in the middle 00252 // If it is false, put it in (0,0), this approach saves time, but it is diffcult to manage the result 00253 if (center) { 00254 // Multiply two functions (the real work of this routine) 00255 int itmp = nx/2; 00256 //float sx = float(-twopi*float(itmp)/float(nxp)); 00257 float sxn = 2*float(itmp)/float(nxp); 00258 float sx = -M_PI*sxn; 00259 itmp = ny/2; 00260 //float sy = float(-twopi*float(itmp)/float(nyp)); 00261 float syn = 2*float(itmp)/float(nyp); 00262 float sy = -M_PI*syn; 00263 itmp = nz/2; 00264 //float sz = float(-twopi*float(itmp)/float(nzp)); 00265 float szn = 2*float(itmp)/float(nzp); 00266 float sz = -M_PI*szn; 00267 if ( (flag > 2) || (nx%2==0 && (ny%2==0 || ny==1) && (nz%2==0 || nz==1)) ) { // padded images have always even size: if ( (padded) || (even) ) ... 00268 switch (ptype) { 00269 case AUTOCORRELATION: 00270 // fpmat := |fpmat|^2 00271 // Note nxp are padded dimensions 00272 for (int iz = 1; iz <= nzp; iz++) { 00273 for (int iy = 1; iy <= nyp; iy++) { 00274 for (int ix = 1; ix <= lsd2; ix++) { 00275 float fpr = real(fp->cmplx(ix,iy,iz)); 00276 float fpi = imag(fp->cmplx(ix,iy,iz)); 00277 fp->cmplx(ix,iy,iz) = complex<float>(fpr*fpr+fpi*fpi, 0.0f); 00278 } 00279 } 00280 } 00281 break; 00282 case SELF_CORRELATION: 00283 // fpmat:=|fpmat| 00284 // Note nxp are padded dimensions 00285 for (int iz = 1; iz <= nzp; iz++) { 00286 for (int iy = 1; iy <= nyp; iy++) { 00287 for (int ix = 1; ix <= lsd2; ix++) { 00288 fp->cmplx(ix,iy,iz) = complex<float>(abs(fp->cmplx(ix,iy,iz)), 0.0f); 00289 } 00290 } 00291 } 00292 break; 00293 case CORRELATION: 00294 // fpmat:=fpmat*conjg(gpmat) 00295 // Note nxp are padded dimensions 00296 for (int iz = 1; iz <= nzp; iz++) { 00297 for (int iy = 1; iy <= nyp; iy++) { 00298 for (int ix = 1; ix <= lsd2; ix++) { 00299 fp->cmplx(ix,iy,iz) *= conj(gp->cmplx(ix,iy,iz)); 00300 } 00301 } 00302 } 00303 break; 00304 case CONVOLUTION: 00305 // fpmat:=fpmat*gpmat 00306 // Note nxp are padded dimensions 00307 for (int iz = 1; iz <= nzp; iz++) { 00308 for (int iy = 1; iy <= nyp; iy++) { 00309 for (int ix = 1; ix <= lsd2; ix++) { 00310 fp->cmplx(ix,iy,iz) *= gp->cmplx(ix,iy,iz); 00311 } 00312 } 00313 } 00314 break; 00315 default: 00316 LOGERR("Illegal option in Fourier Product"); 00317 throw InvalidValueException(ptype, "Illegal option in Fourier Product"); 00318 } 00319 for (int iz = 1; iz <= nzp; iz++) { 00320 for (int iy = 1; iy <= nyp; iy++) { 00321 for (int ix = (iz+iy+1)%2+1; ix <= lsd2; ix+=2) { 00322 fp->cmplx(ix,iy,iz) = -fp->cmplx(ix,iy,iz); 00323 } 00324 } 00325 } 00326 } else { 00327 switch (ptype) { 00328 case AUTOCORRELATION: 00329 // fpmat := |fpmat|^2 00330 // Note nxp are padded dimensions 00331 for (int iz = 1; iz <= nzp; iz++) { 00332 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00333 for (int iy = 1; iy <= nyp; iy++) { 00334 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00335 for (int ix = 1; ix <= lsd2; ix++) { 00336 int jx=ix-1; float arg=sx*jx+argy; 00337 float fpr = real(fp->cmplx(ix,iy,iz)); 00338 float fpi = imag(fp->cmplx(ix,iy,iz)); 00339 fp->cmplx(ix,iy,iz)= (fpr*fpr + fpi*fpi) *std::complex<float>(cos(arg),sin(arg)); 00340 } 00341 } 00342 } 00343 break; 00344 case SELF_CORRELATION: 00345 // fpmat:=|fpmat| 00346 // Note nxp are padded dimensions 00347 for (int iz = 1; iz <= nzp; iz++) { 00348 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00349 for (int iy = 1; iy <= nyp; iy++) { 00350 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00351 for (int ix = 1; ix <= lsd2; ix++) { 00352 int jx=ix-1; float arg=sx*jx+argy; 00353 fp->cmplx(ix,iy,iz) = abs(fp->cmplx(ix,iy,iz)) *std::complex<float>(cos(arg),sin(arg)); 00354 } 00355 } 00356 } 00357 break; 00358 case CORRELATION: 00359 // fpmat:=fpmat*conjg(gpmat) 00360 // Note nxp are padded dimensions 00361 for (int iz = 1; iz <= nzp; iz++) { 00362 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00363 for (int iy = 1; iy <= nyp; iy++) { 00364 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00365 for (int ix = 1; ix <= lsd2; ix++) { 00366 int jx=ix-1; float arg=sx*jx+argy; 00367 fp->cmplx(ix,iy,iz) *= conj(gp->cmplx(ix,iy,iz)) *std::complex<float>(cos(arg),sin(arg)); 00368 } 00369 } 00370 } 00371 break; 00372 case CONVOLUTION: 00373 // fpmat:=fpmat*gpmat 00374 // Note nxp are padded dimensions 00375 if(npad == 1) { 00376 sx -= 4*(nx%2)/float(nx); 00377 sy -= 4*(ny%2)/float(ny); 00378 sz -= 4*(nz%2)/float(nz); 00379 } 00380 for (int iz = 1; iz <= nzp; iz++) { 00381 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00382 for (int iy = 1; iy <= nyp; iy++) { 00383 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00384 for (int ix = 1; ix <= lsd2; ix++) { 00385 int jx=ix-1; float arg=sx*jx+argy; 00386 fp->cmplx(ix,iy,iz) *= gp->cmplx(ix,iy,iz) *std::complex<float>(cos(arg),sin(arg)); 00387 } 00388 } 00389 } 00390 break; 00391 default: 00392 LOGERR("Illegal option in Fourier Product"); 00393 throw InvalidValueException(ptype, "Illegal option in Fourier Product"); 00394 } 00395 } 00396 } else { 00397 // If the center flag is false, then just do basic multiplication 00398 // Here I aterd the method of complex calculation. This method is much faster than the previous one. 00399 switch (ptype) { 00400 case AUTOCORRELATION: 00401 for (int iz = 1; iz <= nzp; iz++) { 00402 for (int iy = 1; iy <= nyp; iy++) { 00403 for (int ix = 1; ix <= lsd2; ix++) { 00404 float fpr = real(fp->cmplx(ix,iy,iz)); 00405 float fpi = imag(fp->cmplx(ix,iy,iz)); 00406 fp->cmplx(ix,iy,iz) = complex<float>(fpr*fpr+fpi*fpi, 0.0f); 00407 } 00408 } 00409 } 00410 break; 00411 case SELF_CORRELATION: 00412 for (int iz = 1; iz <= nzp; iz++) { 00413 for (int iy = 1; iy <= nyp; iy++) { 00414 for (int ix = 1; ix <= lsd2; ix++) { 00415 fp->cmplx(ix,iy,iz) = complex<float>(abs(fp->cmplx(ix,iy,iz)), 0.0f); 00416 } 00417 } 00418 } 00419 break; 00420 case CORRELATION: 00421 //phase_mult = 1; 00422 for (int iz = 1; iz <= nzp; iz++) { 00423 for (int iy = 1; iy <= nyp; iy++) { 00424 for (int ix = 1; ix <= lsd2; ix++) { 00425 fp->cmplx(ix,iy,iz)*= conj(gp->cmplx(ix,iy,iz)); 00426 } 00427 } 00428 } 00429 break; 00430 case CONVOLUTION: 00431 if(npad == 1) { 00432 float sx = -M_PI*2*(nx%2)/float(nx); 00433 float sy = -M_PI*2*(ny%2)/float(ny); 00434 float sz = -M_PI*2*(nz%2)/float(nz); 00435 for (int iz = 1; iz <= nzp; iz++) { 00436 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00437 for (int iy = 1; iy <= nyp; iy++) { 00438 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00439 for (int ix = 1; ix <= lsd2; ix++) { 00440 int jx=ix-1; float arg=sx*jx+argy; 00441 fp->cmplx(ix,iy,iz) *= gp->cmplx(ix,iy,iz) *std::complex<float>(cos(arg),sin(arg)); 00442 } 00443 } 00444 } 00445 } else { 00446 for (int iz = 1; iz <= nzp; iz++) { 00447 for (int iy = 1; iy <= nyp; iy++) { 00448 for (int ix = 1; ix <= lsd2; ix++) { 00449 fp->cmplx(ix,iy,iz)*= gp->cmplx(ix,iy,iz); 00450 } 00451 } 00452 } 00453 } 00454 break; 00455 default: 00456 LOGERR("Illegal option in Fourier Product"); 00457 throw InvalidValueException(ptype, "Illegal option in Fourier Product"); 00458 } 00459 } 00460 // Now done w/ gp, so let's get rid of it (if it's not an alias of fp or simply g was complex on input); 00461 if (gexists && (f != g) && (!g->is_complex())) { 00462 if( gp ) { 00463 delete gp; 00464 gp = 0; 00465 } 00466 } 00467 // back transform 00468 fp->do_ift_inplace(); 00469 if(center && npad ==2) fp->depad(); 00470 else fp->depad_corner(); 00471 00472 //vector<int> saved_offsets = fp->get_array_offsets(); I do not know what the meaning of it was, did not work anyway PAP 00473 fp->set_array_offsets(1,1,1); 00474 00475 // Lag normalization 00476 if(flag>4) { 00477 int nxc=nx/2+1, nyc=ny/2+1, nzc=nz/2+1; 00478 for (int iz = 1; iz <= nz; iz++) { 00479 const float lagz = float(nz) / (nz-abs(iz-nzc)); 00480 for (int iy = 1; iy <= ny; iy++) { 00481 const float lagyz = lagz * (float(ny) / (ny-abs(iy-nyc))); 00482 for (int ix = 1; ix <= nx; ix++) { 00483 (*fp)(ix,iy,iz) *= lagyz * (float(nx) / (nx-abs(ix-nxc))); 00484 } 00485 } 00486 } 00487 } 00488 //OVER AND OUT 00489 //fp->set_array_offsets(saved_offsets); This was strange and did not work, PAP 00490 fp->set_array_offsets(0,0,0); 00491 fp->update(); 00492 return fp; 00493 }
|
|
Definition at line 9769 of file processor.cpp. References EMAN::Factory< T >::get(), EMAN::Factory< T >::get_list(), and EMAN::Processor::get_name(). 09770 { 09771 map<string, vector<string> > processor_groups; 09772 09773 vector <string> processornames = Factory<Processor>::get_list(); 09774 09775 for (size_t i = 0; i < processornames.size(); i++) { 09776 Processor * f = Factory<Processor>::get(processornames[i]); 09777 if (dynamic_cast<RealPixelProcessor*>(f) != 0) { 09778 processor_groups["RealPixelProcessor"].push_back(f->get_name()); 09779 } 09780 else if (dynamic_cast<BoxStatProcessor*>(f) != 0) { 09781 processor_groups["BoxStatProcessor"].push_back(f->get_name()); 09782 } 09783 else if (dynamic_cast<ComplexPixelProcessor*>(f) != 0) { 09784 processor_groups["ComplexPixelProcessor"].push_back(f->get_name()); 09785 } 09786 else if (dynamic_cast<CoordinateProcessor*>(f) != 0) { 09787 processor_groups["CoordinateProcessor"].push_back(f->get_name()); 09788 } 09789 else if (dynamic_cast<FourierProcessor*>(f) != 0) { 09790 processor_groups["FourierProcessor"].push_back(f->get_name()); 09791 } 09792 else if (dynamic_cast<NewFourierProcessor*>(f) != 0) { 09793 processor_groups["FourierProcessor"].push_back(f->get_name()); 09794 } 09795 else if (dynamic_cast<NormalizeProcessor*>(f) != 0) { 09796 processor_groups["NormalizeProcessor"].push_back(f->get_name()); 09797 } 09798 else { 09799 processor_groups["Others"].push_back(f->get_name()); 09800 } 09801 } 09802 09803 return processor_groups; 09804 }
|
|
Definition at line 48 of file vecmath.h. Referenced by EMAN::Matrix4::approxEqual(), EMAN::Vector4::approxEqual(), EMAN::Matrix3::approxEqual(), EMAN::Point3::approxEqual(), EMAN::Vector3::approxEqual(), EMAN::Matrix4::inverse(), EMAN::Matrix3::inverse(), and EMAN::Matrix4::operator *(). 00049 { 00050 return (in_d < in_dEps && in_d > -in_dEps)? true : false; 00051 }
|
|
Definition at line 688 of file vecmath.h. References EMAN::Vector4::length(), and v. Referenced by EMAN::Vector4::normalize(), EMAN::Vec2< Type >::normalize(), EMAN::Vec3< int >::normalize(), and EMAN::Vec4< Type >::normalize(). 00688 { return v.length(); }
|
|
Definition at line 317 of file vecmath.h. References EMAN::Vector3::length(), and v. Referenced by EMAN::TestImageFourierNoiseProfile::process_inplace(), EMAN::CTFSNRWeightProcessor::process_inplace(), and EMAN::TestImageFourierNoiseGaussian::process_inplace(). 00317 { return v.length(); }
|
|
Definition at line 406 of file vecmath.h. 00407 { 00408 const double dTMinus = 1.0 - dT; 00409 return Point3( dTMinus * p0[0] + dT * p1[0], dTMinus * p0[1] + dT * p1[1], dTMinus * p0[2] + dT * p1[2] ); 00410 }
|
|
Definition at line 8481 of file processor.cpp. References Assert, and EMAN::EMData::process_inplace(). 08482 { 08483 Assert(image != 0); 08484 Assert(processornames.size() > 0); 08485 08486 for (size_t i = 0; i < processornames.size(); i++) { 08487 image->process_inplace(processornames[i]); 08488 } 08489 return 0; 08490 }
|
|
Definition at line 684 of file vecmath.h. References v. 00684 {
00685 return Vector4( v[0] * s, v[1] * s, v[2] * s, v[3] * s );
00686 }
|
|
Definition at line 578 of file vecmath.h. 00578 {
00579 return Point3(m(0,0) * p[0] + m(1,0) * p[1] + m(2,0) * p[2],
00580 m(0,1) * p[0] + m(1,1) * p[1] + m(2,1) * p[2],
00581 m(0,2) * p[0] + m(1,2) * p[1] + m(2,2) * p[2]);
00582 }
|
|
Definition at line 571 of file vecmath.h. References v. 00571 {
00572 return Vector3(m(0,0) * v[0] + m(1,0) * v[1] + m(2,0) * v[2],
00573 m(0,1) * v[0] + m(1,1) * v[1] + m(2,1) * v[2],
00574 m(0,2) * v[0] + m(1,2) * v[1] + m(2,2) * v[2]);
00575 }
|
|
Definition at line 305 of file vecmath.h. References v. 00305 {
00306 return Vector3( v[0] * s, v[1] * s, v[2] * s );
00307 }
|
|
Definition at line 133 of file vecmath.h. References v. 00133 { 00134 return ScreenVector( (int)(v[0] * s), (int)(v[1] * s) ); 00135 }
|
|
Definition at line 1035 of file vec3.h. References v. 01035 { 01036 // Preserve the vector type 01037 Vec2<Type> v1(v); 01038 v1 *= d; 01039 return v1; 01040 }
|
|
Definition at line 1026 of file vec3.h. References v. 01027 { 01028 // Preserve the vector type 01029 Vec2<Type2> v1(v); 01030 v1 *= d; 01031 return v1; 01032 }
|
|
Definition at line 1020 of file vec3.h. References EMAN::Vec2< Type >::dot(). 01021 {
01022 return v1.dot(v2);
01023 }
|
|
Definition at line 657 of file vec3.h. References v. 00657 { 00658 // Preserve the vector type 00659 Vec3<Type> v1(v); 00660 v1 *= d; 00661 return v1; 00662 }
|
|
Definition at line 648 of file vec3.h. References v. 00649 { 00650 // Preserve the vector type 00651 Vec3<Type2> v1(v); 00652 v1 *= d; 00653 return v1; 00654 }
|
|
Definition at line 642 of file vec3.h. References EMAN::Vec3< Type >::dot(). 00643 {
00644 return v1.dot(v2);
00645 }
|
|
Vector times a matrix. Highly specialized. Useful when the upper 3x3 only contains rotations and you want to quickly multiply by the rotation matrix inverse (transpose) Definition at line 550 of file transform.h. References v, Vec3f, x, and y. 00551 { 00552 float x = v[0] * M[0][0] + v[1] * M[1][0] + v[2] * M[2][0] ; 00553 float y = v[0] * M[0][1] + v[1] * M[1][1] + v[2] * M[2][1]; 00554 float z = v[0] * M[0][2] + v[1] * M[1][2] + v[2] * M[2][2]; 00555 return Vec3f(x, y, z); 00556 }
|
|
Matrix times Vector, a pure mathematical operation.
Definition at line 541 of file transform.h. References EMAN::Transform::transform(), v, and Vec2f. 00542 {
00543 return M.transform(v);
00544 }
|
|
Matrix times Vector, a pure mathematical operation.
Definition at line 534 of file transform.h. References EMAN::Transform::transform(), v, and Vec3f. 00535 {
00536 return M.transform(v);
00537 }
|
|
Matrix times Matrix, a pure mathematical operation.
Definition at line 1306 of file transform.cpp. 01307 { 01308 Transform result; 01309 for (int i=0; i<3; i++) { 01310 for (int j=0; j<4; j++) { 01311 result[i][j] = M2[i][0] * M1[0][j] + M2[i][1] * M1[1][j] + M2[i][2] * M1[2][j]; 01312 } 01313 result[i][3] += M2[i][3]; 01314 } 01315 01316 return result; 01317 }
|
|
Definition at line 337 of file quaternion.cpp. 00338 { 00339 Quaternion q1 = q; 00340 q1 *= s; 00341 return q1; 00342 }
|
|
Definition at line 330 of file quaternion.cpp. 00331 { 00332 Quaternion q1 = q; 00333 q1 *= s; 00334 return q1; 00335 }
|
|
Definition at line 323 of file quaternion.cpp. References q. 00324 { 00325 Quaternion q = q1; 00326 q *= q2; 00327 return q; 00328 }
|
|
Definition at line 3099 of file emdata.cpp. References b, EMAN::EMData::copy(), and EMAN::EMData::mult().
|
|
Definition at line 3058 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::mult().
|
|
Definition at line 3028 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::mult().
|
|
Definition at line 1068 of file vec3.h. 01068 { 01069 if (v1[0] != v2[0] || v1[1] != v2[1] ) { 01070 return true; 01071 } 01072 return false; 01073 }
|
|
Definition at line 690 of file vec3.h. 00690 { 00691 if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) { 00692 return true; 00693 } 00694 return false; 00695 }
|
|
Definition at line 370 of file quaternion.cpp. 00371 {
00372 return (!(q1 == q2));
00373 }
|
|
Definition at line 62 of file geometry.cpp. 00063 {
00064 return !(p1 == p2);
00065 }
|
|
Definition at line 1098 of file emobject.cpp. 01099 {
01100 return !(d1 == d2);
01101 }
|
|
Definition at line 944 of file emobject.cpp. 00945 {
00946 return !(e1 == e2);
00947 }
|
|
Definition at line 991 of file vec3.h. References v. 00992 {
00993 Vec2<Type> v1(v);
00994 v1 += n;
00995 return v1;
00996 }
|
|
Definition at line 985 of file vec3.h. 00986 {
00987 return Vec2<Type>(static_cast<Type>(v1[0] + v2[0]), static_cast<Type>(v1[1] + v2[1]));;
00988 }
|
|
Definition at line 597 of file vec3.h. References v. 00598 {
00599 Vec3<Type> v1(v);
00600 v1 += n;
00601 return v1;
00602 }
|
|
Definition at line 590 of file vec3.h. 00591 {
00592
00593 return Vec3<Type>(static_cast<Type>(v1[0] + v2[0]), static_cast<Type>(v1[1] + v2[1]),static_cast<Type>(v1[2] + v2[2]));;
00594 }
|
|
Definition at line 308 of file quaternion.cpp. References q. 00309 { 00310 Quaternion q = q1; 00311 q += q2; 00312 return q; 00313 }
|
|
Definition at line 3085 of file emdata.cpp. References EMAN::EMData::add(), b, and EMAN::EMData::copy().
|
|
Definition at line 3043 of file emdata.cpp. References EMAN::EMData::add(), and EMAN::EMData::copy().
|
|
Definition at line 3014 of file emdata.cpp. References EMAN::EMData::add(), and EMAN::EMData::copy().
|
|
Definition at line 1013 of file vec3.h. References v.
|
|
Definition at line 1005 of file vec3.h. References v. 01006 {
01007 Vec2<Type> v1(v);
01008 v1 -= n;
01009 return v1;
01010 }
|
|
Definition at line 999 of file vec3.h. 01000 {
01001 return Vec2<Type>(static_cast<Type>(v1[0] - v2[0]), static_cast<Type>(v1[1] - v2[1]));
01002 }
|
|
Definition at line 628 of file vec3.h. References v.
|
|
Definition at line 621 of file vec3.h. References v. 00622 {
00623 Vec3<Type> v1(v);
00624 v1 -= n;
00625 return v1;
00626 }
|
|
Definition at line 613 of file vec3.h. 00614 {
00615 return Vec3<Type>(static_cast<Type>(v1[0] - v2[0]),
00616 static_cast<Type>(v1[1] - v2[1]),
00617 static_cast<Type>(v1[2] - v2[2]));
00618 }
|
|
Definition at line 315 of file quaternion.cpp. References q. 00316 { 00317 Quaternion q = q1; 00318 q -= q2; 00319 return q; 00320 }
|
|
Definition at line 41 of file geometry.cpp. 00042 { 00043 return IntPoint(-p[0],-p[1],-p[2]); 00044 }
|
|
Definition at line 3092 of file emdata.cpp. References b, EMAN::EMData::copy(), and EMAN::EMData::sub().
|
|
Definition at line 3050 of file emdata.cpp. References EMAN::EMData::add(), EMAN::EMData::copy(), and EMAN::EMData::mult(). 03051 { 03052 EMData * r = em.copy(); 03053 r->mult(-1.0f); 03054 r->add(n); 03055 return r; 03056 }
|
|
Definition at line 3021 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::sub(). Referenced by rsub().
|
|
Definition at line 1052 of file vec3.h. References v. 01052 { 01053 // Preserve the vector type 01054 Vec2<Type> v1(v); 01055 v1 /= d; 01056 return v1; 01057 }
|
|
Definition at line 1043 of file vec3.h. References v. 01044 { 01045 // Preserve the vector type 01046 Vec2<Type2> v1(v); 01047 v1 /= d; 01048 return v1; 01049 }
|
|
Definition at line 674 of file vec3.h. References v. 00674 { 00675 // Preserve the vector type 00676 Vec3<Type> v1(v); 00677 v1 /= d; 00678 return v1; 00679 }
|
|
Definition at line 665 of file vec3.h. References v. 00666 { 00667 // Preserve the vector type 00668 Vec3<Type2> v1(v); 00669 v1 /= d; 00670 return v1; 00671 }
|
|
Definition at line 344 of file quaternion.cpp. References q. 00345 { 00346 Quaternion q = q1; 00347 q /= q2; 00348 return q; 00349 }
|
|
Definition at line 3106 of file emdata.cpp. References b, EMAN::EMData::copy(), and EMAN::EMData::div().
|
|
Definition at line 3065 of file emdata.cpp. References EMAN::EMData::copy(), EMAN::EMData::div(), EMAN::EMData::mult(), and EMAN::EMData::to_one(). 03066 { 03067 EMData * r = em.copy(); 03068 r->to_one(); 03069 r->mult(n); 03070 r->div(em); 03071 03072 return r; 03073 }
|
|
Definition at line 3035 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::div(). Referenced by rdiv().
|
|
Definition at line 46 of file geometry.cpp. References EMAN::Pixel::value.
|
|
Definition at line 952 of file vecmath.h. References EMAN::Matrix4::row(). 00952 { 00953 os << m.row(0) << std::endl; 00954 os << m.row(1) << std::endl; 00955 os << m.row(2) << std::endl; 00956 os << m.row(3) << std::endl; 00957 return os; 00958 }
|
|
Definition at line 690 of file vecmath.h. References v. 00690 { 00691 os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")"; 00692 return os; 00693 }
|
|
Definition at line 584 of file vecmath.h. References EMAN::Matrix3::row(). 00584 {
00585 os << m.row(0) << std::endl;
00586 os << m.row(1) << std::endl;
00587 os << m.row(2) << std::endl;
00588 return os;
00589 }
|
|
Definition at line 412 of file vecmath.h. 00412 { 00413 os << "(" << p[0] << ", " << p[1] << ", " << p[2] << ")"; 00414 return os; 00415 }
|
|
Definition at line 320 of file vecmath.h. References v.
|
|
Definition at line 200 of file vecmath.h. 00200 { 00201 os << "(" << p[0] << ", " << p[1] << ")"; 00202 return os; 00203 }
|
|
Definition at line 137 of file vecmath.h. References v.
|
|
Definition at line 1060 of file vec3.h. 01060 { 01061 if (v1[0] == v2[0] && v1[1] == v2[1] ) { 01062 return true; 01063 } 01064 return false; 01065 }
|
|
Definition at line 682 of file vec3.h. 00682 { 00683 if (v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2]) { 00684 return true; 00685 } 00686 return false; 00687 }
|
|
Definition at line 352 of file quaternion.cpp. References EMAN::Quaternion::as_list(). 00353 { 00354 bool result = true; 00355 const float err_limit = 0.00001f; 00356 00357 vector < float >v1 = q1.as_list(); 00358 vector < float >v2 = q2.as_list(); 00359 00360 for (size_t i = 0; i < v1.size(); i++) { 00361 if (fabs(v1[i] - v2[i]) > err_limit) { 00362 result = false; 00363 break; 00364 } 00365 } 00366 00367 return result; 00368 }
|
|
Definition at line 54 of file geometry.cpp. References EMAN::Pixel::value, EMAN::Pixel::x, EMAN::Pixel::y, and EMAN::Pixel::z. 00055 { 00056 if (p1.x == p2.x && p1.y == p2.y && p1.z == p2.z && p1.value == p2.value) { 00057 return true; 00058 } 00059 return false; 00060 }
|
|
Definition at line 1092 of file emobject.cpp. References EMAN::Dict::dict. 01093 { 01094 // Just make use of map's version of operator== 01095 return (d1.dict == d2.dict); 01096 }
|
|
Definition at line 841 of file emobject.cpp. References EMAN::EMObject::b, EMAN::EMObject::d, EMAN::EMObject::emdata, EMAN::EMObject::f, EMAN::EMObject::farray, EMAN::EMObject::fp, EMAN::EMObject::iarray, EMAN::EMObject::ip, EMAN::EMObject::n, EMAN::EMObject::si, EMAN::EMObject::str, EMAN::EMObject::strarray, EMAN::EMObject::transformarray, EMAN::EMObject::type, EMAN::EMObject::ui, EMAN::EMObject::vp, and EMAN::EMObject::xydata. 00842 { 00843 00844 if (e1.type != e2.type) { 00845 return false; 00846 } 00847 00848 switch (e1.type) { 00849 case EMObject::BOOL: 00850 return (e1.b == e2.b); 00851 break; 00852 case EMObject::SHORT: 00853 return (e1.si == e2.si); 00854 break; 00855 case EMObject::INT: 00856 return (e1.n == e2.n); 00857 break; 00858 case EMObject::UNSIGNEDINT: 00859 return (e1.ui == e2.ui); 00860 break; 00861 case EMObject::FLOAT: 00862 return (e1.f == e2.f); 00863 break; 00864 case EMObject::DOUBLE: 00865 return (e1.d == e2.d); 00866 break; 00867 case EMObject::CTF: 00868 case EMObject::STRING: 00869 return (e1.str == e2.str); 00870 break; 00871 case EMObject::FLOAT_POINTER: 00872 return (e1.fp == e2.fp); 00873 break; 00874 case EMObject::INT_POINTER: 00875 return (e1.ip == e2.ip); 00876 break; 00877 case EMObject::VOID_POINTER: 00878 return (e1.vp == e2.vp); 00879 break; 00880 case EMObject::EMDATA: 00881 return (e1.emdata == e2.emdata); 00882 break; 00883 case EMObject::XYDATA: 00884 return (e1.xydata == e2.xydata); 00885 break; 00886 case EMObject::TRANSFORM: 00887 case EMObject::FLOATARRAY: 00888 if (e1.farray.size() == e2.farray.size()) { 00889 for (size_t i = 0; i < e1.farray.size(); i++) { 00890 if (e1.farray[i] != e2.farray[i]) { 00891 return false; 00892 } 00893 } 00894 return true; 00895 } 00896 else { 00897 return false; 00898 } 00899 break; 00900 case EMObject::INTARRAY: 00901 if (e1.iarray.size() == e2.iarray.size()) { 00902 for (size_t i = 0; i < e1.iarray.size(); i++) { 00903 if (e1.iarray[i] != e2.iarray[i]) { 00904 return false; 00905 } 00906 } 00907 return true; 00908 } 00909 break; 00910 case EMObject::STRINGARRAY: 00911 if (e1.strarray.size() == e2.strarray.size()) { 00912 for (size_t i = 0; i < e1.strarray.size(); i++) { 00913 if (e1.strarray[i] != e2.strarray[i]) { 00914 return false; 00915 } 00916 } 00917 return true; 00918 } 00919 else { 00920 return false; 00921 } 00922 break; 00923 case EMObject::TRANSFORMARRAY: 00924 if (e1.transformarray.size() == e2.transformarray.size()) { 00925 for (size_t i = 0; i < e1.transformarray.size(); i++) { 00926 if (e1.transformarray[i] != e2.transformarray[i]) { 00927 return false; 00928 } 00929 } 00930 } 00931 break; 00932 case EMObject::UNKNOWN: 00933 // UNKNOWN really means "no type" and if two objects both have 00934 // type UNKNOWN they really are the same 00935 return (e1.type == e2.type); 00936 break; 00937 default: 00938 return false; 00939 break; 00940 } 00941 return false; 00942 }
|
|
Direct Fourier inversion Reconstructor.
Definition at line 1957 of file reconstructor.cpp. References Assert, EMAN::EMData::average_circ_sub(), EMAN::EMData::center_origin_fft(), checked_delete(), EMAN::EMData::do_fft_inplace(), EMAN::EMData::get_attr_default(), EMAN::Transform::get_trans_2d(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::norm_pad(), nx, ny, EMAN::EMData::process_inplace(), EMAN::EMData::set_attr(), t, and Vec2f. Referenced by EMAN::file_store::add_image(), and EMAN::newfile_store::add_image(). 01958 { 01959 int nx = slice->get_xsize(); 01960 int ny = slice->get_ysize(); 01961 int ndim = (ny==1) ? 1 : 2; 01962 01963 if( ndim==2 && nx!=ny ) 01964 { 01965 // FIXME: What kind of exception should we throw here? 01966 throw std::runtime_error("Tried to padfft a 2D slice which is not square."); 01967 } 01968 01969 // process 2D slice or 1D line -- subtract the average outside of the circle, zero-pad, fft extend, and fft 01970 EMData* temp = slice->average_circ_sub(); 01971 01972 Assert( temp != NULL ); 01973 EMData* zeropadded = temp->norm_pad( false, npad ); 01974 Assert( zeropadded != NULL ); 01975 checked_delete( temp ); 01976 01977 zeropadded->do_fft_inplace(); 01978 EMData* padfftslice = zeropadded; 01979 01980 // shift the projection 01981 Vec2f trans = t.get_trans_2d(); 01982 float sx = -trans[0]; 01983 float sy = -trans[1]; 01984 if(sx != 0.0f || sy != 0.0) 01985 padfftslice->process_inplace("filter.shift", Dict("x_shift", sx, "y_shift", sy, "z_shift", 0.0f)); 01986 01987 int remove = slice->get_attr_default("remove", 0); 01988 padfftslice->set_attr( "remove", remove ); 01989 01990 01991 01992 padfftslice->center_origin_fft(); 01993 return padfftslice; 01994 }
|
|
Definition at line 40 of file fundamentals.cpp. References EMAN::EMData::cmplx(), EMAN::EMData::copy(), EMAN::EMData::do_fft_inplace(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), imag(), EMAN::EMData::is_complex(), EMAN::EMData::is_fftodd(), EMAN::EMData::norm_pad(), nx, ny, power(), real(), EMAN::EMData::set_array_offsets(), EMAN::EMData::set_attr(), EMAN::EMData::set_size(), and EMAN::EMData::update(). 00040 { 00041 // These are actual dimensions 00042 int nx = f->get_xsize(); 00043 int ny = f->get_ysize(); 00044 int nz = f->get_zsize(); 00045 00046 // We manifestly assume no zero-padding here, just the 00047 // necessary extension along x for the fft 00048 00049 if (f->is_complex()) nx = (nx - 2 + f->is_fftodd()); // nx is the real-space size of the input image 00050 int lsd2 = (nx + 2 - nx%2) / 2; // Extended x-dimension of the complex image 00051 00052 // Process f if real 00053 EMData* fp = NULL; 00054 if(f->is_complex()) fp = f->copy(); // we need to make a full copy so that we don't damage the original 00055 else { 00056 00057 fp = f->norm_pad(false, 1); // Extend and do the FFT if f is real 00058 fp->do_fft_inplace(); 00059 00060 00061 } 00062 fp->set_array_offsets(1,1,1); 00063 00064 // Periodogram: fp:=|fp|**2 00065 for (int iz = 1; iz <= nz; iz++) { 00066 for (int iy = 1; iy <= ny; iy++) { 00067 for (int ix = 1; ix <= lsd2; ix++) { 00068 float fpr = real(fp->cmplx(ix,iy,iz)); 00069 float fpi = imag(fp->cmplx(ix,iy,iz)); 00070 fp->cmplx(ix,iy,iz) = fpr*fpr + fpi*fpi; 00071 } 00072 } 00073 } 00074 // Create power as a 3D array (-n/2:n/2+n%2-1) 00075 int nyt, nzt; 00076 int nx2 = nx/2; 00077 int ny2 = ny/2; if(ny2 == 0) nyt =0; else nyt=ny; 00078 int nz2 = nz/2; if(nz2 == 0) nzt =0; else nzt=nz; 00079 int nx2p = nx2+nx%2; 00080 int ny2p = ny2+ny%2; 00081 int nz2p = nz2+nz%2; 00082 EMData& power = *(new EMData()); // output image 00083 power.set_size(nx, ny, nz); 00084 power.set_array_offsets(-nx2,-ny2,-nz2); 00085 //If instead of preservation of the norm one would prefer to have peak of a PW of a single sine wave equal one 00086 // multiply power by the scale below, or the other way around. 00087 float scale = 4.0f/float (nx*nx)/float (ny*ny)/float (nz*nz); 00088 for (int iz = 1; iz <= nz; iz++) { 00089 int jz=iz-1; 00090 if(jz>=nz2p) jz=jz-nzt; 00091 for (int iy = 1; iy <= ny; iy++) { 00092 int jy=iy-1; 00093 if(jy>=ny2p) jy=jy-nyt; 00094 for (int ix = 1; ix <= lsd2; ix++) { 00095 int jx=ix-1; 00096 if(jx>=nx2p) jx=jx-nx; 00097 power(jx,jy,jz) = real(fp->cmplx(ix,iy,iz)) * scale; 00098 } 00099 } 00100 } 00101 00102 // Create the Friedel related half 00103 int nzb, nze, nyb, nye, nxb, nxe; 00104 nxb =-nx2+(nx+1)%2; 00105 nxe = nx2-(nx+1)%2; 00106 if(ny2 == 0) {nyb =0; nye = 0;} else {nyb =-ny2+(ny+1)%2; nye = ny2-(ny+1)%2;} 00107 if(nz2 == 0) {nzb =0; nze = 0;} else {nzb =-nz2+(nz+1)%2; nze = nz2-(nz+1)%2;} 00108 for (int iz = nzb; iz <= nze; iz++) { 00109 for (int iy = nyb; iy <= nye; iy++) { 00110 for (int ix = 1; ix <= nxe; ix++) { // Note this loop begins with 1 - FFT should create correct Friedel related 0 plane 00111 power(-ix,-iy,-iz) = power(ix,iy,iz); 00112 } 00113 } 00114 } 00115 if(ny2 != 0) { 00116 if(nz2 != 0) { 00117 if(nz%2 == 0) { //if nz even, fix the first slice 00118 for (int iy = nyb; iy <= nye; iy++) { 00119 for (int ix = nxb; ix <= -1; ix++) { 00120 power(ix,iy,-nz2) = power(-ix,-iy,-nz2); 00121 } 00122 } 00123 if(ny%2 == 0) { //if ny even, fix the first line 00124 for (int ix = nxb; ix <= -1; ix++) { 00125 power(ix,-ny2,-nz2) = power(-ix,-ny2,-nz2); 00126 } 00127 } 00128 } 00129 } 00130 if(ny%2 == 0) { //if ny even, fix the first column 00131 for (int iz = nzb; iz <= nze; iz++) { 00132 for (int ix = nxb; ix <= -1; ix++) { 00133 power(ix,-ny2,-iz) = power(-ix,-ny2,iz); 00134 } 00135 } 00136 } 00137 00138 } 00139 00140 if( fp ) { 00141 delete fp; // avoid a memory leak! 00142 fp = 0; 00143 } 00144 //power[0][0][0]=power[1][0][0]; //Steve requested the original origin. 00145 00146 int sz[3]; 00147 sz[0] = nx; 00148 sz[1] = ny; 00149 sz[2] = nz; 00150 int max_size = *std::max_element(&sz[0],&sz[3]); 00151 // set the pixel size for the power spectrum, only ration of the frequency pixel size is considered 00152 power.set_attr("apix_x", float(max_size)/nx); 00153 if(ny2 > 0) power.set_attr("apix_y", float(max_size)/ny); 00154 if(nz2 > 0) power.set_attr("apix_z", float(max_size)/nz); 00155 00156 power.update(); 00157 power.set_array_offsets(0,0,0); 00158 return &power; 00159 //OVER AND OUT 00160 }
|
|
Definition at line 3080 of file emdata.cpp. References operator/(). 03081 { 03082 return EMAN::operator/(n, em); 03083 }
|
|
Real-space convolution of two images.
Definition at line 249 of file rsconvolution.cpp. References EMAN::EMData::get_array_offsets(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, mult_circ(), mult_internal(), EMAN::EMData::set_array_offsets(), EMAN::EMData::set_size(), EMAN::EMData::to_zero(), and EMAN::EMData::update(). 00249 {//Does not work properly in 3D, corners are not done, PAP 07/16/09 00250 // Kernel should be the smaller image 00251 int nxf=f->get_xsize(); int nyf=f->get_ysize(); int nzf=f->get_zsize(); 00252 int nxK=K->get_xsize(); int nyK=K->get_ysize(); int nzK=K->get_zsize(); 00253 if ((nxf<nxK)&&(nyf<nyK)&&(nzf<nzK)) { 00254 // whoops, f smaller than K 00255 swap(f,K); swap(nxf,nxK); swap(nyf,nyK); swap(nzf,nzK); 00256 } else if ((nxK<=nxf)&&(nyK<=nyf)&&(nzK<=nzf)) { 00257 // that's what it should be, so do nothing 00258 ; 00259 } else { 00260 // incommensurate sizes 00261 throw ImageDimensionException("input images are incommensurate"); 00262 } 00263 // Kernel needs to be _odd_ in size 00264 if ((nxK % 2 != 1) || (nyK % 2 != 1) || (nzK % 2 != 1)) 00265 throw ImageDimensionException("Real-space convolution kernel" 00266 " must have odd nx,ny,nz (so the center is well-defined)."); 00267 EMData* result = new EMData(); 00268 result->set_size(nxf, nyf, nzf); 00269 result->to_zero(); 00270 // kernel corners, need to check for degenerate case 00271 int kxmin = -nxK/2; int kymin = -nyK/2; int kzmin = -nzK/2; 00272 int kxmax = (1 == nxK % 2) ? -kxmin : -kxmin - 1; 00273 int kymax = (1 == nyK % 2) ? -kymin : -kymin - 1; 00274 int kzmax = (1 == nzK % 2) ? -kzmin : -kzmin - 1; 00275 vector<int> K_saved_offsets = K->get_array_offsets(); 00276 K->set_array_offsets(kxmin,kymin,kzmin); 00277 // interior boundaries, need to check for degenerate cases 00278 int izmin = 0, izmax = 0, iymin = 0, iymax = 0, ixmin = 0, ixmax = 0; 00279 if (1 != nzf) { 00280 izmin = -kzmin; 00281 izmax = nzf - 1 - kzmax; 00282 } 00283 if (1 != nyf) { 00284 iymin = -kymin; 00285 iymax = nyf - 1 - kymax; 00286 } 00287 if (1 != nxf) { 00288 ixmin = -kxmin; 00289 ixmax = nxf - 1 - kxmax; 00290 } 00291 // interior (no boundary condition issues here) 00292 for (int iz = izmin; iz <= izmax; iz++) { 00293 for (int iy = iymin; iy <= iymax; iy++) { 00294 for (int ix = ixmin; ix <= ixmax; ix++) { 00295 (*result)(ix,iy,iz) = 00296 mult_internal(*K, *f, 00297 kzmin, kzmax, kymin, kymax, kxmin, kxmax, 00298 iz, iy, ix); 00299 } 00300 } 00301 } 00302 // corners 00303 // corner sizes, with checking for degenerate cases 00304 int sz = (1 == nzK) ? 1 : -kzmin + kzmax; 00305 int sy = (1 == nyK) ? 1 : -kymin + kymax; 00306 int sx = (1 == nxK) ? 1 : -kxmin + kxmax; 00307 // corner starting locations, with checking for degenerate cases 00308 int zstart = (0 == izmin) ? 0 : izmin - 1; 00309 int ystart = (0 == iymin) ? 0 : iymin - 1; 00310 int xstart = (0 == ixmin) ? 0 : ixmin - 1; 00311 // corners 00312 for (int cz = 0; cz < sz; cz++) { 00313 int iz = (zstart - cz) % nzf; 00314 if (iz < 0) iz += nzf; 00315 for (int cy = 0; cy < sy; cy++) { 00316 int iy = (ystart - cy) % nyf; 00317 if (iy < 0) iy += nyf; 00318 for (int cx=0; cx < sx; cx++) { 00319 int ix = (xstart - cx) % nxf; 00320 if (ix < 0) ix += nxf; 00321 (*result)(ix,iy,iz) = 00322 mult_circ(*K, *f, kzmin, kzmax, kymin, 00323 kymax, kxmin, kxmax, 00324 nzf, nyf, nxf, iz, iy, ix); 00325 } 00326 } 00327 } 00328 // remaining stripes -- should use a more elegant (non-3D-specific) method here 00329 // ix < ixmin 00330 for (int ix = 0; ix < ixmin; ix++) { 00331 for (int iy = iymin; iy <= iymax; iy++) { 00332 for (int iz = izmin; iz <= izmax; iz++) { 00333 (*result)(ix,iy,iz) = 00334 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00335 kxmin, kxmax, 00336 nzf, nyf, nxf, iz, iy, ix); 00337 } 00338 } 00339 } 00340 // ix > ixmax 00341 for (int ix = ixmax+1; ix < nxf; ix++) { 00342 for (int iy = iymin; iy <= iymax; iy++) { 00343 for (int iz = izmin; iz <= izmax; iz++) { 00344 (*result)(ix,iy,iz) = 00345 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00346 kxmin, kxmax, 00347 nzf, nyf, nxf, iz, iy, ix); 00348 } 00349 } 00350 } 00351 // iy < iymin 00352 for (int iy = 0; iy < iymin; iy++) { 00353 for (int ix = ixmin; ix <= ixmax; ix++) { 00354 for (int iz = izmin; iz <= izmax; iz++) { 00355 (*result)(ix,iy,iz) = 00356 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00357 kxmin, kxmax, 00358 nzf, nyf, nxf, iz, iy, ix); 00359 } 00360 } 00361 } 00362 // iy > iymax 00363 for (int iy = iymax+1; iy < nyf; iy++) { 00364 for (int ix = ixmin; ix <= ixmax; ix++) { 00365 for (int iz = izmin; iz <= izmax; iz++) { 00366 (*result)(ix,iy,iz) = 00367 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00368 kxmin, kxmax, 00369 nzf, nyf, nxf, iz, iy, ix); 00370 } 00371 } 00372 } 00373 // iz < izmin 00374 for (int iz = 0; iz < izmin; iz++) { 00375 for (int ix = ixmin; ix <= ixmax; ix++) { 00376 for (int iy = iymin; iy <= iymax; iy++) { 00377 (*result)(ix,iy,iz) = 00378 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00379 kxmin, kxmax, 00380 nzf, nyf, nxf, iz, iy, ix); 00381 } 00382 } 00383 } 00384 // iz > izmax 00385 for (int iz = izmax+1; iz < nzf; iz++) { 00386 for (int ix = ixmin; ix <= ixmax; ix++) { 00387 for (int iy = iymin; iy <= iymax; iy++) { 00388 (*result)(ix,iy,iz) = 00389 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00390 kxmin, kxmax, 00391 nzf, nyf, nxf, iz, iy, ix); 00392 } 00393 } 00394 } 00395 00396 00397 // ix < ixmin, iy < iymin 00398 for (int ix = 0; ix < ixmin; ix++) { 00399 for (int iy = 0; iy < iymin; iy++) { 00400 for (int iz = izmin; iz <= izmax; iz++) { 00401 (*result)(ix,iy,iz) = 00402 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00403 kxmin, kxmax, 00404 nzf, nyf, nxf, iz, iy, ix); 00405 } 00406 } 00407 } 00408 00409 // ix < ixmin, iy > iymax 00410 for (int ix = 0; ix < ixmin; ix++) { 00411 for (int iy = iymax+1; iy < nyf; iy++) { 00412 for (int iz = izmin; iz <= izmax; iz++) { 00413 (*result)(ix,iy,iz) = 00414 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00415 kxmin, kxmax, 00416 nzf, nyf, nxf, iz, iy, ix); 00417 } 00418 } 00419 } 00420 00421 // ix > ixmax, iy < iymin 00422 for (int ix = ixmax+1; ix < nxf; ix++) { 00423 for (int iy = 0; iy < iymin; iy++) { 00424 for (int iz = izmin; iz <= izmax; iz++) { 00425 (*result)(ix,iy,iz) = 00426 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00427 kxmin, kxmax, 00428 nzf, nyf, nxf, iz, iy, ix); 00429 } 00430 } 00431 } 00432 00433 // ix > ixmax, iy > iymax 00434 for (int ix = ixmax+1; ix < nxf; ix++) { 00435 for (int iy = iymax+1; iy < nyf; iy++) { 00436 for (int iz = izmin; iz <= izmax; iz++) { 00437 (*result)(ix,iy,iz) = 00438 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00439 kxmin, kxmax, 00440 nzf, nyf, nxf, iz, iy, ix); 00441 } 00442 } 00443 } 00444 00445 00446 00447 // ix < ixmin, iz < izmin 00448 for (int ix = 0; ix < ixmin; ix++) { 00449 for (int iy = iymin; iy <= iymax; iy++) { 00450 for (int iz = 0; iz < izmin; iz++) { 00451 (*result)(ix,iy,iz) = 00452 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00453 kxmin, kxmax, 00454 nzf, nyf, nxf, iz, iy, ix); 00455 } 00456 } 00457 } 00458 00459 // ix < ixmin, iz > izmax 00460 for (int ix = 0; ix < ixmin; ix++) { 00461 for (int iy = iymin; iy <= iymax; iy++) { 00462 for (int iz = izmax+1; iz < nzf; iz++) { 00463 (*result)(ix,iy,iz) = 00464 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00465 kxmin, kxmax, 00466 nzf, nyf, nxf, iz, iy, ix); 00467 } 00468 } 00469 } 00470 00471 00472 // ix > ixmin, iz < izmin 00473 for (int ix = ixmax+1; ix < nxf; ix++) { 00474 for (int iy = iymin; iy <= iymax; iy++) { 00475 for (int iz = 0; iz < izmin; iz++) { 00476 (*result)(ix,iy,iz) = 00477 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00478 kxmin, kxmax, 00479 nzf, nyf, nxf, iz, iy, ix); 00480 } 00481 } 00482 } 00483 00484 // ix > ixmin, iz > izmax 00485 for (int ix = ixmax+1; ix < nxf; ix++) { 00486 for (int iy = iymin; iy <= iymax; iy++) { 00487 for (int iz = izmax+1; iz < nzf; iz++) { 00488 (*result)(ix,iy,iz) = 00489 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00490 kxmin, kxmax, 00491 nzf, nyf, nxf, iz, iy, ix); 00492 } 00493 } 00494 } 00495 00496 00497 00498 // iy < iymin, iz < izmin 00499 00500 for (int iz = 0; iz < izmin; iz++) { 00501 for (int ix = ixmin; ix <= ixmax; ix++) { 00502 for (int iy = 0; iy < iymin; iy++) { 00503 (*result)(ix,iy,iz) = 00504 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00505 kxmin, kxmax, 00506 nzf, nyf, nxf, iz, iy, ix); 00507 } 00508 } 00509 } 00510 00511 00512 // iy < iymin, iz > izmax 00513 00514 for (int iz = izmax+1; iz < nzf; iz++) { 00515 for (int ix = ixmin; ix <= ixmax; ix++) { 00516 for (int iy = 0; iy < iymin; iy++) { 00517 (*result)(ix,iy,iz) = 00518 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00519 kxmin, kxmax, 00520 nzf, nyf, nxf, iz, iy, ix); 00521 } 00522 } 00523 } 00524 00525 00526 // iy > iymax, iz < izmin 00527 00528 for (int iz = 0; iz < izmin; iz++) { 00529 for (int ix = ixmin; ix <= ixmax; ix++) { 00530 for (int iy = iymax+1; iy < nyf; iy++) { 00531 (*result)(ix,iy,iz) = 00532 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00533 kxmin, kxmax, 00534 nzf, nyf, nxf, iz, iy, ix); 00535 } 00536 } 00537 } 00538 00539 00540 // iy > iymax, iz > izmax 00541 00542 for (int iz = izmax+1; iz < nzf; iz++) { 00543 for (int ix = ixmin; ix <= ixmax; ix++) { 00544 for (int iy = iymax+1; iy < nyf; iy++) { 00545 (*result)(ix,iy,iz) = 00546 mult_circ(*K, *f, kzmin, kzmax, kymin, kymax, 00547 kxmin, kxmax, 00548 nzf, nyf, nxf, iz, iy, ix); 00549 } 00550 } 00551 } 00552 00553 00554 K->set_array_offsets(K_saved_offsets); 00555 result->update(); 00556 return result; 00557 }
|
|
Real-space convolution with the K-B window.
|
|
Definition at line 3075 of file emdata.cpp. References operator-(). Referenced by main(). 03076 { 03077 return EMAN::operator-(n, em); 03078 }
|
|
Image self-correlation.
Definition at line 206 of file fundamentals.h. References fourierproduct(), and SELF_CORRELATION. 00206 { 00207 return fourierproduct(f, NULL, myflag, SELF_CORRELATION, center); 00208 }
|
|
Definition at line 689 of file vecmath.h. References EMAN::Vector4::length(), and v.
|
|
Definition at line 318 of file vecmath.h. References EMAN::Vector3::length(), and v.
|
|
Definition at line 49 of file polardata.h. |