Classes | |
class | Aligner |
Aligner class defines image alignment method. More... | |
class | TranslationalAligner |
Translational 2D Alignment using cross correlation. More... | |
class | RotationalAligner |
rotational alignment using angular correlation More... | |
class | RotatePrecenterAligner |
rotational alignment assuming centers are correct More... | |
class | RotateTranslateAligner |
rotational, translational alignment More... | |
class | RotateTranslateBestAligner |
rotational, translational alignment More... | |
class | RotateFlipAligner |
rotational and flip alignment More... | |
class | RotateTranslateFlipAligner |
rotational, translational and flip alignment More... | |
class | RTFExhaustiveAligner |
rotational, translational and flip alignment using real-space methods. More... | |
class | RTFSlowExhaustiveAligner |
rotational, translational and flip alignment using exhaustive search. More... | |
class | RefineAligner |
refine alignment. More... | |
class | Refine3DAligner |
Refine alignment. More... | |
class | 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), but very useful if you want to search in a specific, small, local area. More... | |
class | RT3DSphereAligner |
3D rotational and translational alignment using spherical sampling, can reduce the search space based on symmetry. More... | |
class | CUDA_Aligner |
class | AmiraIO |
Amira file = ASCII header + binary data. More... | |
class | Analyzer |
Analyzer class defines a way to take a List of images as input, and returns a new List of images. More... | |
class | 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 | SVDAnalyzer |
Singular Value Decomposition from GSL. More... | |
class | Averager |
Averager class defines a way to do averaging on a set of images. More... | |
class | ImageAverager |
ImageAverager averages a list of images. More... | |
class | MinMaxAverager |
ImageAverager averages a list of images. More... | |
class | IterationAverager |
IterationAverager averages images by doing the smoothing iteration. More... | |
class | CtfAverager |
CtfAverager is the base Averager class for CTF correction or SNR weighting. More... | |
class | WeightingAverager |
WeightingAverager averages the images with SNR weighting, but no CTF correction. More... | |
class | CtfCAverager |
CtfCAverager averages the images with CTF correction. More... | |
class | CtfCWAverager |
CtfCWAverager averages the images with CTF correction. More... | |
class | CtfCWautoAverager |
CtfCWautoAverager averages the images with CTF correction with a Wiener filter. More... | |
class | BoxingTools |
BoxingTools is class for encapsulating common boxing operations that may become expensive if they are implemented in python. More... | |
class | BoxSVDClassifier |
class | ByteOrder |
ByteOrder defines functions to work on big/little endian byte orders. More... | |
class | Cmp |
Cmp class defines image comparison method. More... | |
class | CccCmp |
Compute the cross-correlation coefficient between two images. More... | |
class | SqEuclideanCmp |
Squared Euclidean distance normalized by n between 'this' and 'with'. More... | |
class | DotCmp |
Use dot product of 2 same-size images to do the comparison. More... | |
class | TomoDotCmp |
Use dot product but normalize based on characteristics of the missing wedge. More... | |
class | QuadMinDotCmp |
This will calculate the dot product for each quadrant of the image and return the worst value. More... | |
class | OptVarianceCmp |
Variance between two data sets after various modifications. More... | |
class | PhaseCmp |
Amplitude weighted mean phase difference (radians) with optional SNR weight. More... | |
class | FRCCmp |
FRCCmp returns a quality factor based on FRC between images. More... | |
class | Ctf |
Ctf is the base class for all CTF model. More... | |
class | EMAN1Ctf |
EMAN1Ctf is the CTF model used in EMAN1. More... | |
class | EMAN2Ctf |
EMAN2Ctf is the default CTF model used in EMAN2. More... | |
class | DM3IO |
Gatan DM3 file is a hierarchical binary image format. More... | |
class | EMCache |
EMCache is a generic cache that can cache anything defined by 'T'. More... | |
class | GlobalCache |
GlobalCache is a Singleton class that handles cache across EMAN. More... | |
class | EMData |
EMData stores an image's data and defines core image processing routines. More... | |
class | EMFTGL |
EMFTGL is an interface for rendering fonts in EMAN2 using FTGL. More... | |
class | EmimIO |
EMIM image format = 1 EmimFileHeader + n x (EmimImageHeader + data). More... | |
class | EmIO |
EmIO defines I/O operations on EM image format. More... | |
class | EMConsts |
class | EMObject |
EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType. More... | |
class | TypeDict |
TypeDict is a dictionary to store <string, EMObject::ObjectType> pair. More... | |
class | Dict |
Dict is a dictionary to store <string, EMObject> pair. More... | |
class | Factory |
Factory is used to store objects to create new instances. More... | |
class | FactoryBase |
A class one may inherit from to ensure that the responsibilities of being incorporated into an EMAN2::Factory are met. More... | |
class | EMUtil |
struct | ImageScore |
class | ImageSort |
class | E2Exception |
E2Exception class is the parent class of all EMAN2 E2Exceptions. More... | |
class | _NotExistingObjectException |
Used when an object type, like an EMObject type, doesn't exist. More... | |
class | _ImageFormatException |
Used when an image is not in the expected format. More... | |
class | _ImageDimensionException |
Used when an image is not in the expected dimension. More... | |
class | _FileAccessException |
Used when a file access error occurs. More... | |
class | _ImageReadException |
Used when an error occurs at image reading time. More... | |
class | _ImageWriteException |
Used when an error occurs at image writing time. More... | |
class | _NullPointerException |
Used when a NULL is given to a pointer that should not be NULL. More... | |
class | _TypeException |
Used when a type cast error occurs. More... | |
class | _InvalidValueException |
Used when an invalid integer value is given. More... | |
class | _InvalidStringException |
Used when an invalid (format) string is given. More... | |
class | _OutofRangeException |
Used when the given value is out of range. More... | |
class | _InvalidCallException |
class | _InvalidParameterException |
class | _EmptyContainerException |
Used when an argument container is empty, such as a vector. More... | |
class | _BadAllocException |
Used when memory allocation goes wrong. More... | |
class | _UnexpectedBehaviorException |
Used when internal behavior is unexpected A generic kind of exception. More... | |
class | FitsIO |
MRC file = header + data (nx x ny x nz). More... | |
class | Gatan2IO |
Gatan2 Image file = header + data. More... | |
class | IntSize |
IntSize is used to describe a 1D, 2D or 3D rectangular size in integers. More... | |
class | FloatSize |
FloatSize is used to describe a 1D, 2D or 3D rectangular size in floating numbers. More... | |
class | IntPoint |
IntPoint defines an integer-coordinate point in a 1D/2D/3D space. More... | |
class | FloatPoint |
FloatPoint defines a float-coordinate point in a 1D/2D/3D space. More... | |
class | Pixel |
Pixel describes a 3D pixel's coordinates and its intensity value. More... | |
class | Region |
Region defines a 2D or 3D rectangular region specified by its origin coordinates and all edges' sizes. More... | |
class | GLUtil |
class | PriorityQueue |
Template class for a priority queue. More... | |
class | IcosIO |
ICOS file = header + data. More... | |
class | ImageIO |
ImageIO classes are designed for reading/writing various electron micrography image formats, including MRC, IMAGIC, SPIDER, PIF, etc. More... | |
class | ImagicIO |
IMAGIC-5 Header File Format. More... | |
class | ImagicIO2 |
IMAGIC-5 Header File Format. More... | |
class | Interp |
Interp defines the interpolation function used to generate a e^-x^4 function in real space. More... | |
class | Isosurface |
class | Log |
Log defines a way to output logging information. More... | |
class | LstFastIO |
A LSX file is a high performance ASCII file that contains a list of image numbers and file names. More... | |
class | LstIO |
A LST file is an ASCII file that contains a list of image file names. More... | |
class | CustomVector |
CustomVector has some trivial optimizations of the STL vector. More... | |
class | MarchingCubes |
class | U3DWriter |
A work in progress by David Woolford. More... | |
class | MrcIO |
MRC file = header + data (nx x ny x nz). More... | |
class | PDBReader |
PointArray defines a double array of points with values in a 3D space. More... | |
class | PgmIO |
A PGM file = header + data. More... | |
class | PifIO |
PIF(Portable Image Format for EM Data) is an image format from Purdue University. More... | |
class | XYZAligner |
XYZAligner is an aligner template for defining new aligners. More... | |
class | XYZAverager |
XYZAverager is an averager template for defining new averagers. More... | |
class | XYZCmp |
XYZCmp is a cmp template for defining new cmps. More... | |
class | XYZIO |
XYZIO is a sample Image IO class. More... | |
class | XYZProcessor |
XYZProcessor is a processor template for defining new processors. More... | |
class | XYZProjector |
XYZProjector is an projector template for defining new projectors. More... | |
class | XYZReconstructor |
XYZReconstructor is a reconstructor template for defining new reconstructors. More... | |
class | PointArray |
PointArray defines a double array of points with values in a 3D space. More... | |
class | UnevenMatrix |
a general data structure for a matrix with variable x dim size for different y More... | |
class | PolarData |
a specialized image class for storing the results of a transform from EMData to polar coordinates, currently support 2D only. More... | |
class | Processor |
Typical usage of Processors are as follows:. More... | |
class | ImageProcessor |
class | FourierProcessor |
base class for Fourier filters More... | |
class | 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 | SNREvalProcessor |
Evaluate individual particle images using a tenchique similar to that used for CTF evaluation. More... | |
class | AmpweightFourierProcessor |
Multiplies each Fourier pixel by its amplitude. More... | |
class | ConvolutionProcessor |
This processor performs fast convolution in Fourier space. More... | |
class | 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 | YGradientProcessor |
class | ZGradientProcessor |
class | 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 | KmeansSegmentProcessor |
class | Wiener2DFourierProcessor |
Wiener filter based on a Ctf object either in the image header. More... | |
class | LowpassFourierProcessor |
Low-pass processor attenuates amplitudes at high spatial frequencies. More... | |
class | LinearRampFourierProcessor |
class | HighpassFourierProcessor |
High-pass processor is rotationally symmetric 2D function. More... | |
class | LowpassSharpCutoffProcessor |
processor radial function: if x <= lowpass, f(x) = 1; else f(x) = 0; More... | |
class | HighpassSharpCutoffProcessor |
processor radial function: if x >= highpass, f(x) = 1; else f(x) = 0; More... | |
class | LowpassGaussProcessor |
processor radial function: if lowpass > 0, f(x) = exp(-x*x/(lowpass*lowpass)); else f(x) = exp(x*x/(lowpass*lowpass)) More... | |
class | LowpassAutoBProcessor |
processor radial function: if lowpass > 0, f(x) = exp(-x*x/(lowpass*lowpass)); else f(x) = exp(x*x/(lowpass*lowpass)) More... | |
class | HighpassAutoPeakProcessor |
This processor attempts to remove the low resolution peak present in all cryoEM data. More... | |
class | HighpassGaussProcessor |
processor radial function: f(x) = 1.0-exp(-x*x/(highpass*highpass)) More... | |
class | LowpassTanhProcessor |
processor radial function: f(x)=tanh(lowpass-x)/2.0 + 0.5; More... | |
class | HighpassTanhProcessor |
processor radial function: f(x)=tanh(x-highpass)/2.0+0.5; More... | |
class | HighpassButterworthProcessor |
processor radial function: f(x) = 1/(1+t*t) More... | |
class | LinearRampProcessor |
processor radial function: f(x) = slope * x + intercept More... | |
class | RealPixelProcessor |
The base class for real space processor working on individual pixels. More... | |
class | AbsoluateValueProcessor |
f(x) = |x| More... | |
class | BooleanProcessor |
f(x) = 0 if x = 0; f(x) = 1 if x != 0 More... | |
class | InvertCarefullyProcessor |
Invert image as if f(x) != 0: f(x) = 1/f(x) else: f(x) = zero_to. More... | |
class | ValuePowProcessor |
Do a math power operation on image, f(x) = x ^ pow;. More... | |
class | ValueSquaredProcessor |
Do a square operation on image, f(x) = x * x;. More... | |
class | ValueSqrtProcessor |
f(x) = sqrt(x) More... | |
class | ToZeroProcessor |
f(x) = x if x >= minval; f(x) = 0 if x < minval More... | |
class | Rotate180Processor |
Rotate by 180 using pixel swapping, works for 2D only. More... | |
class | TransformProcessor |
Transform the image using a Transform object. More... | |
class | 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 | ScaleTransformProcessor |
Scale the image with control over the output dimensions. More... | |
class | ClampingProcessor |
f(x) = maxval if f(x) > maxval; f(x) = minval if f(x) < minval More... | |
class | 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 | ToMinvalProcessor |
f(x) = x if x >= minval; f(x) = minval if x < minval More... | |
class | CutToZeroProcessor |
f(x) = x-minval if x >= minval; f(x) = 0 if x < minval More... | |
class | BinarizeProcessor |
f(x) = 0 if x < value; f(x) = 1 if x >= value. More... | |
class | BinarizeFourierProcessor |
A thresholding processor for Fourier images based on the amplitude component. More... | |
class | CollapseProcessor |
f(x): if v-r<x<v+r -> v; if x>v+r -> x-r; if x<v-r -> x+r More... | |
class | LinearXformProcessor |
linear transform processor: f(x) = x * scale + shift More... | |
class | ExpProcessor |
f(x) = exp( x / low - high) More... | |
class | FiniteProcessor |
f(x) = f(x) if f(x) is finite | to if f(x) is not finite More... | |
class | RangeThresholdProcessor |
f(x) = 1 if (low <= x <= high); else f(x) = 0 More... | |
class | SigmaProcessor |
f(x) = mean if x<(mean-v2*sigma) or x>(mean+v1*sigma); else f(x) = x; More... | |
class | LogProcessor |
f(x) = log10(x) if x > 0; else f(x) = 0 More... | |
class | CoordinateProcessor |
CoordinateProcessor applies processing based on a pixel's value and it coordinates. More... | |
class | 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 | MaskSharpProcessor |
step cutoff to a user-given value in both inner and outer circles. More... | |
class | MaskEdgeMeanProcessor |
A step cutoff to the the mean value in a ring centered on the outer radius. More... | |
class | MaskNoiseProcessor |
fills masked region More... | |
class | MaskGaussProcessor |
a gaussian falloff to zero, radius is the 1/e of the width. More... | |
class | MaskGaussNonuniformProcessor |
a gaussian falloff to zero, with nonisotropic widths along x,y,z More... | |
class | MaskGaussInvProcessor |
f(x) = f(x) / exp(-radius*radius * gauss_width / (ny*ny)) More... | |
class | 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 | MakeRadiusSquaredProcessor |
overwrites input, f(x) = radius * radius More... | |
class | MakeRadiusProcessor |
overwrites input, f(x) = radius More... | |
class | ComplexPixelProcessor |
The base class for fourier space processor working on individual pixels. More... | |
class | ComplexNormPixel |
Each Fourier pixel will be normalized. More... | |
class | AreaProcessor |
AreaProcessor use pixel values and coordinates of a real-space square area. More... | |
class | LaplacianProcessor |
Discrete approximation to Laplacian. More... | |
class | ZeroConstantProcessor |
Contraction of data, if any nearest neighbor is 0, value -> 0, generally used iteratively. More... | |
class | BoxStatProcessor |
BoxStatProcessor files are a kind of neighborhood processors. More... | |
class | BoxMedianProcessor |
A processor for noise reduction. More... | |
class | BoxSigmaProcessor |
pixel = standard deviation of values surrounding pixel. More... | |
class | BoxMaxProcessor |
peak processor: pixel = max of values surrounding pixel. More... | |
class | MinusPeakProcessor |
peak processor: pixel = pixel - max of values surrounding pixel. More... | |
class | PeakOnlyProcessor |
peak processor -> if npeaks or more surrounding values >= value, value->0 More... | |
class | DiffBlockProcessor |
averages over cal_half_width, then sets the value in a local block More... | |
class | CutoffBlockProcessor |
Block processor, val1 is dx/dy, val2 is lp freq cutoff in pixels. More... | |
class | 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 | 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... | |
class | 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... | |
class | MeanShrinkProcessor |
MeanShrinkProcessor shrinks an image by in an integer amount (and optionally by 1.5) taking the mean of the pixel neighbourhood. More... | |
class | MedianShrinkProcessor |
MeanShrinkProcessor shrinks an image by in an integer amount taking the median of the pixel neighbourhood. More... | |
class | 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 | GradientRemoverProcessor |
Gradient remover, does a rough plane fit to find linear gradients. More... | |
class | GradientPlaneRemoverProcessor |
Gradient removed by least square plane fit. More... | |
class | FlattenBackgroundProcessor |
Flattens the background by subtracting the local mean. More... | |
class | RampProcessor |
Ramp processor -- Fits a least-squares plane to the picture, and subtracts the plane from the picture. More... | |
class | VerticalStripeProcessor |
Tries to fix images scanned on the zeiss for poor ccd normalization. More... | |
class | RealToFFTProcessor |
This will replace the image with a full-circle 2D fft amplitude rendering. More... | |
class | SigmaZeroEdgeProcessor |
Fill zeroes at edges with nearest horizontal/vertical value. More... | |
class | BeamstopProcessor |
Try to eliminate beamstop in electron diffraction patterns. More... | |
class | MeanZeroEdgeProcessor |
Fill zeroes at edges with nearest horizontal/vertical value damped towards Mean2. More... | |
class | AverageXProcessor |
Average along Y and replace with average. More... | |
class | DecayEdgeProcessor |
Decay edges of image to zero. More... | |
class | ZeroEdgeRowProcessor |
zero edges of image on top and bottom, and on left and right. More... | |
class | ZeroEdgePlaneProcessor |
zero edges of volume on all sides More... | |
class | BilateralProcessor |
Bilateral processing on 2D or 3D volume data. More... | |
class | NormalizeProcessor |
Base class for normalization processors. More... | |
class | NormalizeUnitProcessor |
Normalize an image so its vector length is 1.0. More... | |
class | NormalizeUnitSumProcessor |
Normalize an image so its elements sum to 1.0 (fails if mean=0). More... | |
class | NormalizeStdProcessor |
do a standard normalization on an image. More... | |
class | 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 | NormalizeRampNormVar |
Normalize the image whilst also removing any ramps. More... | |
class | NormalizeByMassProcessor |
Normalize the mass of the image assuming a density of 1.35 g/ml (0.81 Da/A^3). More... | |
class | NormalizeEdgeMeanProcessor |
normalizes an image, mean value equals to edge mean. More... | |
class | NormalizeCircleMeanProcessor |
normalizes an image, mean value equals to mean of 2 pixel circular border. More... | |
class | NormalizeLREdgeMeanProcessor |
normalizes an image, uses 2 pixels on left and right edge More... | |
class | NormalizeMaxMinProcessor |
normalizes an image. More... | |
class | NormalizeRowProcessor |
normalizes each row in the image individually More... | |
class | NormalizeToLeastSquareProcessor |
use least square method to normalize More... | |
class | RotationalAverageProcessor |
makes image circularly symmetric. More... | |
class | RotationalSubstractProcessor |
subtracts circularly symmetric part of an image. More... | |
class | TransposeProcessor |
Transpose a 2D image. More... | |
class | FlipProcessor |
flip an image around an axis More... | |
class | AddNoiseProcessor |
add noise to an image More... | |
class | AddSigmaNoiseProcessor |
add sigma noise, multiply image's sigma value to noise More... | |
class | AddRandomNoiseProcessor |
add spectral noise to a complex image More... | |
class | FourierToCornerProcessor |
Undo the effects of the FourierToCenterProcessor. More... | |
class | 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 | Phase180Processor |
This class is abstract. More... | |
class | PhaseToCenterProcessor |
Translates a cornered image to the center Undoes the PhaseToCornerProcessor. More... | |
class | PhaseToCornerProcessor |
Translates a centered image to the corner works for 1D, 2D and 3D images, for all combinations of even and oddness. More... | |
class | AutoMask2DProcessor |
Attempts to automatically mask out the particle, excluding other particles in the box, etc. More... | |
class | AutoMaskAsymUnit |
Tries to mask out only interesting density. More... | |
class | AutoMask3DProcessor |
Tries to mask out only interesting density. More... | |
class | AutoMask3D2Processor |
Tries to mask out only interesting density. More... | |
class | AddMaskShellProcessor |
Add additional shells/rings to an existing 1/0 mask image. More... | |
class | PhaseToMassCenterProcessor |
ToMassCenterProcessor centers image at center of mass, ignores old dx, dy. More... | |
class | ToMassCenterProcessor |
ToMassCenterProcessor centers image at center of mass, ignores old dx, dy. More... | |
class | ACFCenterProcessor |
Center image using auto convolution with 180 degree rotation. More... | |
class | 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 | FileFourierProcessor |
A fourier processor specified in a 2 column text file. More... | |
class | SymSearchProcessor |
Identifiy the best symmetry in the given symmetry list for each pixel and then apply the best symmetry to each pixel. More... | |
class | 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 | IndexMaskFileProcessor |
Multiplies the image by the specified file using pixel indices. More... | |
class | CoordinateMaskFileProcessor |
Multiplies the image by the specified file using pixel coordinates instead of pixel indices. More... | |
class | 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 | 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 | 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 | BinaryOperateProcessor |
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 | MaxPixelOperator |
class | MinPixelOperator |
class | MatchSFProcessor |
Sets the structure factor To match a second provided image/volume. More... | |
class | SetSFProcessor |
Sets the structure factor based on a 1D s/intensity curve as an XYData object. More... | |
class | SmartMaskProcessor |
Smart mask processor. More... | |
class | 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 | TestImageProcessor |
Base class for a group of 'processor' used to create test image. More... | |
class | TestImagePureGaussian |
Replace a source image as a strict Gaussian. More... | |
class | TestImageFourierNoiseGaussian |
Replace a source image as a strict Gaussian. More... | |
class | TestImageFourierNoiseProfile |
class | CTFSNRWeightProcessor |
class | 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 | 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 | 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. More... | |
class | TestImageAxes |
Make an image consisting of a single cross, with lines going in the axial directions, intersecting at the origin. More... | |
class | TestImageGaussian |
Replace a source image as a Gaussian Blob. More... | |
class | TestImageScurve |
Replace a source image with a lumpy S-curve used for alignment testing. More... | |
class | TestImageSphericalWave |
Replace a source image as a sine wave in specified wave length. More... | |
class | TestImageSinewave |
Replace a source image as a sine wave in specified wave length. More... | |
class | TestImageSinewaveCircular |
Replace a source image as a circular sine wave in specified wave length. More... | |
class | TestImageSquarecube |
Replace a source image as a square or cube depends on 2D or 3D of the source image. More... | |
class | TestImageEllipse |
Generate an ellipse or ellipsoid image. More... | |
class | TestImageHollowEllipse |
Generate an ellipse/ellipsoid image with an inner hollow ellipse/ellipsoid. More... | |
class | TestImageCirclesphere |
Replace a source image as a circle or sphere depends on 2D or 3D of the source image. More... | |
class | 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 | 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 | TestImageCylinder |
Replace a source image with a cylinder. More... | |
class | CCDNormProcessor |
Try to normalize the 4 quadrants of a CCD image. More... | |
class | WaveletProcessor |
Perform a Wavelet transform using GSL. More... | |
class | TomoTiltEdgeMaskProcessor |
A processor designed specifically for tomographic tilt series data. More... | |
class | 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 | FFTProcessor |
Perform a FFT transform by calling EMData::do_fft() and EMData::do_ift(). More... | |
class | RadialProcessor |
Perform a multiplication of real image with a radial table. More... | |
class | HistogramBin |
Bins pixel values, similar to calculating a histogram. More... | |
class | ModelHelixProcessor |
class | ModelEMCylinderProcessor |
class | ApplyPolynomialProfileToHelix |
class | BinarySkeletonizerProcessor |
class | Projector |
Projector class defines a method to generate 2D projections from a 3D model. More... | |
class | GaussFFTProjector |
Gaussian FFT 3D projection. More... | |
class | FourierGriddingProjector |
Fourier gridding projection routine. More... | |
class | PawelProjector |
Pawel Penczek's optimized projection routine. More... | |
class | StandardProjector |
Fast real-space 3D projection. More... | |
class | ChaoProjector |
Fast real space projection using Bi-Linear interpolation. More... | |
class | Quaternion |
Quaternion is used in Rotation and Transformation to replace Euler angles. More... | |
class | Randnum |
The wrapper class for gsl's random number generater. More... | |
class | Reconstructor |
Reconstructor class defines a way to do 3D recontruction. More... | |
class | 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 | FourierReconstructorSimple2D |
This class originally added for 2D experimentation and prototying. More... | |
class | 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 | WienerFourierReconstructor |
Fourier space 3D reconstruction with slices already Wiener filter processed. More... | |
class | BackProjectionReconstructor |
Real space 3D reconstruction using back projection. More... | |
class | nn4Reconstructor |
class | nnSSNR_Reconstructor |
class | nn4_ctfReconstructor |
nn4_ctf Direct Fourier Inversion Reconstructor More... | |
class | nnSSNR_ctfReconstructor |
struct | point_t |
class | newfile_store |
class | file_store |
class | 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 | FourierInserter3DMode1 |
FourierPixelInserter3DMode1 - encapsulates "method 1" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | FourierInserter3DMode2 |
FourierPixelInserter3DMode2 - encapsulates "method 2" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | FourierInserter3DMode3 |
FourierPixelInserter3DMode3 - encapsulates "method 3" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | FourierInserter3DMode5 |
FourierPixelInserter3DMode5 - encapsulates "method 5" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | FourierInserter3DMode6 |
FourierPixelInserter3DMode6 - encapsulates "method 6" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | FourierInserter3DMode7 |
FourierPixelInserter3DMode7 - encapsulates "method 7" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | FourierInserter3DMode8 |
FourierPixelInserter3DMode8 - encapsulates "method 8" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations. More... | |
class | SalIO |
A SAL image is an image from Perkin Elmer PDS Microdensitometer. More... | |
class | PCAsmall |
Principal component analysis. More... | |
class | PCAlarge |
class | varimax |
class | EMArray |
EMArray -- 1-, 2-, or 3-D array of types T. More... | |
class | PCA |
class | MirrorProcessor |
mirror an image More... | |
class | NewFourierProcessor |
class | NewLowpassTopHatProcessor |
Lowpass top-hat filter processor applied in Fourier space. More... | |
class | NewHighpassTopHatProcessor |
Highpass top-hat filter applied in Fourier space. More... | |
class | NewBandpassTopHatProcessor |
Bandpass top-hat filter processor applied in Fourier space. More... | |
class | NewHomomorphicTopHatProcessor |
Homomorphic top-hat filter processor applied in Fourier space. More... | |
class | NewLowpassGaussProcessor |
Lowpass Gauss filter processor applied in Fourier space. More... | |
class | NewHighpassGaussProcessor |
Highpass Gauss filter processor applied in Fourier space. More... | |
class | NewBandpassGaussProcessor |
Bandpass Gauss filter processor applied in Fourier space. More... | |
class | NewHomomorphicGaussProcessor |
Homomorphic Gauss filter processor applied in Fourier space. More... | |
class | NewInverseGaussProcessor |
Divide by a Gaussian in Fourier space. More... | |
class | SHIFTProcessor |
Shift by phase multiplication in Fourier space. More... | |
class | InverseKaiserI0Processor |
Divide by a Kaiser-Bessel I0 func in Fourier space. More... | |
class | InverseKaiserSinhProcessor |
Divide by a Kaiser-Bessel Sinh func in Fourier space. More... | |
class | NewRadialTableProcessor |
Filter with tabulated data in Fourier space. More... | |
class | NewLowpassButterworthProcessor |
Lowpass Butterworth filter processor applied in Fourier space. More... | |
class | NewHighpassButterworthProcessor |
Highpass Butterworth filter processor applied in Fourier space. More... | |
class | NewHomomorphicButterworthProcessor |
Homomorphic Butterworth filter processor applied in Fourier space. More... | |
class | NewLowpassTanhProcessor |
Lowpass tanh filter processor applied in Fourier space. More... | |
class | NewHighpassTanhProcessor |
Highpass tanh filter processor applied in Fourier space. More... | |
class | NewHomomorphicTanhProcessor |
Homomorphic Tanh processor applied in Fourier space. More... | |
class | NewBandpassTanhProcessor |
Bandpass tanh processor applied in Fourier space. More... | |
class | CTF_Processor |
class | SpiderIO |
SPIDER: (System for Processing Image Data from Electron microscopy and Related fields) is an image processing system for electron microscopy. More... | |
class | SingleSpiderIO |
Single Spider Image I/O class. More... | |
class | Symmetry3D |
Symmetry3D - A base class for 3D Symmetry objects. More... | |
class | CSym |
An encapsulation of cyclic 3D symmetry. More... | |
class | DSym |
An encapsulation of dihedral 3D symmetry. More... | |
class | HSym |
An encapsulation of helical 3D symmetry. More... | |
class | PlatonicSym |
A base (or parent) class for the Platonic symmetries. More... | |
class | TetrahedralSym |
An encapsulation of tetrahedral symmetry Doctor Phil has this to say about tetrahedral symmetry: " Each Platonic Solid has 2E symmetry elements. More... | |
class | 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 | IcosahedralSym |
An encapsulation of icosahedral symmetry Doctor Phil has this to say about icosahedral symmetry: "Each Platonic Solid has 2E symmetry elements. More... | |
class | 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 | EmanOrientationGenerator |
EmanOrientationGenerator generates orientations quasi-evenly distributed in the asymmetric unit. More... | |
class | RandomOrientationGenerator |
Random Orientation Generator - carefully generates uniformly random orientations in any asymmetric unit. More... | |
class | EvenOrientationGenerator |
Sparx even orientation generator - see util_sparx.cpp - Util::even_angles(. More... | |
class | SaffOrientationGenerator |
Saff orientation generator - based on the work of Saff and Kuijlaars, 1997 E.B. More... | |
class | OptimumOrientationGenerator |
Optimum orientation generator. More... | |
class | TestUtil |
class | Transform |
A Transform object is a somewhat specialized object designed specifically for EMAN2/Sparx storage of alignment parameters and euler orientations. More... | |
class | Transform3D |
Transform3D These are a collection of transformation tools: rotation, translation, and construction of symmetric objects. More... | |
class | Util |
Util is a collection of utility functions. More... | |
class | V4L2IO |
Read-only. More... | |
class | Vec3 |
The Vec3 object is a templated object, intended to instantiated with basic types such as int, float, double etc. More... | |
class | Vec2 |
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 | ScreenVector |
class | ScreenPoint |
class | Vector3 |
class | Point3 |
class | Matrix3 |
class | Vector4 |
class | Matrix4 |
class | VtkIO |
VtkIO reads/writes VTK image file. More... | |
class | XplorIO |
XPLOR image format is in ASCII:. More... | |
class | XYData |
XYData defines a 1D (x,y) data set. More... | |
Namespaces | |
namespace | Gatan |
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 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) |
Image periodogram. | |
EMData * | fourierproduct (EMData *f, EMData *g, fp_flag myflag, fp_type mytype, 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. | |
Transform3D | operator * (const Transform3D &M2, const Transform3D &M1) |
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> | |
Vec3f | operator * (const Vec3< Type > &v, const Transform3D &M) |
template<typename Type> | |
Vec3f | operator * (const Transform3D &M, const Vec3< Type > &v) |
template<typename Type> | |
Vec2f | operator * (const Transform3D &M, const Vec2< Type > &v) |
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 | |
static const int | MAXFFT = 32768 |
E2Exception class is a subclass of std::exception; All EMAN2 exception classes are subclass of E2Exception class.
A XYZ Exception class is defined in the following way: 0) It will extend E2Exception class. 1) The class is named _XYZException. 2) The class has a function to return its name "XYZException". 3) A macro called "XYZException" is defined to simplify the usage of _XYZException class. So that filename, function name, and line number can be handled automatically.
How to use XYZException:
1) To throw exception, use "throw XYZException(...)"; 2) To catch exception, use "catch (_XYZException & e) ...".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 71 of file fundamentals.h. 00071 { 00072 CIRCULANT = 1, 00073 CIRCULANT_NORMALIZED = 2, 00074 PADDED = 3, 00075 PADDED_NORMALIZED = 4, 00076 PADDED_LAG = 5, 00077 PADDED_NORMALIZED_LAG = 6 00078 };
|
|
Definition at line 81 of file fundamentals.h. 00081 { 00082 CORRELATION, 00083 CONVOLUTION, 00084 SELF_CORRELATION, 00085 AUTOCORRELATION 00086 };
|
|
Definition at line 232 of file fundamentals.h.
|
|
Definition at line 94 of file emobject.h. 00094 { 00095 NORMAL, 00096 ICOS2F_FIRST_OCTANT, 00097 ICOS2F_FULL, 00098 ICOS2F_HALF, 00099 ICOS3F_HALF, 00100 ICOS3F_FULL, 00101 ICOS5F_HALF, 00102 ICOS5F_FULL, 00103 ICOS_UNKNOWN 00104 };
|
|
Median filter.
Definition at line 259 of file fundamentals.h.
|
|
Image autocorrelation.
Definition at line 192 of file fundamentals.h. References AUTOCORRELATION, and fourierproduct(). 00192 { 00193 return fourierproduct(f, NULL, myflag, AUTOCORRELATION, center); 00194 }
|
|
Convolution of two images.
Definition at line 149 of file fundamentals.h. References CONVOLUTION, and fourierproduct(). Referenced by EMAN::EMData::calc_ccf(). 00149 { 00150 return fourierproduct(f, g, myflag, CONVOLUTION, center); 00151 }
|
|
Correlation of two images.
Definition at line 128 of file fundamentals.h. References CORRELATION, and fourierproduct(). Referenced by EMAN::EMData::calc_ccf(). 00128 { 00129 return fourierproduct(f, g, myflag, CORRELATION, center); 00130 }
|
|
Definition at line 313 of file vecmath.h. 00313 { 00314 return w ^ v; 00315 }
|
|
Definition at line 309 of file vecmath.h. Referenced by EMAN::FourierReconstructor::do_compare_slice_work(), and EMAN::EMUtil::vertical_acf(). 00309 { 00310 return w * v; 00311 }
|
|
Definition at line 2216 of file aligner.cpp.
|
|
Definition at line 2221 of file aligner.cpp.
|
|
Definition at line 819 of file analyzer.cpp.
|
|
Definition at line 824 of file analyzer.cpp.
|
|
Definition at line 1283 of file averager.cpp.
|
|
Definition at line 1288 of file averager.cpp.
|
|
Definition at line 1220 of file cmp.cpp.
|
|
Definition at line 1225 of file cmp.cpp.
|
|
Definition at line 822 of file emobject.h. References EMAN::TypeDict::dump(). 00823 { 00824 vector < string > item_names = Factory < T >::get_list(); 00825 00826 for (size_t i = 0; i < item_names.size(); i++) { 00827 T *item = Factory < T >::get(item_names[i]); 00828 printf("%s : %s\n", item->get_name().c_str(),item->get_desc().c_str()); 00829 TypeDict td = item->get_param_types(); 00830 td.dump(); 00831 } 00832 }
|
|
Definition at line 834 of file emobject.h. References EMAN::TypeDict::get_desc(), EMAN::TypeDict::get_type(), EMAN::TypeDict::keys(), and EMAN::TypeDict::size(). 00835 { 00836 vector < string > item_names = Factory < T >::get_list(); 00837 map<string, vector<string> > factory_list; 00838 00839 typename vector<string>::const_iterator p; 00840 for(p = item_names.begin(); p !=item_names.end(); ++p) { 00841 T *item = Factory<T>::get(*p); 00842 00843 string name = item->get_name(); 00844 00845 vector<string> content; 00846 content.push_back(item->get_desc()); 00847 TypeDict td = item->get_param_types(); 00848 vector<string> keys = td.keys(); 00849 for(unsigned int i=0; i<td.size(); ++i) { 00850 content.push_back(keys[i]); 00851 content.push_back( td.get_type(keys[i]) ); 00852 content.push_back( td.get_desc(keys[i]) ); 00853 } 00854 factory_list[name] = content; 00855 } 00856 00857 return factory_list; 00858 }
|
|
Dumps useful information about the OrientationGenerator factory.
Definition at line 136 of file symmetry.cpp.
|
|
Can be used to get useful information about the OrientationGenerator factory.
Definition at line 141 of file symmetry.cpp.
|
|
Definition at line 9763 of file processor.cpp.
|
|
Definition at line 9768 of file processor.cpp.
|
|
Definition at line 2108 of file projector.cpp.
|
|
Definition at line 2113 of file projector.cpp.
|
|
Definition at line 3379 of file reconstructor.cpp.
|
|
Definition at line 3384 of file reconstructor.cpp.
|
|
dump symmetries, useful for obtaining symmetry information
Definition at line 62 of file symmetry.cpp.
|
|
dump_symmetries_list, useful for obtaining symmetry information
Definition at line 67 of file symmetry.cpp.
|
|
Definition at line 597 of file rsconvolution.cpp. References BINARY, EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), GRAYLEVEL, 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 BINARY, EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), GRAYLEVEL, 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 CIRCULAR, 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 167 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::do_fft_inplace(), EMAN::EMData::do_ift_inplace(), 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, SELF_CORRELATION, EMAN::EMData::set_array_offsets(), and EMAN::EMData::update(). Referenced by autocorrelation(), convolution(), correlation(), EMAN::ConvolutionProcessor::process_inplace(), and self_correlation(). 00167 { 00168 int normfact; 00169 //std::complex<float> phase_mult; 00170 // Not only does the value of "flag" determine how we handle 00171 // periodicity, but it also determines whether or not we should 00172 // normalize the results. Here's some convenience bools: 00173 bool donorm = (0 == flag%2) ? true : false; 00174 // the 2x padding is hardcoded for now 00175 int npad = (flag >= 3) ? 2 : 1; // amount of padding used 00176 // g may be NULL. If so, have g point to the same object as f. In that 00177 // case we need to be careful later on not to try to delete g's workspace 00178 // as well as f's workspace, since they will be the same. 00179 bool gexists = true; 00180 if (!g) { g = f; gexists = false; } 00181 if ( f->is_complex() || g->is_complex() ) { 00182 // Fourier input only allowed for circulant 00183 if (CIRCULANT != flag) { 00184 LOGERR("Cannot perform normalization or padding on Fourier type."); 00185 throw InvalidValueException(flag, "Cannot perform normalization or padding on Fourier type."); 00186 } 00187 } 00188 // These are actual dimensions of f (and real-space sizes for ny and nz) 00189 int nx = f->get_xsize(); 00190 int ny = f->get_ysize(); 00191 int nz = f->get_zsize(); 00192 // We manifestly assume no zero-padding here, just the 00193 // necessary extension along x for the fft 00194 if (!f->is_real()) nx = (nx - 2 + (f->is_fftodd() ? 1 : 0)); 00195 00196 // these are padded dimensions 00197 const int nxp = npad*nx; 00198 const int nyp = (ny > 1) ? npad*ny : 1; // don't pad y for 1-d image 00199 const int nzp = (nz > 1) ? npad*nz : 1; // don't pad z for 2-d image 00200 00201 // now one half of the padded, fft-extended size along x 00202 const int lsd2 = (nxp + 2 - nxp%2) / 2; 00203 // The [padded] fft-extended fourier version of f is fp. 00204 00205 EMData* fp = NULL; 00206 if (f->is_complex()) { 00207 // If f is already a fourier object then fp is a copy of f. 00208 // (The fp workspace is modified, so we copy f to keep f pristine.) 00209 fp=f->copy(); 00210 } else { 00211 // [normalize] [pad] compute fft 00212 fp = f->norm_pad(donorm, npad); 00213 fp->do_fft_inplace(); 00214 } 00215 // The [padded] fft-extended version of g is gp. 00216 EMData* gp = NULL; 00217 if(f==g) { 00218 // g is an alias for f, so gp should be an alias for fp 00219 gp=fp; 00220 } else if (g->is_complex()) { 00221 // g is already a Fourier object, so gp is just an alias for g 00222 // (The gp workspace is not modified, so we don't need a copy.) 00223 gp = g; 00224 } else { 00225 // normal case: g is real and different from f, so compute gp 00226 gp = g->norm_pad(donorm, npad); 00227 gp->do_fft_inplace(); 00228 } 00229 // Get complex matrix views of fp and gp; matrices start from 1 (not 0) 00230 fp->set_array_offsets(1,1,1); 00231 gp->set_array_offsets(1,1,1); 00232 00233 // If the center flag is true, put the center of the correlation in the middle 00234 // If it is false, put it in (0,0), this approach saves time, but it is diffcult to manage the result 00235 if (center) { 00236 // Multiply two functions (the real work of this routine) 00237 int itmp = nx/2; 00238 //float sx = float(-twopi*float(itmp)/float(nxp)); 00239 float sxn = 2*float(itmp)/float(nxp); 00240 float sx = -M_PI*sxn; 00241 itmp = ny/2; 00242 //float sy = float(-twopi*float(itmp)/float(nyp)); 00243 float syn = 2*float(itmp)/float(nyp); 00244 float sy = -M_PI*syn; 00245 itmp = nz/2; 00246 //float sz = float(-twopi*float(itmp)/float(nzp)); 00247 float szn = 2*float(itmp)/float(nzp); 00248 float sz = -M_PI*szn; 00249 if ( nx%2==0 && (ny%2==0 || ny==1 ) && (nz%2==0 || nz==1 ) ) { 00250 switch (ptype) { 00251 case AUTOCORRELATION: 00252 // fpmat := |fpmat|^2 00253 // Note nxp are padded dimensions 00254 for (int iz = 1; iz <= nzp; iz++) { 00255 for (int iy = 1; iy <= nyp; iy++) { 00256 for (int ix = 1; ix <= lsd2; ix++) { 00257 float fpr = real(fp->cmplx(ix,iy,iz)); 00258 float fpi = imag(fp->cmplx(ix,iy,iz)); 00259 fp->cmplx(ix,iy,iz) = complex<float>(fpr*fpr+fpi*fpi, 0.0f); 00260 } 00261 } 00262 } 00263 break; 00264 case SELF_CORRELATION: 00265 // fpmat:=|fpmat| 00266 // Note nxp are padded dimensions 00267 for (int iz = 1; iz <= nzp; iz++) { 00268 for (int iy = 1; iy <= nyp; iy++) { 00269 for (int ix = 1; ix <= lsd2; ix++) { 00270 fp->cmplx(ix,iy,iz) = complex<float>(abs(fp->cmplx(ix,iy,iz)), 0.0f); 00271 } 00272 } 00273 } 00274 break; 00275 case CORRELATION: 00276 // fpmat:=fpmat*conjg(gpmat) 00277 // Note nxp are padded dimensions 00278 for (int iz = 1; iz <= nzp; iz++) { 00279 for (int iy = 1; iy <= nyp; iy++) { 00280 for (int ix = 1; ix <= lsd2; ix++) { 00281 fp->cmplx(ix,iy,iz) *= conj(gp->cmplx(ix,iy,iz)); 00282 } 00283 } 00284 } 00285 break; 00286 case CONVOLUTION: 00287 // fpmat:=fpmat*gpmat 00288 // Note nxp are padded dimensions 00289 for (int iz = 1; iz <= nzp; iz++) { 00290 for (int iy = 1; iy <= nyp; iy++) { 00291 for (int ix = 1; ix <= lsd2; ix++) { 00292 fp->cmplx(ix,iy,iz) *= gp->cmplx(ix,iy,iz); 00293 } 00294 } 00295 } 00296 break; 00297 default: 00298 LOGERR("Illegal option in Fourier Product"); 00299 throw InvalidValueException(ptype, "Illegal option in Fourier Product"); 00300 } 00301 for (int iz = 1; iz <= nzp; iz++) { 00302 for (int iy = 1; iy <= nyp; iy++) { 00303 for (int ix = (iz+iy+1)%2+1; ix <= lsd2; ix+=2) { 00304 fp->cmplx(ix,iy,iz) = -fp->cmplx(ix,iy,iz); 00305 } 00306 } 00307 } 00308 } else { 00309 switch (ptype) { 00310 case AUTOCORRELATION: 00311 // fpmat := |fpmat|^2 00312 // Note nxp are padded dimensions 00313 for (int iz = 1; iz <= nzp; iz++) { 00314 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00315 for (int iy = 1; iy <= nyp; iy++) { 00316 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00317 for (int ix = 1; ix <= lsd2; ix++) { 00318 int jx=ix-1; float arg=sx*jx+argy; 00319 float fpr = real(fp->cmplx(ix,iy,iz)); 00320 float fpi = imag(fp->cmplx(ix,iy,iz)); 00321 fp->cmplx(ix,iy,iz)= (fpr*fpr + fpi*fpi) *std::complex<float>(cos(arg),sin(arg)); 00322 } 00323 } 00324 } 00325 break; 00326 case SELF_CORRELATION: 00327 // fpmat:=|fpmat| 00328 // Note nxp are padded dimensions 00329 for (int iz = 1; iz <= nzp; iz++) { 00330 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00331 for (int iy = 1; iy <= nyp; iy++) { 00332 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00333 for (int ix = 1; ix <= lsd2; ix++) { 00334 int jx=ix-1; float arg=sx*jx+argy; 00335 fp->cmplx(ix,iy,iz) = abs(fp->cmplx(ix,iy,iz)) *std::complex<float>(cos(arg),sin(arg)); 00336 } 00337 } 00338 } 00339 break; 00340 case CORRELATION: 00341 // fpmat:=fpmat*conjg(gpmat) 00342 // Note nxp are padded dimensions 00343 for (int iz = 1; iz <= nzp; iz++) { 00344 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00345 for (int iy = 1; iy <= nyp; iy++) { 00346 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00347 for (int ix = 1; ix <= lsd2; ix++) { 00348 int jx=ix-1; float arg=sx*jx+argy; 00349 fp->cmplx(ix,iy,iz) *= conj(gp->cmplx(ix,iy,iz)) *std::complex<float>(cos(arg),sin(arg)); 00350 } 00351 } 00352 } 00353 break; 00354 case CONVOLUTION: 00355 // fpmat:=fpmat*gpmat 00356 // Note nxp are padded dimensions 00357 if(npad == 1) { 00358 sx -= 4*(nx%2)/float(nx); 00359 sy -= 4*(ny%2)/float(ny); 00360 sz -= 4*(nz%2)/float(nz); 00361 } 00362 for (int iz = 1; iz <= nzp; iz++) { 00363 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00364 for (int iy = 1; iy <= nyp; iy++) { 00365 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00366 for (int ix = 1; ix <= lsd2; ix++) { 00367 int jx=ix-1; float arg=sx*jx+argy; 00368 fp->cmplx(ix,iy,iz) *= gp->cmplx(ix,iy,iz) *std::complex<float>(cos(arg),sin(arg)); 00369 } 00370 } 00371 } 00372 break; 00373 default: 00374 LOGERR("Illegal option in Fourier Product"); 00375 throw InvalidValueException(ptype, "Illegal option in Fourier Product"); 00376 } 00377 } 00378 } else { 00379 // If the center flag is false, then just do basic multiplication 00380 switch (ptype) { 00381 case AUTOCORRELATION: 00382 for (int iz = 1; iz <= nzp; iz++) { 00383 for (int iy = 1; iy <= nyp; iy++) { 00384 for (int ix = 1; ix <= lsd2; ix++) { 00385 float fpr = real(fp->cmplx(ix,iy,iz)); 00386 float fpi = imag(fp->cmplx(ix,iy,iz)); 00387 fp->cmplx(ix,iy,iz) = complex<float>(fpr*fpr+fpi*fpi, 0.0f); 00388 } 00389 } 00390 } 00391 break; 00392 case SELF_CORRELATION: 00393 for (int iz = 1; iz <= nzp; iz++) { 00394 for (int iy = 1; iy <= nyp; iy++) { 00395 for (int ix = 1; ix <= lsd2; ix++) { 00396 fp->cmplx(ix,iy,iz) = complex<float>(abs(fp->cmplx(ix,iy,iz)), 0.0f); 00397 } 00398 } 00399 } 00400 break; 00401 case CORRELATION: 00402 //phase_mult = 1; 00403 for (int iz = 1; iz <= nzp; iz++) { 00404 for (int iy = 1; iy <= nyp; iy++) { 00405 for (int ix = 1; ix <= lsd2; ix++) { 00406 fp->cmplx(ix,iy,iz)*= conj(gp->cmplx(ix,iy,iz)); 00407 } 00408 } 00409 } 00410 break; 00411 case CONVOLUTION: 00412 if(npad == 1) { 00413 float sx = -M_PI*2*(nx%2)/float(nx); 00414 float sy = -M_PI*2*(ny%2)/float(ny); 00415 float sz = -M_PI*2*(nz%2)/float(nz); 00416 for (int iz = 1; iz <= nzp; iz++) { 00417 int jz=iz-1; if(jz>nzp/2) jz=jz-nzp; float argz=sz*jz; 00418 for (int iy = 1; iy <= nyp; iy++) { 00419 int jy=iy-1; if(jy>nyp/2) jy=jy-nyp; float argy=sy*jy+argz; 00420 for (int ix = 1; ix <= lsd2; ix++) { 00421 int jx=ix-1; float arg=sx*jx+argy; 00422 fp->cmplx(ix,iy,iz) *= gp->cmplx(ix,iy,iz) *std::complex<float>(cos(arg),sin(arg)); 00423 } 00424 } 00425 } 00426 } else { 00427 for (int iz = 1; iz <= nzp; iz++) { 00428 for (int iy = 1; iy <= nyp; iy++) { 00429 for (int ix = 1; ix <= lsd2; ix++) { 00430 fp->cmplx(ix,iy,iz)*= gp->cmplx(ix,iy,iz); 00431 } 00432 } 00433 } 00434 } 00435 break; 00436 default: 00437 LOGERR("Illegal option in Fourier Product"); 00438 throw InvalidValueException(ptype, "Illegal option in Fourier Product"); 00439 } 00440 } 00441 // 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); 00442 if (gexists && (f != g) && (!g->is_complex())) { 00443 if( gp ) { 00444 delete gp; 00445 gp = 0; 00446 } 00447 } 00448 // back transform 00449 fp->do_ift_inplace(); 00450 if(center && npad ==2) fp->depad(); 00451 else fp->depad_corner(); 00452 00453 //vector<int> saved_offsets = fp->get_array_offsets(); I do not know what the meaning of it was, did not work anyway PAP 00454 fp->set_array_offsets(1,1,1); 00455 00456 normfact = (nxp/nx)*(nyp/ny)*(nzp/nz); // Normalization factor for the padded operations 00457 if(normfact>1) { 00458 for (int iz = 1; iz <= nz; iz++) for (int iy = 1; iy <= ny; iy++) for (int ix = 1; ix <= nx; ix++) (*fp)(ix,iy,iz) *= normfact; 00459 } 00460 // Lag normalization 00461 if(flag>4) { 00462 normfact = nx*ny*nz; // Normalization factor 00463 int nxc=nx/2+1, nyc=ny/2+1, nzc=nz/2+1; 00464 for (int iz = 1; iz <= nz; iz++) { 00465 float lagz=float(normfact/(nz-abs(iz-nzc))); 00466 for (int iy = 1; iy <= ny; iy++) { 00467 float lagyz=lagz/(ny-abs(iy-nyc)); 00468 for (int ix = 1; ix <= nx; ix++) { 00469 (*fp)(ix,iy,iz) *= lagyz/(nx-abs(ix-nxc)); 00470 } 00471 } 00472 } 00473 } 00474 //OVER AND OUT 00475 //fp->set_array_offsets(saved_offsets); This was strange and did not work, PAP 00476 fp->set_array_offsets(0,0,0); 00477 fp->update(); 00478 return fp; 00479 }
|
|
Definition at line 9773 of file processor.cpp. References EMAN::Factory< T >::get(), and EMAN::Factory< T >::get_list(). 09774 { 09775 map<string, vector<string> > processor_groups; 09776 09777 vector <string> processornames = Factory<Processor>::get_list(); 09778 09779 for (size_t i = 0; i < processornames.size(); i++) { 09780 Processor * f = Factory<Processor>::get(processornames[i]); 09781 if (dynamic_cast<RealPixelProcessor*>(f) != 0) { 09782 processor_groups["RealPixelProcessor"].push_back(f->get_name()); 09783 } 09784 else if (dynamic_cast<BoxStatProcessor*>(f) != 0) { 09785 processor_groups["BoxStatProcessor"].push_back(f->get_name()); 09786 } 09787 else if (dynamic_cast<ComplexPixelProcessor*>(f) != 0) { 09788 processor_groups["ComplexPixelProcessor"].push_back(f->get_name()); 09789 } 09790 else if (dynamic_cast<CoordinateProcessor*>(f) != 0) { 09791 processor_groups["CoordinateProcessor"].push_back(f->get_name()); 09792 } 09793 else if (dynamic_cast<FourierProcessor*>(f) != 0) { 09794 processor_groups["FourierProcessor"].push_back(f->get_name()); 09795 } 09796 else if (dynamic_cast<NewFourierProcessor*>(f) != 0) { 09797 processor_groups["FourierProcessor"].push_back(f->get_name()); 09798 } 09799 else if (dynamic_cast<NormalizeProcessor*>(f) != 0) { 09800 processor_groups["NormalizeProcessor"].push_back(f->get_name()); 09801 } 09802 else { 09803 processor_groups["Others"].push_back(f->get_name()); 09804 } 09805 } 09806 09807 return processor_groups; 09808 }
|
|
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 *().
|
|
Definition at line 688 of file vecmath.h. References EMAN::Vector4::length(). 00688 { return v.length(); }
|
|
Definition at line 317 of file vecmath.h. References EMAN::Vector3::length(). 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 8146 of file processor.cpp. References Assert, and EMAN::EMData::process_inplace(). 08147 { 08148 Assert(image != 0); 08149 Assert(processornames.size() > 0); 08150 08151 for (size_t i = 0; i < processornames.size(); i++) { 08152 image->process_inplace(processornames[i]); 08153 } 08154 return 0; 08155 }
|
|
Definition at line 684 of file vecmath.h.
|
|
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. 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.
|
|
Definition at line 133 of file vecmath.h.
|
|
Definition at line 826 of file vec3.h. 00826 { 00827 // Preserve the vector type 00828 Vec2<Type> v1(v); 00829 v1 *= d; 00830 return v1; 00831 }
|
|
Definition at line 817 of file vec3.h. 00818 { 00819 // Preserve the vector type 00820 Vec2<Type2> v1(v); 00821 v1 *= d; 00822 return v1; 00823 }
|
|
Definition at line 811 of file vec3.h. References EMAN::Vec2< Type >::dot().
|
|
Definition at line 448 of file vec3.h. 00448 { 00449 // Preserve the vector type 00450 Vec3<Type> v1(v); 00451 v1 *= d; 00452 return v1; 00453 }
|
|
Definition at line 439 of file vec3.h. 00440 { 00441 // Preserve the vector type 00442 Vec3<Type2> v1(v); 00443 v1 *= d; 00444 return v1; 00445 }
|
|
Definition at line 433 of file vec3.h. References EMAN::Vec3< Type >::dot().
|
|
Definition at line 899 of file transform.h. 00900 { 00901 // This is the left multiplication of a vector, v by a matrix M 00902 float x = M[0][0] * v[0] + M[0][1] * v[1] + M[0][3] ; 00903 float y = M[1][0] * v[0] + M[1][1] * v[1] + M[1][3]; 00904 return Vec2f(x, y); 00905 }
|
|
Definition at line 888 of file transform.h. 00889 { 00890 // This is the left multiplication of a vector, v by a matrix M 00891 float x = M[0][0] * v[0] + M[0][1] * v[1] + M[0][2] * v[2] + M[0][3]; 00892 float y = M[1][0] * v[0] + M[1][1] * v[1] + M[1][2] * v[2] + M[1][3]; 00893 float z = M[2][0] * v[0] + M[2][1] * v[1] + M[2][2] * v[2] + M[2][3]; 00894 return Vec3f(x, y, z); 00895 }
|
|
Definition at line 878 of file transform.h. 00879 { 00880 // This is the right multiplication of a row vector, v by a transform3D matrix M 00881 float x = v[0] * M[0][0] + v[1] * M[1][0] + v[2] * M[2][0] ; 00882 float y = v[0] * M[0][1] + v[1] * M[1][1] + v[2] * M[2][1]; 00883 float z = v[0] * M[0][2] + v[1] * M[1][2] + v[2] * M[2][2]; 00884 return Vec3f(x, y, z); 00885 }
|
|
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 473 of file transform.h. 00474 { 00475 float x = v[0] * M[0][0] + v[1] * M[1][0] + v[2] * M[2][0] ; 00476 float y = v[0] * M[0][1] + v[1] * M[1][1] + v[2] * M[2][1]; 00477 float z = v[0] * M[0][2] + v[1] * M[1][2] + v[2] * M[2][2]; 00478 return Vec3f(x, y, z); 00479 }
|
|
Matrix times Vector, a pure mathematical operation.
Definition at line 464 of file transform.h. References EMAN::Transform::transform(). 00465 { 00466 return M.transform(v); 00467 }
|
|
Matrix times Vector, a pure mathematical operation.
Definition at line 457 of file transform.h. References EMAN::Transform::transform(). 00458 { 00459 return M.transform(v); 00460 }
|
|
Definition at line 1532 of file transform.cpp. 01533 { 01534 // This is the left multiplication of a matrix M1 by a matrix M2; that is M2*M1 01535 // It returns a new matrix 01536 Transform3D resultant; 01537 for (int i=0; i<3; i++) { 01538 for (int j=0; j<4; j++) { 01539 resultant[i][j] = M2[i][0] * M1[0][j] + M2[i][1] * M1[1][j] + M2[i][2] * M1[2][j]; 01540 } 01541 resultant[i][3] += M2[i][3]; // add on the new translation (not included above) 01542 } 01543 01544 for (int j=0; j<3; j++) { 01545 resultant[3][j] = M2[3][j]; 01546 } 01547 01548 return resultant; // This will have the post_trans of M2 01549 }
|
|
Matrix times Matrix, a pure mathematical operation.
Definition at line 1149 of file transform.cpp. 01150 { 01151 Transform result; 01152 for (int i=0; i<3; i++) { 01153 for (int j=0; j<4; j++) { 01154 result[i][j] = M2[i][0] * M1[0][j] + M2[i][1] * M1[1][j] + M2[i][2] * M1[2][j]; 01155 } 01156 result[i][3] += M2[i][3]; 01157 } 01158 01159 return result; 01160 }
|
|
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 2852 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::mult().
|
|
Definition at line 2811 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::mult().
|
|
Definition at line 2781 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::mult().
|
|
Definition at line 859 of file vec3.h. 00859 { 00860 if (v1[0] != v2[0] || v1[1] != v2[1] ) { 00861 return true; 00862 } 00863 return false; 00864 }
|
|
Definition at line 481 of file vec3.h. 00481 { 00482 if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) { 00483 return true; 00484 } 00485 return false; 00486 }
|
|
Definition at line 370 of file quaternion.cpp.
|
|
Definition at line 62 of file geometry.cpp.
|
|
Definition at line 903 of file emobject.cpp.
|
|
Definition at line 759 of file emobject.cpp.
|
|
Definition at line 782 of file vec3.h. 00783 { 00784 Vec2<Type> v1(v); 00785 v1 += n; 00786 return v1; 00787 }
|
|
Definition at line 776 of file vec3.h. 00777 { 00778 return Vec2<Type>(static_cast<Type>(v1[0] + v2[0]), static_cast<Type>(v1[1] + v2[1]));; 00779 }
|
|
Definition at line 388 of file vec3.h. 00389 { 00390 Vec3<Type> v1(v); 00391 v1 += n; 00392 return v1; 00393 }
|
|
Definition at line 381 of file vec3.h. 00382 { 00383 00384 return Vec3<Type>(static_cast<Type>(v1[0] + v2[0]), static_cast<Type>(v1[1] + v2[1]),static_cast<Type>(v1[2] + v2[2]));; 00385 }
|
|
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 2838 of file emdata.cpp. References EMAN::EMData::add(), and EMAN::EMData::copy().
|
|
Definition at line 2796 of file emdata.cpp. References EMAN::EMData::add(), and EMAN::EMData::copy().
|
|
Definition at line 2767 of file emdata.cpp. References EMAN::EMData::add(), and EMAN::EMData::copy().
|
|
Definition at line 804 of file vec3.h. 00805 { 00806 return Vec2<Type>(-v[0],-v[1]); 00807 }
|
|
Definition at line 796 of file vec3.h. 00797 { 00798 Vec2<Type> v1(v); 00799 v1 -= n; 00800 return v1; 00801 }
|
|
Definition at line 790 of file vec3.h. 00791 { 00792 return Vec2<Type>(static_cast<Type>(v1[0] - v2[0]), static_cast<Type>(v1[1] - v2[1])); 00793 }
|
|
Definition at line 419 of file vec3.h. 00420 { 00421 return Vec3<Type>(-v[0],-v[1],-v[2]); 00422 }
|
|
Definition at line 412 of file vec3.h. 00413 { 00414 Vec3<Type> v1(v); 00415 v1 -= n; 00416 return v1; 00417 }
|
|
Definition at line 404 of file vec3.h. 00405 { 00406 return Vec3<Type>(static_cast<Type>(v1[0] - v2[0]), 00407 static_cast<Type>(v1[1] - v2[1]), 00408 static_cast<Type>(v1[2] - v2[2])); 00409 }
|
|
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 2845 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::sub().
|
|
Definition at line 2803 of file emdata.cpp. References EMAN::EMData::add(), EMAN::EMData::copy(), and EMAN::EMData::mult(). 02804 { 02805 EMData * r = em.copy(); 02806 r->mult(-1.0f); 02807 r->add(n); 02808 return r; 02809 }
|
|
Definition at line 2774 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::sub(). Referenced by rsub().
|
|
Definition at line 843 of file vec3.h. 00843 { 00844 // Preserve the vector type 00845 Vec2<Type> v1(v); 00846 v1 /= d; 00847 return v1; 00848 }
|
|
Definition at line 834 of file vec3.h. 00835 { 00836 // Preserve the vector type 00837 Vec2<Type2> v1(v); 00838 v1 /= d; 00839 return v1; 00840 }
|
|
Definition at line 465 of file vec3.h. 00465 { 00466 // Preserve the vector type 00467 Vec3<Type> v1(v); 00468 v1 /= d; 00469 return v1; 00470 }
|
|
Definition at line 456 of file vec3.h. 00457 { 00458 // Preserve the vector type 00459 Vec3<Type2> v1(v); 00460 v1 /= d; 00461 return v1; 00462 }
|
|
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 2859 of file emdata.cpp. References EMAN::EMData::copy(), and EMAN::EMData::div().
|
|
Definition at line 2818 of file emdata.cpp. References EMAN::EMData::copy(), EMAN::EMData::div(), EMAN::EMData::mult(), and EMAN::EMData::to_one(). 02819 { 02820 EMData * r = em.copy(); 02821 r->to_one(); 02822 r->mult(n); 02823 r->div(em); 02824 02825 return r; 02826 }
|
|
Definition at line 2788 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. 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.
|
|
Definition at line 320 of file vecmath.h.
|
|
Definition at line 200 of file vecmath.h.
|
|
Definition at line 137 of file vecmath.h.
|
|
Definition at line 851 of file vec3.h. 00851 { 00852 if (v1[0] == v2[0] && v1[1] == v2[1] ) { 00853 return true; 00854 } 00855 return false; 00856 }
|
|
Definition at line 473 of file vec3.h. 00473 { 00474 if (v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2]) { 00475 return true; 00476 } 00477 return false; 00478 }
|
|
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 897 of file emobject.cpp. References EMAN::Dict::dict. 00898 { 00899 // Just make use of map's version of operator== 00900 return (d1.dict == d2.dict); 00901 }
|
|
Definition at line 668 of file emobject.cpp. References EMAN::EMObject::b, EMAN::EMObject::BOOL, EMAN::EMObject::CTF, EMAN::EMObject::d, EMAN::EMObject::DOUBLE, EMAN::EMObject::emdata, EMAN::EMObject::EMDATA, EMAN::EMObject::f, EMAN::EMObject::farray, EMAN::EMObject::FLOAT, EMAN::EMObject::FLOAT_POINTER, EMAN::EMObject::FLOATARRAY, EMAN::EMObject::fp, EMAN::EMObject::iarray, EMAN::EMObject::INT, EMAN::EMObject::INT_POINTER, EMAN::EMObject::INTARRAY, EMAN::EMObject::ip, EMAN::EMObject::n, EMAN::EMObject::str, EMAN::EMObject::strarray, EMAN::EMObject::STRING, EMAN::EMObject::STRINGARRAY, EMAN::EMObject::TRANSFORM, EMAN::EMObject::type, EMAN::EMObject::ui, EMAN::EMObject::UNKNOWN, EMAN::EMObject::UNSIGNEDINT, EMAN::EMObject::VOID_POINTER, EMAN::EMObject::vp, EMAN::EMObject::xydata, and EMAN::EMObject::XYDATA. 00669 { 00670 00671 if (e1.type != e2.type) { 00672 return false; 00673 } 00674 00675 switch (e1.type) { 00676 case EMObject::BOOL: 00677 return (e1.b == e2.b); 00678 break; 00679 case EMObject::INT: 00680 return (e1.n == e2.n); 00681 break; 00682 case EMObject::UNSIGNEDINT: 00683 return (e1.ui == e2.ui); 00684 break; 00685 case EMObject::FLOAT: 00686 return (e1.f == e2.f); 00687 break; 00688 case EMObject::DOUBLE: 00689 return (e1.d == e2.d); 00690 break; 00691 case EMObject::CTF: 00692 case EMObject::STRING: 00693 return (e1.str == e2.str); 00694 break; 00695 case EMObject::FLOAT_POINTER: 00696 return (e1.fp == e2.fp); 00697 break; 00698 case EMObject::INT_POINTER: 00699 return (e1.ip == e2.ip); 00700 break; 00701 case EMObject::VOID_POINTER: 00702 return (e1.vp == e2.vp); 00703 break; 00704 case EMObject::EMDATA: 00705 return (e1.emdata == e2.emdata); 00706 break; 00707 case EMObject::XYDATA: 00708 return (e1.xydata == e2.xydata); 00709 break; 00710 case EMObject::TRANSFORM: 00711 case EMObject::FLOATARRAY: 00712 if (e1.farray.size() == e2.farray.size()) { 00713 for (size_t i = 0; i < e1.farray.size(); i++) { 00714 if (e1.farray[i] != e2.farray[i]) { 00715 return false; 00716 } 00717 } 00718 return true; 00719 } 00720 else { 00721 return false; 00722 } 00723 break; 00724 case EMObject::INTARRAY: 00725 if (e1.iarray.size() == e2.iarray.size()) { 00726 for (size_t i = 0; i < e1.iarray.size(); i++) { 00727 if (e1.iarray[i] != e2.iarray[i]) { 00728 return false; 00729 } 00730 } 00731 return true; 00732 } 00733 break; 00734 case EMObject::STRINGARRAY: 00735 if (e1.strarray.size() == e2.strarray.size()) { 00736 for (size_t i = 0; i < e1.strarray.size(); i++) { 00737 if (e1.strarray[i] != e2.strarray[i]) { 00738 return false; 00739 } 00740 } 00741 return true; 00742 } 00743 else { 00744 return false; 00745 } 00746 break; 00747 case EMObject::UNKNOWN: 00748 // UNKNOWN really means "no type" and if two objects both have 00749 // type UNKNOWN they really are the same 00750 return (e1.type == e2.type); 00751 break; 00752 default: 00753 return false; 00754 break; 00755 } 00756 return false; 00757 }
|
|
Direct Fourier inversion Reconstructor.
Definition at line 1949 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(), and EMAN::EMData::set_attr(). Referenced by EMAN::file_store::add_image(), EMAN::newfile_store::add_image(), EMAN::nnSSNR_ctfReconstructor::insert_slice(), EMAN::nn4_ctfReconstructor::insert_slice(), EMAN::nnSSNR_Reconstructor::insert_slice(), and EMAN::nn4Reconstructor::insert_slice(). 01950 { 01951 int nx = slice->get_xsize(); 01952 int ny = slice->get_ysize(); 01953 int ndim = (ny==1) ? 1 : 2; 01954 01955 if( ndim==2 && nx!=ny ) 01956 { 01957 // FIXME: What kind of exception should we throw here? 01958 throw std::runtime_error("Tried to padfft a 2D slice which is not square."); 01959 } 01960 01961 // process 2D slice or 1D line -- subtract the average outside of the circle, zero-pad, fft extend, and fft 01962 EMData* temp = slice->average_circ_sub(); 01963 01964 Assert( temp != NULL ); 01965 EMData* zeropadded = temp->norm_pad( false, npad ); 01966 Assert( zeropadded != NULL ); 01967 checked_delete( temp ); 01968 01969 zeropadded->do_fft_inplace(); 01970 EMData* padfftslice = zeropadded; 01971 01972 // shift the projection 01973 Vec2f trans = t.get_trans_2d(); 01974 float sx = -trans[0]; 01975 float sy = -trans[1]; 01976 if(sx != 0.0f || sy != 0.0) 01977 padfftslice->process_inplace("filter.shift", Dict("x_shift", sx, "y_shift", sy, "z_shift", 0.0f)); 01978 01979 int remove = slice->get_attr_default("remove", 0); 01980 padfftslice->set_attr( "remove", remove ); 01981 01982 01983 01984 padfftslice->center_origin_fft(); 01985 return padfftslice; 01986 }
|
|
Image periodogram.
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(), EMAN::EMData::set_array_offsets(), 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 // We manifestly assume no zero-padding here, just the 00046 // necessary extension along x for the fft 00047 00048 if (f->is_complex()) nx = (nx - 2 + f->is_fftodd()); // nx is the real-space size of the input image 00049 int lsd2 = (nx + 2 - nx%2) / 2; // Extended x-dimension of the complex image 00050 00051 // Process f if real 00052 EMData* fp = NULL; 00053 if(f->is_complex()) fp = f->copy(); // we need to make a full copy so that we don't damage the original 00054 else { 00055 fp = f->norm_pad(false, 1); // Extend and do the FFT if f is real 00056 fp->do_fft_inplace(); 00057 } 00058 fp->set_array_offsets(1,1,1); 00059 00060 // Periodogram: fp:=|fp|**2 00061 for (int iz = 1; iz <= nz; iz++) { 00062 for (int iy = 1; iy <= ny; iy++) { 00063 for (int ix = 1; ix <= lsd2; ix++) { 00064 float fpr = real(fp->cmplx(ix,iy,iz)); 00065 float fpi = imag(fp->cmplx(ix,iy,iz)); 00066 fp->cmplx(ix,iy,iz) = fpr*fpr + fpi*fpi; 00067 } 00068 } 00069 } 00070 // Create power as a 3D array (-n/2:n/2+n%2-1) 00071 int nyt, nzt; 00072 int nx2 = nx/2; 00073 int ny2 = ny/2; if(ny2 == 0) nyt =0; else nyt=ny; 00074 int nz2 = nz/2; if(nz2 == 0) nzt =0; else nzt=nz; 00075 int nx2p = nx2+nx%2; 00076 int ny2p = ny2+ny%2; 00077 int nz2p = nz2+nz%2; 00078 EMData& power = *(new EMData()); // output image 00079 power.set_size(nx, ny, nz); 00080 power.set_array_offsets(-nx2,-ny2,-nz2); 00081 //If instead of preservation of the norm one would prefer to have peak of a PW of a single sine wave equal one 00082 // multiply power by the scale below, or the other way around. 00083 float scale = 4.0f/float (nx*nx)/float (ny*ny)/float (nz*nz); 00084 for (int iz = 1; iz <= nz; iz++) { 00085 int jz=iz-1; 00086 if(jz>=nz2p) jz=jz-nzt; 00087 for (int iy = 1; iy <= ny; iy++) { 00088 int jy=iy-1; 00089 if(jy>=ny2p) jy=jy-nyt; 00090 for (int ix = 1; ix <= lsd2; ix++) { 00091 int jx=ix-1; 00092 if(jx>=nx2p) jx=jx-nx; 00093 power(jx,jy,jz) = real(fp->cmplx(ix,iy,iz)) * scale; 00094 } 00095 } 00096 } 00097 00098 // Create the Friedel related half 00099 int nzb, nze, nyb, nye, nxb, nxe; 00100 nxb =-nx2+(nx+1)%2; 00101 nxe = nx2-(nx+1)%2; 00102 if(ny2 == 0) {nyb =0; nye = 0;} else {nyb =-ny2+(ny+1)%2; nye = ny2-(ny+1)%2;} 00103 if(nz2 == 0) {nzb =0; nze = 0;} else {nzb =-nz2+(nz+1)%2; nze = nz2-(nz+1)%2;} 00104 for (int iz = nzb; iz <= nze; iz++) { 00105 for (int iy = nyb; iy <= nye; iy++) { 00106 for (int ix = 1; ix <= nxe; ix++) { // Note this loop begins with 1 - FFT should create correct Friedel related 0 plane 00107 power(-ix,-iy,-iz) = power(ix,iy,iz); 00108 } 00109 } 00110 } 00111 if(ny2 != 0) { 00112 if(nz2 != 0) { 00113 if(nz%2 == 0) { //if nz even, fix the first slice 00114 for (int iy = nyb; iy <= nye; iy++) { 00115 for (int ix = nxb; ix <= -1; ix++) { 00116 power(ix,iy,-nz2) = power(-ix,-iy,-nz2); 00117 } 00118 } 00119 if(ny%2 == 0) { //if ny even, fix the first line 00120 for (int ix = nxb; ix <= -1; ix++) { 00121 power(ix,-ny2,-nz2) = power(-ix,-ny2,-nz2); 00122 } 00123 } 00124 } 00125 } 00126 if(ny%2 == 0) { //if ny even, fix the first column 00127 for (int iz = nzb; iz <= nze; iz++) { 00128 for (int ix = nxb; ix <= -1; ix++) { 00129 power(ix,-ny2,-iz) = power(-ix,-ny2,iz); 00130 } 00131 } 00132 } 00133 00134 } 00135 00136 if( fp ) { 00137 delete fp; // avoid a memory leak! 00138 fp = 0; 00139 } 00140 //power[0][0][0]=power[1][0][0]; //Steve requested the original origin. 00141 00142 power.update(); 00143 power.set_array_offsets(0,0,0); 00144 return &power; 00145 //OVER AND OUT 00146 }
|
|
Definition at line 2833 of file emdata.cpp. References operator/(). 02834 { 02835 return EMAN::operator/(n, em); 02836 }
|
|
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 2828 of file emdata.cpp. References operator-(). Referenced by main(). 02829 { 02830 return EMAN::operator-(n, em); 02831 }
|
|
Image self-correlation.
Definition at line 211 of file fundamentals.h. References fourierproduct(), and SELF_CORRELATION. 00211 { 00212 return fourierproduct(f, NULL, myflag, SELF_CORRELATION, center); 00213 }
|
|
Definition at line 689 of file vecmath.h. References EMAN::Vector4::length().
|
|
Definition at line 318 of file vecmath.h. References EMAN::Vector3::length().
|
|
Definition at line 49 of file polardata.h. Referenced by alprbs(), and Numrinit(). |