| ►NEMAN | E2Exception class |
| ►NGatan | |
| CDataType | |
| CTagData | |
| CTagEntry | |
| CTagGroup | |
| CTagTable | |
| ►NGatanDM4 | |
| CDataType | |
| CTagData | |
| CTagEntry | |
| CTagGroup | |
| CTagTable | |
| C_BadAllocException | Used when memory allocation goes wrong... i.e |
| C_EmptyContainerException | Used when an argument container is empty, such as a vector |
| C_FileAccessException | Used when a file access error occurs |
| C_ImageDimensionException | Used when an image is not in the expected dimension |
| C_ImageFormatException | Used when an image is not in the expected format |
| C_ImageReadException | Used when an error occurs at image reading time |
| C_ImageWriteException | Used when an error occurs at image writing time |
| C_InvalidCallException | |
| C_InvalidParameterException | |
| C_InvalidStringException | Used when an invalid (format) string is given |
| C_InvalidValueException | Used when an invalid integer value is given |
| C_NotExistingObjectException | Used when an object type, like an EMObject type, doesn't exist |
| C_NullPointerException | Used when a NULL is given to a pointer that should not be NULL |
| C_OutofRangeException | Used when the given value is out of range |
| C_TypeException | Used when a type cast error occurs |
| C_UnexpectedBehaviorException | Used when internal behavior is unexpected A generic kind of exception |
| CAboveToZeroProcessor | F(x) = x if x <= maxval; f(x) = 0 if x > maxval |
| CAbsoluteValueProcessor | F(x) = |x| |
| CACFCenterProcessor | Center image using auto convolution with 180 degree rotation |
| CAddMaskShellProcessor | Add additional shells/rings to an existing 1/0 mask image |
| CAddNoiseProcessor | Add noise to an image |
| CAddRandomNoiseProcessor | Add spectral noise to a complex image |
| CAddShapeProcessor | Rotate by 180 using pixel swapping, works for 2D only |
| CAddSigmaNoiseProcessor | Add sigma noise, multiply image's sigma value to noise |
| CAligner | Aligner class defines image alignment method |
| CAmiraIO | Amira file = ASCII header + binary data |
| CAmpMultProcessor | |
| CAmpweightFourierProcessor | Multiplies each Fourier pixel by its amplitude |
| CAnalyzer | Analyzer class defines a way to take a List of images as input, and returns a new List of images |
| CApplyPolynomialProfileToHelix | |
| CApplySymProcessor | Applies a symmetry to a 3D model |
| CAreaProcessor | AreaProcessor use pixel values and coordinates of a real-space square area |
| CAutoMask2DProcessor | Attempts to automatically mask out the particle, excluding other particles in the box, etc |
| CAutoMask3D2Processor | Tries to mask out only interesting density |
| CAutoMask3DProcessor | Tries to mask out only interesting density |
| CAutoMaskAsymUnit | Tries to mask out only interesting density |
| CAutoMaskDustProcessor | A "dust removal" filter which will remove above threshold densities smaller than a given size |
| CAverager | Averager class defines a way to do averaging on a set of images |
| CAverageXProcessor | Average along Y and replace with average |
| CAxis0FourierProcessor | Zeroes the values on the X=0 and y=0 Fourier axes (except x=y=0) |
| CAzSharpProcessor | Similar to FourierProcessor, but enhances or compresses azimuthal contrast rather than the typical radial linear filter |
| CBackProjectionReconstructor | Real space 3D reconstruction using back projection |
| CBadLineXYProcessor | This processor will remove specified bad lines from CCD/DDD images, generally due to faulty lines/rows in the detector |
| CBeamstopProcessor | Try to eliminate beamstop in electron diffraction patterns |
| CBilateralProcessor | Bilateral processing on 2D or 3D volume data |
| CBinarizeFourierProcessor | A thresholding processor for Fourier images based on the amplitude component |
| CBinarizeProcessor | F(x) = 0 if x < value; f(x) = 1 if x >= value |
| CBinaryBlackHatProcessor | Performs a morphological black hat operation on an image |
| CBinaryClosingProcessor | Performs a morphological closing operation on an image |
| CBinaryDilationProcessor | Performs a morphological dilation operation on an image |
| CBinaryErosionProcessor | Performs a morphological erosion operation on an image |
| CBinaryExternalGradientProcessor | Computes an external morphological gradient operation on an image |
| CBinaryInternalGradientProcessor | Computes an internal morphological gradient operation on an image |
| CBinaryMorphGradientProcessor | Computes the morphological gradient operation on an image |
| CBinaryOpeningProcessor | Performs a morphological opening operation on an image |
| CBinaryOperateProcessor | 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 |
| CBinarySkeletonizerProcessor | |
| CBinaryTopHatProcessor | Performs a morphological top hat operation on an image |
| CBispecSliceProcessor | This processor computes 2-D slices of the 4-D bispectrum of a 2-D image |
| CBitReader | |
| CBitStream | |
| CBooleanProcessor | F(x) = 0 if x = 0; f(x) = 1 if x != 0 |
| CBooleanShrinkProcessor | BooleanShrinkProcessor encapsulates code common to MaxShrinkProcessor and MinShrinkProcessor - the processors use more or less identical code, the main difference being the logical operator |
| CBoxingTools | BoxingTools is class for encapsulating common boxing operations that may become expensive if they are implemented in python |
| CBoxMaxProcessor | Peak processor: pixel = max of values surrounding pixel |
| CBoxMedianProcessor | A processor for noise reduction |
| CBoxSigmaProcessor | Pixel = standard deviation of values surrounding pixel |
| CBoxStatProcessor | BoxStatProcessor files are a kind of neighborhood processors |
| CBoxSVDClassifier | |
| CBwMajorityProcessor | Set a pixel to white when >= N neighbors are white |
| CBwThinningProcessor | Thinning a binary map to skelton using the Zhang-Suen thinning algorithm |
| CByteOrder | ByteOrder defines functions to work on big/little endian byte orders |
| CCccCmp | Compute the cross-correlation coefficient between two images |
| CCCCSNRProcessor | Convert an image containing normalized correlation coefficients to SNR or a Wiener filter value used in conjunction with local resolution filtration |
| CCCDNormProcessor | Try to normalize the 4 quadrants of a CCD image |
| CChaoProjector | Fast real space projection using Bi-Linear interpolation |
| CCircularAverageAnalyzer | Calculate the circular average around the center in real space |
| CCircularAverageBinarizeProcessor | Binarize an image based on the circular average around each pixel in real space |
| CCircularMaskProcessor | 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() |
| CClampingProcessor | F(x) = maxval if f(x) > maxval; f(x) = minval if f(x) < minval |
| CCmp | Cmp class defines image comparison method |
| CCollapseProcessor | F(x): if v-r<x<v+r -> v; if x>v+r -> x-r; if x<v-r -> x+r |
| CColorRGBGenerator | Class to encapsulate an RGB color generator for marching cubes isosurface generator For now you can only color by radius, but in the near future you will be able to color by map, etc |
| CComplexNormPixel | Each Fourier pixel will be normalized |
| CComplexPixelProcessor | The base class for fourier space processor working on individual pixels |
| CConvolutionKernelProcessor | |
| CConvolutionProcessor | This processor performs fast convolution in Fourier space |
| CCoordinateProcessor | CoordinateProcessor applies processing based on a pixel's value and it coordinates |
| CCSym | An encapsulation of cyclic 3D symmetry |
| CCtf | Ctf is the base class for all CTF model |
| CCtfCAutoAverager | CtfCWautoAverager averages the images with CTF correction with a Wiener filter |
| CCTFCorrProcessor | 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 |
| CCtfCWautoAverager | CtfCWautoAverager averages the images with CTF correction with a Wiener filter |
| CCtfSimProcessor | CTF simulation processor |
| CCTFSNRWeightProcessor | |
| CCtfWtAverager | CtfWtAverager |
| CCtfWtFiltAverager | CtfWtAverager |
| CCUDA_Aligner | |
| CCUDA_multiref_aligner | |
| CCustomVector | CustomVector has some trivial optimizations of the STL vector |
| CCutoffBlockProcessor | Block processor, val1 is dx/dy, val2 is lp freq cutoff in pixels |
| CCutToZeroProcessor | F(x) = x-minval if x >= minval; f(x) = 0 if x < minval |
| CDecayEdgeProcessor | Decay edges of image to zero |
| CDecoder | |
| CDecoderIx | |
| CDf3IO | |
| ►CDict | Dict is a dictionary to store <string, EMObject> pair |
| Cconst_iterator | Const iterator support for the Dict object This is just a wrapper, everything is inherited from the map<string,EMObject>::cons_iterator so the interface is the same as you would expect i.e for ( Dict::const_iterator it = params.begin(); it != params.end(); ++it ) |
| Citerator | Non const iterator support for the Dict object This is just a wrapper, everything is inherited from the map<string,EMObject>::iterator so the interface is the same as you would expect i.e for ( Dict::iterator it = params.begin(); it != params.end(); ++it ) |
| CDiffBlockProcessor | Averages over cal_half_width, then sets the value in a local block |
| CDirectionalSumProcessor | Does a projection in one the axial directions Doesn't support process_inplace (because the output has potentially been compressed in one dimension) |
| CDiscritizeProcessor | |
| CDistanceSegmentProcessor | Segment a volume about:homeinto subvolumes based on a center separation value |
| CDM3IO | Gatan DM3 file is a hierarchical binary image format |
| CDM4IO | Gatan DM$ was introduced with the GMS 2.0 release |
| CDoGFourierProcessor | Processor radial function: f(x) = 1/sqrt(2*pi)*[1/sigma1*exp-(x^2/2*sigma1^2) - 1/sigma2*exp-(x^2/2*sigma2^2)] |
| CDotCmp | Use dot product of 2 same-size images to do the comparison |
| CDSym | An encapsulation of dihedral 3D symmetry |
| CE2Exception | E2Exception class is the parent class of all EMAN2 E2Exceptions |
| CEerIO | |
| CEMAN1Ctf | EMAN1Ctf is the CTF model used in EMAN1 |
| CEMAN2Ctf | EMAN2Ctf is the default CTF model used in EMAN2 |
| CEmanOrientationGenerator | EmanOrientationGenerator generates orientations quasi-evenly distributed in the asymmetric unit |
| CEMBytes | |
| CEMConsts | |
| ►CEMData | EMData stores an image's data and defines core image processing routines |
| CClipInplaceVariables | |
| ►CEMFTGL | EMFTGL is an interface for rendering fonts in EMAN2 using FTGL |
| CEMFTGLFontInstance | A class for encapsulatiing a particular instance of an FTFont (pointer) Each FTFont is characterised by 5 parameters, them being the font mode, the font file name, the face size, whether or not display lists are being used, and depth (which is redundant, except when the font mode is EXTRUDE) |
| CEMFTGLManager | A class for managing multiple instances of EMFTGLFontInstances, in particular for caching them, for constructing news ones if they don't exist, and for returning appropriate instances |
| ►CEmIO | EmIO defines I/O operations on EM image format |
| CEMHeader | |
| CEMObject | EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType |
| CEMUtil | |
| CEnhanceProcessor | This processor filters an image to improve the visibility of particles |
| CEvenOrientationGenerator | Sparx even orientation generator - see util_sparx.cpp - Util::even_angles(...) This orientation generator is based on work presented in Penczek et al., 1994 P.A |
| CExpProcessor | F(x) = exp( x / low - high) |
| CFactory | Factory is used to store objects to create new instances |
| CFactoryBase | A class one may inherit from to ensure that the responsibilities of being incorporated into an EMAN2::Factory are met |
| CFFTConeProcessor | Mask out (or in) peaks in Fourier space based on the average amplitude at each spatial frequency |
| CFFTPeakProcessor | Mask out (or in) peaks in Fourier space based on the average amplitude at each spatial frequency |
| CFFTProcessor | Perform a FFT transform by calling EMData::do_fft() and EMData::do_ift() |
| CFFTResampleProcessor | 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 |
| CFFTWedgeProcessor | Mask out (or in) peaks in Fourier space based on the average amplitude at each spatial frequency |
| Cfile_store | |
| CFileFourierProcessor | A fourier processor specified in a 2 column text file |
| CFiniteProcessor | F(x) = f(x) if f(x) is finite | to if f(x) is not finite |
| CFitsIO | MRC file = header + data (nx x ny x nz) |
| CFixSignProcessor | This processor can be used to correct errors when reading signed data as unsigned and vice-versa |
| CFlattenBackgroundProcessor | Flattens the background by subtracting the local mean |
| CFlipProcessor | Flip/mirror an image around an axis |
| CFloatPoint | FloatPoint defines a float-coordinate point in a 1D/2D/3D space |
| CFloatSize | FloatSize is used to describe a 1D, 2D or 3D rectangular size in floating numbers |
| CFloorValueProcessor | F(x) = floor(x) |
| CFourierAnlProcessor | 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) |
| CFourierGriddingProjector | Fourier gridding projection routine |
| CFourierInserter3DMode1 | FourierPixelInserter3DMode1 - encapsulates "method 1" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode10 | FourierPixelInserter3DMode10 - encapsulates "method 10" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode11 | FourierPixelInserter3DMode7 - encapsulates "method 7" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode2 | FourierPixelInserter3DMode2 - encapsulates "method 2" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode2l | FourierPixelInserter3DMode2l - trilinear 2x2x2 inserter See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode3 | FourierPixelInserter3DMode3 - encapsulates "method 3" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode5 | FourierPixelInserter3DMode5 - encapsulates "method 5" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode6 | FourierPixelInserter3DMode6 - encapsulates "method 6" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode7 | FourierPixelInserter3DMode7 - encapsulates "method 7" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode8 | FourierPixelInserter3DMode8 - encapsulates "method 8" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierInserter3DMode9 | FourierPixelInserter3DMode9 - encapsulates "method 9" for inserting a 2D Fourier slice into a 3D volume See comments in FourierPixelInserter3D for explanations |
| CFourierIterReconstructor | 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 |
| CFourierPixelInserter3D | 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 |
| CFourierProcessor | Base class for Fourier filters |
| CFourierReconstructor | 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 |
| CFourierReconstructorSimple2D | This class originally added for 2D experimentation and prototying |
| CFourierToCenterProcessor | 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 |
| CFourierToCornerProcessor | Undo the effects of the FourierToCenterProcessor |
| CFourierWeightAverager | FourierWeightAverager makes an average of a set of images in Fourier space using a per-image radial weight |
| CFRCCmp | FRCCmp returns a quality factor based on FRC between images |
| CFRM2DAligner | |
| CFSCFourierProcessor | This processor will apply a Wiener filter to a volume based on a provided FSC curve |
| ►CGatan2IO | Gatan2 Image file = header + data |
| CGatan2Header | |
| CGaussFFTProjector | Gaussian FFT 3D projection |
| CGaussSegmentProcessor | Segment a volume by sequentially finding the highest peak and subtracting a Gaussian at that point from the density after strongly filtering the map to a specified resolvability |
| CGaussZFourierProcessor | Zeroes the values on the X=0 and y=0 Fourier axes (except x=y=0) |
| CGLUtil | |
| CGradientDirectionProcessor | Determines the direction of an approximate image gradient using David's image gradient processors |
| CGradientMagnitudeProcessor | Determines the magnitude of an approximate image gradient using David's image gradient processors |
| CGradientPlaneRemoverProcessor | Gradient removed by least square plane fit |
| CGradientRemoverProcessor | Gradient remover, does a rough plane fit to find linear gradients |
| CGridKernelFixProcessor | 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 |
| CGrowSkeletonProcessor | Grow a skeleton map toward a local direction |
| CHarmonicProcessor | This processor computes what I've dubbed the 'harmonic power spectrum' |
| CHighpassAutoPeakProcessor | This processor attempts to remove the low resolution peak present in all cryoEM data |
| CHistogramBin | Bins pixel values, similar to calculating a histogram |
| CHSym | An encapsulation of helical 3D symmetry |
| CIcosahedral2Sym | An encapsulation of icosahedral symmetry 222 |
| CIcosahedralSym | An encapsulation of icosahedral symmetry Doctor Phil has this to say about icosahedral symmetry: "Each Platonic Solid has 2E symmetry elements |
| ►CIcosIO | ICOS file = header + data |
| CIcosHeader | |
| CImageAverager | ImageAverager averages a list of images |
| CImageDivergenceProcessor | Computes the image divergence using David's partial derivative processors |
| CImageIO | ImageIO classes are designed for reading/writing various electron micrography image formats, including MRC, IMAGIC, SPIDER, PIF, etc |
| CImageProcessor | |
| CImageScore | |
| CImageSort | |
| ►CImagicIO | IMAGIC-5 Header File Format |
| CImagicHeader | |
| ►CImagicIO2 | IMAGIC-5 Header File Format |
| CImagic4D | IMAGIC-4D file format http://www.imagescience.de/formats/formats.htm |
| CIndexMaskFileProcessor | Multiplies the image by the specified file using pixel indices |
| CInertiaMatrixAnalyzer | Inertia Matrix computer Computes the Inertia Matrix for a 3-D volume |
| CInterp | Interp defines the interpolation function used to generate a e^-x^4 function in real space |
| CIntPoint | IntPoint defines an integer-coordinate point in a 1D/2D/3D space |
| CIntSize | IntSize is used to describe a 1D, 2D or 3D rectangular size in integers |
| CIntTranslateProcessor | Translate the image an integer amount Uses EMData::clip_inplace (inplace) and EMData::get_clip (out of place) to do the translation |
| CIsosurface | |
| CIterAverager | IterAverager performs iterative averaging of 3x3 pixel zones around each pixel, computing the mean of the 9 pixels initially, then iteratively refining the average to produce something self-consistent, but hopefully less noisy |
| CIterBinMaskProcessor | 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 |
| CIterMultiMaskProcessor | This expands a multilevel mask volume so inter-mask boundaries are preserved |
| CKMeansAnalyzer | KMeansAnalyzer Performs k-means classification on a set of input images (shape/size arbitrary) returned result is a set of classification vectors |
| CKmeansSegmentProcessor | Segment a volume into ~n subvolumes using K-means classification |
| CLaplacianDirectionProcessor | Determines the direction of an approximate image laplacian using David's image gradient processors |
| CLaplacianMagnitudeProcessor | Determines the direction of an approximate image laplacian using David's image gradient processors |
| CLaplacianProcessor | Discrete approximation to Laplacian |
| CLinearPyramidProcessor | 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 |
| CLinearRampFourierProcessor | |
| CLinearRampProcessor | Processor radial function: f(x) = slope * x + intercept |
| CLinearXformProcessor | Linear transform processor: f(x) = x * scale + shift |
| CLocalMinAbsProcessor | |
| CLocalNormProcessor | 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 |
| CLocalWeightAverager | LocalWeightAverager makes an average of a set of images in Fourier space using a per-image radial weight |
| CLodCmp | |
| CLog | Log defines a way to output logging information |
| CLoGFourierProcessor | Processor radial function: f(x) = ((x^2 - s^2)/s^4)e^-(x^2/2s^2) |
| CLogProcessor | F(x) = log10(x) if x > 0; else f(x) = 0 |
| CLowpassAutoBProcessor | Processor radial function: if lowpass > 0, f(x) = exp(-x*x/(lowpass*lowpass)); else f(x) = exp(x*x/(lowpass*lowpass)) |
| CLowpassRandomPhaseProcessor | Lowpass Phase Randomization processor applied in Fourier space |
| CLstFastIO | A LSX file is a high performance ASCII file that contains a list of image numbers and file names |
| CLstIO | A LST file is an ASCII file that contains a list of image file names |
| CMakeRadiusProcessor | Overwrites input, f(x) = radius |
| CMakeRadiusSquaredProcessor | Overwrites input, f(x) = radius * radius |
| CManhattanDistanceProcessor | Sets pixel values in a binary image equal to their element wise manhattan distance |
| CMarchingCubes | |
| CMaskAzProcessor | MaskAzProcessor masks out pixels within a specified cylindrical (or circular) arc |
| CMaskEdgeMeanProcessor | A step cutoff to the the mean value in a ring centered on the outer radius |
| CMaskGaussInvProcessor | F(x) = f(x) / exp(-radius*radius * gauss_width / (ny*ny)) |
| CMaskGaussNonuniformProcessor | Gaussian falloff to zero, with anisotropic widths along x,y,z |
| CMaskGaussProcessor | Gaussian falloff to zero, radius is the 1/e of the width |
| CMaskNoiseProcessor | Fills masked region |
| CMaskPackProcessor | This processor will take a mask and extract the values inside the mask as a new 1-D image as well as performing the inverse operation |
| CMaskSharpProcessor | Step cutoff to a user-given value in both inner and outer circles |
| CMaskSoftProcessor | Step cutoff to a user-given value in both inner and outer circles |
| CMatchSFProcessor | Sets the structure factor To match a second provided image/volume |
| CMatrix3 | |
| CMatrix4 | |
| CMaxPixelOperator | |
| ►CMaxShrinkProcessor | 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 |
| CGreaterThan | |
| CMaxValProjector | Real-space projection which computes the maximum value along each line projection rather than a sum |
| CMeanShrinkProcessor | MeanShrinkProcessor shrinks an image by in an integer amount (and optionally by 1.5) taking the mean of the pixel neighbourhood |
| CMeanZeroEdgeProcessor | Fill zeroes at edges with nearest horizontal/vertical value damped towards Mean2 |
| CMedianAverager | MedianAverager averages a list of images to the maximum(or minimum of the absolute pixel value) It optionally makes a sigma image |
| CMedianShrinkProcessor | MeanShrinkProcessor shrinks an image by in an integer amount taking the median of the pixel neighbourhood |
| CMinMaxAverager | ImageAverager averages a list of images |
| CMinPixelOperator | |
| ►CMinShrinkProcessor | 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 |
| CLessThan | |
| CMinusPeakProcessor | Peak processor: pixel = pixel - max of values surrounding pixel |
| CModelEMCylinderProcessor | |
| CModelHelixProcessor | |
| CMorphologicalProcessor | |
| ►CMrcIO | MRC file = header + data (nx x ny x nz) |
| CFeiMrcExtHeader | The extended header used by Fei MRC image |
| CFeiMrcHeader | Extended MRC format for tomography As used by Fei; original definition of extended header by Dave Agard and Bram Koster Contact Dustin Morado Dusti.nosp@m.n.Mo.nosp@m.rado@.nosp@m.uth..nosp@m.tmc.e.nosp@m.du for details |
| CMrcHeader | |
| Cnewfile_store | |
| Cnn4_ctf_rectReconstructor | Nn4_ctf_rectDirect Fourier Inversion Reconstructor |
| Cnn4_ctfReconstructor | Nn4_ctf Direct Fourier Inversion Reconstructor |
| Cnn4_ctfwReconstructor | Nn4_ctfw Direct Fourier Weighted Inversion Reconstructor |
| Cnn4_ctfwsReconstructor | Nn4_ctfws Direct Fourier Weighted Inversion Reconstructor for sorting |
| Cnn4_rectReconstructor | Direct Fourier inversion Reconstructor for extremly rectangular object |
| Cnn4Reconstructor | |
| CnnSSNR_ctfReconstructor | |
| CnnSSNR_Reconstructor | |
| CNonConvexProcessor | Make a curve or surface non-convex (planar or concave), iteratively |
| CNormalizeByMassProcessor | Normalize the mass of the image assuming a density of 1.35 g/ml (0.81 Da/A^3) |
| CNormalizeCircleMeanProcessor | Normalizes an image, mean value equals to mean of 2 pixel circular border |
| CNormalizeEdgeMeanProcessor | Normalizes an image, mean value equals to edge mean |
| CNormalizeHistPeakProcessor | Normalize such that the estimated histogram peak value is zero |
| CNormalizeLREdgeMeanProcessor | Normalizes an image, uses 2 pixels on left and right edge |
| CNormalizeMaskProcessor | Uses a 1/0 mask defining a region to use for the zero-normalization.if no_sigma is 1, standard deviation not modified |
| CNormalizeMaxMinProcessor | Normalizes an image |
| CNormalizeProcessor | Base class for normalization processors |
| CNormalizeRampNormVar | Normalize the image whilst also removing any ramps |
| CNormalizeRowProcessor | Normalizes each row in the image individually |
| CNormalizeStdProcessor | Do a standard normalization on an image |
| CNormalizeToLeastSquareProcessor | Use least square method to normalize |
| CNormalizeUnitProcessor | Normalize an image so its vector length is 1.0 |
| CNormalizeUnitSumProcessor | Normalize an image so its elements sum to 1.0 (fails if mean=0) |
| CNSigmaClampingProcessor | This function clamps the min and max vals in the image at minval and maxval at mean-n*sigma and mean+n*sigma, respectively |
| CObjDensityProcessor | Replace the value of each pixel with the sum of density of the object it belongs to |
| CObjLabelProcessor | Label each object in a black-white image |
| COctahedralSym | An encapsulation of octahedral symmetry Doctor Phil has this to say about the octahedral symmetry: "Each Platonic Solid has 2E symmetry elements |
| ►COmapIO | DSN6 MAP is composed of a series of records which are all 512 bytes long |
| COmapHeader | The data in the header is composed of 256 short integers |
| COptimumOrientationGenerator | Optimum orientation generator |
| COptSubCmp | Uses math.sub.optimal to remove the density of the reference from the image as much as possible |
| COptVarianceCmp | Variance between two data sets after various modifications |
| COrientationGenerator | 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 |
| COutlierProcessor | This processor will try and remove outliers (and optionally exactly zero values), replacing any identified values with the local mean value |
| CPaintProcessor | Multiplies the image by the specified file using pixel coordinates instead of pixel indices |
| ►CPawelProjector | Pawel Penczek's optimized projection routine |
| CIPCube | |
| CPDBReader | PointArray defines a double array of points with values in a 3D space |
| CPeakOnlyProcessor | Peak processor -> if npeaks or more surrounding values >= value, value->0 |
| CPgmIO | A PGM file = header + data |
| CPhase180Processor | This class is abstract |
| CPhaseCmp | Amplitude weighted mean phase difference (radians) with optional SNR weight |
| CPhaseToCenterProcessor | Translates a cornered image to the center Undoes the PhaseToCornerProcessor |
| CPhaseToCornerProcessor | Translates a centered image to the corner works for 1D, 2D and 3D images, for all combinations of even and oddness |
| CPhaseToMassCenterProcessor | ToMassCenterProcessor centers image at center of mass, ignores old dx, dy |
| ►CPifIO | PIF(Portable Image Format for EM Data) is an image format from Purdue University |
| CPifColorMap | |
| CPifFileHeader | |
| CPifImageHeader | |
| CPixel | Pixel describes a 3D pixel's coordinates and its intensity value |
| CPlatonicSym | A base (or parent) class for the Platonic symmetries |
| CPoint3 | |
| Cpoint_t | |
| CPointArray | PointArray defines a double array of points with values in a 3D space |
| CPolarData | Specialized image class for storing the results of a transform from EMData to polar coordinates, currently support 2D only |
| CPolyMaskProcessor | |
| CPriorityQueue | Template class for a priority queue |
| CProcessor | Typical usage of Processors are as follows: |
| CProjector | Projector class defines a method to generate 2D projections from a 3D model |
| CPruneSkeletonProcessor | Prune branches from the skeleton |
| CQuadMinDotCmp | This will calculate the dot product for each quadrant of the image and return the worst value |
| CQuaternion | Quaternion is used in Rotation and Transformation to replace Euler angles |
| CRadialProcessor | Perform a multiplication of real image with a radial table |
| CRampProcessor | Ramp processor – Fits a least-squares plane to the picture, and subtracts the plane from the picture |
| CRandnum | The wrapper class for gsl's random number generater |
| CRandomOrientationGenerator | Random Orientation Generator - carefully generates uniformly random orientations in any asymmetric unit |
| CRangeThresholdProcessor | F(x) = 1 if (low <= x <= high); else f(x) = 0 |
| CRangeZeroProcessor | Set any values in a range to zero |
| CRealMedianReconstructor | Real space 3D reconstruction using per-voxel median |
| CRealPixelProcessor | The base class for real space processor working on individual pixels |
| CRealToFFTProcessor | This will replace the image with a full-circle 2D fft amplitude rendering |
| CRecipCarefullyProcessor | Reciprocal image as if f(x) != 0: f(x) = 1/f(x) else: f(x) = zero_to |
| CReconstructor | Reconstructor class defines a way to do 3D recontruction |
| CReconstructorVolumeData | This is a Mixin class A class object encapsulating the volume data required by Reconstructors It basically stores two (pointers) to EMData objects and stores the dimensions of the image volume |
| CRefine3DAlignerGrid | Refine alignment |
| CRefine3DAlignerQuaternion | Refine alignment |
| CRefineAligner | Refine alignment |
| CRefineAlignerCG | Conjugate gradient refine alignment |
| CRegion | Region defines a 2D or 3D rectangular region specified by its origin coordinates and all edges' sizes |
| CReplaceValuefromListProcessor | Replace the value of each pixel with a value in a given array |
| CReverseProcessor | Mirror an image around an axis (reverse pixels) |
| CRotate180Processor | Rotate by 180 using pixel swapping, works for 2D only |
| CRotateFlipAligner | Rotational and flip alignment |
| CRotateFlipAlignerIterative | Rotational and flip alignment, iterative style |
| CRotateInFSProcessor | |
| CRotatePrecenterAligner | Rotational alignment assuming centers are correct |
| CRotateTranslateAligner | Rotational, translational alignment |
| CRotateTranslateAlignerBispec | Rotational, translational alignment |
| CRotateTranslateAlignerIterative | Iterative rotational, translational alignment |
| CRotateTranslateAlignerPawel | Rotational, translational alignment by resampling to polar coordinates |
| CRotateTranslateBestAligner | Rotational, translational alignment |
| CRotateTranslateFlipAligner | Rotational, translational and flip alignment |
| CRotateTranslateFlipAlignerIterative | Rotational, translational and flip alignment, iterative style |
| CRotateTranslateFlipAlignerPawel | Rotational, translational alignment by resampling to polar coordinates |
| CRotateTranslateFlipScaleAligner | Rotational, translational, flip, scaling alignment |
| CRotateTranslateFlipScaleAlignerIterative | Iterative rotational, translational alignment with flipping and scaling |
| CRotateTranslateScaleAligner | Rotational, translational, scaling alignment |
| CRotateTranslateScaleAlignerIterative | Iterative rotational, translational alignment with scaling |
| CRotationalAligner | Rotational alignment using angular correlation |
| CRotationalAlignerBispec | Rotational alignment using invariants |
| CRotationalAlignerIterative | Rotational alignment using the iterative method (in this case we only do one iteration b/c we are not doing a translation |
| CRotationalAverageProcessor | Makes image circularly symmetric |
| CRotationalSubstractProcessor | Subtracts circularly symmetric part of an image |
| CRT2Dto3DTreeAligner | Alignment of a 2D image into a 3D volume using a hierarchical method with gradually decreasing downsampling in Fourier space |
| CRT2DTreeAligner | 2D rotational and translational alignment using a hierarchical method with gradually decreasing downsampling in Fourier space |
| CRT3DGridAligner | 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) |
| CRT3DLocalTreeAligner | 3D rotational and translational alignment using a hierarchical method with gradually decreasing downsampling in Fourier space |
| CRT3DSphereAligner | 3D rotational and translational alignment using spherical sampling, can reduce the search space based on symmetry |
| CRT3DSymmetryAligner | 3D rotational symmetry aligner |
| CRT3DTreeAligner | 3D rotational and translational alignment using a hierarchical method with gradually decreasing downsampling in Fourier space |
| CRTFExhaustiveAligner | Rotational, translational and flip alignment using real-space methods |
| CRTFSlowExhaustiveAligner | Rotational, translational and flip alignment using exhaustive search |
| CSaffOrientationGenerator | Saff orientation generator - based on the work of Saff and Kuijlaars, 1997 E.B |
| CSalIO | A SAL image is an image from Perkin Elmer PDS Microdensitometer |
| CScaleAligner | Scale aligner |
| CScaleAlignerABS | This is an ABS for use in constructing, rt_scale, rt_flip, etc scale aligners |
| CScaleTransformProcessor | Scale the image with control over the output dimensions |
| CScreenPoint | |
| CScreenVector | |
| CSDGDProcessor | Determines the second derivative in the gradient direction using David's image gradient processors |
| CSegmentSubunitProcessor | This tries to extract a single subunit from a symmetric structure |
| ►CSerIO | SER (Series File Format) is a file format created by Dr |
| CSerHeader | |
| CSetBitsProcessor | |
| CSetIsoPowProcessor | Makes the radial power distribution spherically symmetric with a profile defined by "strucfac" |
| CSetSFProcessor | Sets the structure factor based on a 1D s/intensity curve as an XYData object |
| CShapeAnalyzer | Shape characterization Computes a set of values characteristic of the shape of a volume |
| CSigmaAverager | SigmaAverager averages a list of images |
| CSigmaProcessor | F(x) = mean if x<(mean-v2*sigma) or x>(mean+v1*sigma); else f(x) = x; |
| CSigmaZeroEdgeProcessor | Fill zeroes at edges with nearest horizontal/vertical value |
| CSingleOrientationGenerator | SingleOrientationGenerator generates a single orientation with the specified EMAN-style Euler angles |
| CSingleSpiderIO | Single Spider Image I/O class |
| CSitusIO | Situs is a a Situs-specific format on a cubic lattice |
| CSmartMaskProcessor | Smart mask processor |
| CSNREvalProcessor | Evaluate individual particle images using a tenchique similar to that used for CTF evaluation |
| CSNRProcessor | 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 |
| ►CSpiderIO | SPIDER: (System for Processing Image Data from Electron microscopy and Related fields) is an image processing system for electron microscopy |
| CSpiderHeader | |
| CSqEuclideanCmp | Squared Euclidean distance normalized by n between 'this' and 'with' |
| CStandardProjector | Fast real-space 3D projection |
| CStripeXYProcessor | This processor will remove localized 'striping' along the x/y axes, caused by issues with CCD/CMOS readout |
| CSubtractOptProcessor | Sorry for the pun |
| CSVDAnalyzer | Singular Value Decomposition from GSL |
| CSymAlignProcessor | Aligns a particle with the specified symmetry into the standard orientation for that symmetry |
| CSymAlignProcessorQuat | Aligns a particle with a specified symetry to its symmetry axis using the simplex multidimensional minimization algorithm |
| CSymmetry3D | Symmetry3D - A base class for 3D Symmetry objects |
| CSymSearchProcessor | Identifiy the best symmetry in the given symmetry list for each pixel and then apply the best symmetry to each pixel |
| CTestImageAxes | Make an image consisting of a single cross, with lines going in the axial directions, intersecting at the origin |
| CTestImageCirclesphere | Replace a source image as a circle or sphere depends on 2D or 3D of the source image |
| CTestImageCylinder | Replace a source image with a cylinder |
| CTestImageDisc | Replace source image with a disc (generalized cylinder) |
| CTestImageEllipse | Generate an ellipse or ellipsoid image |
| CTestImageFourierGaussianBand | Replace a source image with a Gaussian band in Fourier space with a given center and width |
| CTestImageFourierNoiseGaussian | Replace a source image as a strict Gaussian |
| CTestImageFourierNoiseProfile | |
| CTestImageGaussian | Replace a source image as a Gaussian Blob |
| CTestImageGradient | Put a gradient in the image of the form y = mx+b : "x" is a string indicating any of the image axes, i.e., x,y or z |
| CTestImageHollowEllipse | Generate an ellipse/ellipsoid image with an inner hollow ellipse/ellipsoid |
| CTestImageLineWave | 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) |
| CTestImageNoiseGauss | 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) |
| CTestImageNoiseUniformRand | 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) |
| CTestImageProcessor | Base class for a group of 'processor' used to create test image |
| CTestImagePureGaussian | Replace a source image as a strict Gaussian |
| CTestImageScurve | Replace a source image with a lumpy S-curve used for alignment testing |
| CTestImageSinewave | Replace a source image as a sine wave in specified wave length |
| CTestImageSinewaveCircular | Replace a source image as a circular sine wave in specified wave length |
| CTestImageSphericalWave | Replace a source image as a sine wave in specified wave length |
| CTestImageSquarecube | Replace a source image as a square or cube depends on 2D or 3D of the source image |
| CTestTomoImage | 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" |
| CTestUtil | |
| CTetrahedralSym | An encapsulation of tetrahedral symmetry Doctor Phil has this to say about tetrahedral symmetry: " Each Platonic Solid has 2E symmetry elements |
| CToCenterProcessor | ToCenterProcessor centers image, ignores old dx, dy |
| CToMassCenterProcessor | ToMassCenterProcessor centers image at center of mass, ignores old dx, dy |
| CToMinvalProcessor | F(x) = x if x >= minval; f(x) = minval if x < minval |
| CTomoAverager | TomoAverager averages a list of volumes in Fourier space |
| CTomoCccCmp | This implements the technique of Mike Schmid where by the cross correlation is normalized in an effort to remove the effects of the missing wedge |
| CTomoFscCmp | This is a FSC comparitor for tomography |
| CTomoObject | |
| CTomoSeg | |
| CTomoTiltAngleWeightProcessor | 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 |
| ►CTomoTiltEdgeMaskProcessor | A processor designed specifically for tomographic tilt series data |
| CGaussianFunctoid | |
| CTomoWedgeCccCmp | Both images should be FFTs |
| CTomoWedgeFscCmp | Both images should be FFTs |
| CToZeroProcessor | F(x) = x if x >= minval; f(x) = 0 if x < minval |
| CTransform | A Transform object is a somewhat specialized object designed specifically for EMAN2/Sparx storage of alignment parameters and euler orientations |
| CTransformProcessor | Transform the image using a Transform object |
| CTranslationalAligner | Translational 2D Alignment using cross correlation |
| CTransposeProcessor | Transpose a 2D image |
| CTypeDict | TypeDict is a dictionary to store <string, EMObject::ObjectType> pair |
| CU3DWriter | A work in progress by David Woolford |
| ►CUnevenMatrix | General data structure for a matrix with variable x dim size for different y |
| CXdim | Struct to define x dimension size for each y, x0 is inclusive, x1 is one after the maximum, [x0, x1), so the corresponding x dim size is (x1-x0) |
| CUtil | Util is a collection of utility functions |
| CV4L2IO | Read-only |
| CValuePowProcessor | Do a math power operation on image, f(x) = x ^ pow; |
| CValueSqrtProcessor | F(x) = sqrt(x) |
| CValueSquaredProcessor | Do a square operation on image, f(x) = x * x; |
| CVec2 | 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 |
| CVec3 | The Vec3 object is a templated object, intended to instantiated with basic types such as int, float, double etc |
| CVec4 | The Vec4 object is a templated object, intended to instantiated with basic types such as int, float, double etc |
| CVector3 | |
| CVector4 | |
| CVerticalCmp | |
| CVerticalStripeProcessor | Tries to fix images scanned on the zeiss for poor ccd normalization |
| CVtkIO | VtkIO reads/writes VTK image file |
| CWatershedProcessor | '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 |
| CWaveletProcessor | Perform a Wavelet transform using GSL |
| CWedgeFillProcessor | Fill missing wedge with information from another image |
| CWiener2DAutoAreaProcessor | 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 |
| CWiener2DFourierProcessor | Wiener filter based on a Ctf object either in the image header |
| CWienerFourierReconstructor | Fourier space 3D reconstruction This is a modified version of the normal FourierReconstructor which is aware of the SSNR information stored in individual class-average headers as "ctf_snr_total" and "ctf_wiener_filtered" |
| CXGradientProcessor | Determines the partial derivatives in the x direction Does this by constructing edge kernels in real space but convoluting in Fourier space |
| CXplorIO | XPLOR image format is in ASCII: |
| ►CXYData | XYData defines a 1D (x,y) data set |
| CPair | |
| CXYZAligner | XYZAligner is an aligner template for defining new aligners |
| CXYZAverager | XYZAverager is an averager template for defining new averagers |
| CXYZCmp | XYZCmp is a cmp template for defining new cmps |
| CXYZIO | XYZIO is a sample Image IO class |
| CXYZProcessor | XYZProcessor is a processor template for defining new processors |
| CXYZProjector | XYZProjector is an projector template for defining new projectors |
| CXYZReconstructor | XYZReconstructor is a reconstructor template for defining new reconstructors |
| CYGradientProcessor | |
| CZeroConstantProcessor | Contraction of data, if any nearest neighbor is 0, value -> 0, generally used iteratively |
| CZeroEdgePlaneProcessor | Zero edges of volume on all sides |
| CZeroEdgeRowProcessor | Zero edges of image on top and bottom, and on left and right |
| CZGradientProcessor | |
| CZThicknessProcessor | Calculate the z thickness of each pixel in a binarized 3d image |
| ►Nwustl_mm | |
| ►NGraySkeletonCPP | |
| CVolumeSkeletonizer | |
| ►NSkeletonMaker | |
| CgridPoint | |
| CGridQueue | |
| CGridQueue2 | |
| CgridQueueEle | |
| CVolume | |
| CVolumeData | |
| CBPKT | |
| Cctf_store_real | |
| CCudaPeakInfo | |
| CCudaPeakInfoFloat | |
| CEMDataForCuda | A struct for passing EMData objects to and from things like processors |
| CWSsortlist | |
