Detailed Description

This module provides functionality to use two-dimensional EM images as restraints.

The overview section of the module page can contain any doxygen markup as well as references to IMP classes such as IMP::Model. See the doxygen web site for a full description of what can be done in doxygen.

Remember to escape characters to keep python happy.

Examples:

Author(s): J. Velazquez-Muriel, D. Russel

Version: SVN.r14091 with OpenCV21

License: LGPL. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Publications:

Daniel Russel, Keren Lasker, Ben Webb, Dina Schneidman, Javier Velázquez-Muriel, Andrej Sali, “Putting the pieces together: integrative structure determination of macromolecular assemblies”, PLoS Biology, 2012. This paper provides an overview of the key concepts in IMP and how to apply them to biological problems.
Frank Alber, Friedrich Foerster, Dmitry Korkin, Maya Topf, Andrej Sali, “Integrating diverse data for structure determination of macromolecular assemblies”, Annual Review of Biochemistry, 2008. This paper provides a review of the integrative structure determination methodology and various data sources that can be used.
Some Person, Someone Else, “A silly title of no paper”, Dev Null, 2051.
IMP

Classes
class	ALIGN2D_PREPROCESSING
class	CenteredMat
class	ChiSquaredScore
	Score based on Chi^2 = ((pixels_iamge - pixels_projection)/stddev_image)^2. More...
class	DistanceFilterTable
class	DummyRestraint
	Dummy restraint between two particles. More...
class	Em2DRestraint
class	EM2DScore
class	Fine2DRegistrationRestraint
class	GridStates
class	HasHigherCCC
	Comparison by value of the ccc. More...
class	HasLowerScore
	Compare two classes that return a score. More...
class	Image
	2D Electron Microscopy images in IMP More...
class	JPGImageReaderWriter
	Class to read and write EM images in JPG format. More...
class	LessPairBySecond
	Comparison of pairs by checking the second element. More...
class	MasksManager
	Manage of projection masks. More...
class	MatchTemplateResult
class	ParticlesDummyRestraint
	Dummy restraint for a set of particles. Same use as DummyRestraint. More...
class	PolarResamplingParameters
class	ProjectionFinder
	class to perform registration of model projections to images images More...
class	ProjectionMask
class	ProjectionParameters
class	ProjectionParametersScoreState
class	ProjectionStates
class	RegistrationResult
	Class to manage registration results. More...
class	ScoreFunction
	Base class for all scoring functions related to em2d. More...
class	SegmentationParameters
	Class to provide all the parameters to the segmentation function. More...
class	SpiderImageReaderWriter

Typedefs
typedef cv::MatConstIterator_ < double >	cvDoubleConstMatIterator
typedef cv::Mat_< double >	cvDoubleMat
typedef cv::MatIterator_< double >	cvDoubleMatIterator
typedef cv::Mat_< int >	cvIntMat
typedef cv::MatIterator_< int >	cvIntMatIterator
typedef cv::Point_< int >	cvPixel
typedef std::vector< cvPixel >	cvPixels
typedef std::map< Ints, unsigned int, IntsOrder >	KeyIndexMap
typedef std::vector< KeyIndexMap >	KeyIndexMaps
typedef std::pair< Ints, unsigned int >	KeyIndexPair
typedef std::list < pair_cluster_id_distance >	list_cluster_id_distance
typedef boost::shared_ptr < MasksManager >	MasksManagerPtr
typedef std::pair< unsigned int,double >	pair_cluster_id_distance
typedef boost::shared_ptr < ProjectionMask >	ProjectionMaskPtr
typedef std::pair < algebra::Transformation2D, double >	ResultAlign2D
typedef std::vector < algebra::Transformation3Ds >	Transformation3DsList
typedef FloatsList	VectorOfFloats
typedef IntsList	VectorOfInts

Functions
void	add_noise (Image *im1, double op1, double op2, const String &mode="uniform", double df=3)
void	add_noise (cv::Mat &v, double op1, double op2, const String &mode="uniform", double df=3)
	Add noise to the values of a matrix.
void	apply_circular_mask (const cv::Mat &mat, cv::Mat &result, int radius, double mask=0.0)
void	apply_diffusion_filter (Image input, Image filtered, double beta, double pixelsize, int time_steps)
void	apply_diffusion_filter (const cv::Mat &m, cv::Mat &result, double beta, double pixelsize, unsigned int time_steps)
void	apply_mask (const cv::Mat &m, cv::Mat &result, const cvIntMat &mask, double val)
	Applies a binary mask to an image.
void	apply_threshold (cv::Mat &m, cv::Mat &result, double threshold=0.0)
void	apply_variance_filter (Image input, Image filtered, int kernelsize)
void	apply_variance_filter (const cv::Mat &input, cv::Mat &filtered, int kernelsize)
Images	create_evenly_distributed_projections (const ParticlesTemp &ps, unsigned int n, const ProjectingOptions &options)
Strings	create_filenames (unsigned long number, String basic_name, String extension)
void	do_combined_fill_holes_and_threshold (Image input, Image result, double n_stddevs)
void	do_combined_fill_holes_and_threshold (cv::Mat &m, cv::Mat &result, double n_stddevs, double threshold=0.0)
	Combines the fill holes and tresholding operations together with normalize.
void	do_dilate_and_shrink_warp (cv::Mat &m, const cv::Mat &greyscale, cv::Mat &kernel)
	(U. Adiga, 2005)
void	do_extend_borders (Image im1, Image im2, unsigned int pix)
void	do_extend_borders (cv::Mat &orig, cv::Mat &dst, unsigned int pix)
void	do_fill_holes (Image input, Image result, double n_stddevs)
void	do_fill_holes (const cv::Mat &m, cv::Mat &result, double h)
	Fills the holes in the matrix m of height h.
template<class LinkageFunction >
ClusterSet	do_hierarchical_agglomerative_clustering (const FloatsList &distances)
void	do_histogram_stretching (cv::Mat &m, int boxes, int offset)
int	do_labeling (const cvIntMat &m, cvIntMat &mat_to_label)
	Labeling function for a matrix.
void	do_matrix_to_image_flip (cv::Mat &m)
void	do_morphologic_contrast_enhancement (const cv::Mat &m, cv::Mat &result, const cv::Mat &kernel, unsigned int iterations)
void	do_morphologic_reconstruction (const cv::Mat &mask, cv::Mat &marker, int neighbors_mode=4)
	morphologic grayscale reconstruction (L Vincent, 1993)
void	do_normalize (Image *im, bool force=false)
void	do_normalize (cv::Mat &m)
	Normalize a openCV matrix to mean 0 and stddev 1. It is done in place.
void	do_place (cv::Mat &mask, cv::Mat &m, const algebra::Vector2D &v)
void	do_project_particles (const ParticlesTemp &ps, cv::Mat &m2, const algebra::Rotation3D &R, const algebra::Vector3D &translation, const ProjectingOptions &options, MasksManagerPtr masks)
	Projects a set of particles. This is the core function that others call.
algebra::Vector2Ds	do_project_vectors (const algebra::Vector3Ds &ps, const algebra::Rotation3D &R, const algebra::Vector3D &translation)
	Project the points contained in Vector3Ds to gen vectors in 2D.
algebra::Vector2Ds	do_project_vectors (const algebra::Vector3Ds &ps, const algebra::Rotation3D &R, const algebra::Vector3D &translation, const algebra::Vector3D &center)
	Project the points contained in Vector3Ds.
void	do_remove_small_objects (cvIntMat &m, double percentage, int background=0, int foreground=1)
	Removes small objects from a matrix of integers.
void	do_remove_small_objects (Image *input, double percentage, int background=0, int foreground=1)
void	do_resample_polar (Image im1, Image im2, const PolarResamplingParameters &polar_params)
void	do_resample_polar (const cv::Mat &input, cv::Mat &resampled, const PolarResamplingParameters &polar_params)
	Resamples a matrix to polar coordinates.
void	do_segmentation (const cv::Mat &m, cv::Mat &result, const SegmentationParameters &params)
	Segmentation of images.
void	do_segmentation (Image input, Image result, const SegmentationParameters &params)
void	do_subtract_images (Image first, Image second, Image *result)
void	get_autocorrelation2d (const cv::Mat &m, cv::Mat &corr)
	Returns the autocorrelation matrix.
void	get_autocorrelation2d (Image im1, Image im2)
	Autocorrelation image.
void	get_autocorrelation2d_no_preprocessing (const cv::Mat &M, cv::Mat &corr)
	Autocorrelation without preprocessing.
double	get_average_rotation_error (const RegistrationResults &correct_RRs, const RegistrationResults &computed_RRs)
double	get_average_shift_error (const RegistrationResults &correct_RRs, const RegistrationResults &computed_RRs)
MatchTemplateResults	get_best_template_matches (const cv::Mat &m, const cv::Mat &templ, unsigned int n)
ResultAlign2D	get_complete_alignment (const cv::Mat &input, cv::Mat &m_to_align, bool apply=false)
em2d::ResultAlign2D	get_complete_alignment_no_preprocessing (const cv::Mat &input, const cv::Mat &INPUT, const cv::Mat &POLAR1, cv::Mat &m_to_align, const cv::Mat &POLAR2, bool apply=false)
ResultAlign2D	get_complete_alignment_with_centers_no_preprocessing (const algebra::Vector2D &center1, const algebra::Vector2D &center2, const cv::Mat &AUTOC_POLAR1, const cv::Mat &AUTOC_POLAR2)
void	get_correlation2d (const cv::Mat &A, const cv::Mat &B, cv::Mat &corr)
	Correlation matrix between two 2D matrices using FFT.
void	get_correlation2d (Image im1, Image im2, Image *corr)
	Cross correlation between two images.
void	get_correlation2d_no_preprocessing (const cv::Mat &M1, const cv::Mat &M2, cv::Mat &corr)
double	get_cross_correlation_coefficient (const cv::Mat &m1, const cv::Mat &m2)
	Computes the cross-correlation coefficient between to matrices.
double	get_cross_correlation_coefficient (Image im1, Image im2)
	Cross correlation between two images.
void	get_diffusion_filtering_partial_derivative (const cv::Mat &m, cv::Mat &der, double dx, double dy, double ang)
void	get_domes (cv::Mat &m, cv::Mat &result, double h)
	Gets the domes of m with height h.
unsigned int	get_enclosing_image_size (const ParticlesTemp &ps, double pixel_size, unsigned int slack)
RegistrationResults	get_evenly_distributed_registration_results (unsigned int n_projections)
void	get_fft_using_optimal_size (const cv::Mat &m, cv::Mat &M)
double	get_global_score (const RegistrationResults &RRs)
Floats	get_histogram (Image *img, int bins)
Floats	get_histogram (const cv::Mat &m, int bins)
	Computes the histogram of a matrix.
void	get_morphologic_gradient (const cv::Mat &m, cv::Mat &result, const cv::Mat &kernel)
double	get_overlap_percentage (cv::Mat &m1, cv::Mat &m2, const IntPair &center)
void	get_projection (em2d::Image *img, const ParticlesTemp &ps, const RegistrationResult &reg, const ProjectingOptions &options, MasksManagerPtr masks=MasksManagerPtr(), String name="")
	Generates a projection from particles.
em2d::Images	get_projections (const ParticlesTemp &ps, const algebra::SphericalVector3Ds &vs, int rows, int cols, const ProjectingOptions &options, Strings names=Strings())
	Generates projectios from particles.
em2d::Images	get_projections (const ParticlesTemp &ps, const RegistrationResults &registration_values, int rows, int cols, const ProjectingOptions &options, Strings names=Strings())
	Generates projectios from particles.
double	get_random_between_zero_and_one ()
RegistrationResults	get_random_registration_results (unsigned int n, double maximum_shift=5.0)
	Provides a set of random registration results (or parameters)
double	get_rotation_error (const RegistrationResult &rr1, const RegistrationResult &rr2)
em2d::ResultAlign2D	get_rotational_alignment (const cv::Mat &input, cv::Mat &m_to_align, bool apply=false)
ResultAlign2D	get_rotational_alignment_no_preprocessing (const cv::Mat &POLAR1, const cv::Mat &POLAR2)
double	get_shift_error (const RegistrationResult &rr1, const RegistrationResult &rr2)
	Distance between the two in-plane translations.
void	get_spectrum (const cv::Mat &m, cv::Mat &real, cv::Mat &imag)
	Computes the fft of a matrix and returns the real and imaginary matrices.
void	get_transformed (const cv::Mat &input, cv::Mat &transformed, const algebra::Transformation2D &T)
ResultAlign2D	get_translational_alignment (const cv::Mat &input, cv::Mat &m_to_align, bool apply=false)
	Aligns two matrices translationally.
ResultAlign2D	get_translational_alignment_no_preprocessing (const cv::Mat &M1, const cv::Mat &M2)
Ints	get_unique_index (const algebra::Rotation3D &rot)
template<class T >
void	print_vector (const std::vector< T > &v)
Images	read_images (const Strings &names, const ImageReaderWriter *rw)
	A vector of reference counted pointers to EM images of type double.
RegistrationResults	read_registration_results (const String &filename)
	Reads a set of registration results.
Strings	read_selection_file (String fn)
	Reads a selection file.
void	save_images (Images images, const Strings &names, const ImageReaderWriter *rw)
void	show (const cv::Mat &m, std::ostream &out=std::cout)
	Prints a OpenCV matrix.
template<typename T >
void	show (const cv::Mat_< T > &m, std::ostream &out=std::cout)
	Show a Mat_.
void	write_matrix (cv::Mat &m, std::string name)
	Quick and dirty way of writing a OpenCV matrix to a Spider image.
void	write_registration_results (String filename, const RegistrationResults &results)
	Writes a set of registration results.
void	write_vectors_as_pdb (const algebra::Vector2Ds vs, const String filename)

Variables
const unsigned int	ALIGN2D_NO_PREPROCESSING = 0
	Methods for registration used by the finder.
const unsigned int	ALIGN2D_PREPROCESSING = 1
const unsigned int	ALIGN2D_WITH_CENTERS = 2

Typedef Documentation

typedef std::pair<algebra::Transformation2D,double> IMP::em2d::ResultAlign2D

Definition of the result of an alignment. Contains the transformation to apply to the matrix to align and the cross correlation of the solution

typedef std::vector<algebra::Transformation3Ds > IMP::em2d::Transformation3DsList

Class for the movement of rigid bodies respect to each other. The class is initiated with the rigid body that is going to move (let's call it A). Afterwards, one of more rigid bodies can be added as references. Each reference rigid body needs to specify the set of the internal (relative) transformations that A can have respect to it.

Parameters:

[in]

Function Documentation

void IMP::em2d::add_noise	(	cv::Mat &	v,
		double	op1,
		double	op2,
		const String &	mode = `"uniform"`,
		double	df = `3`
	)

Add noise to the values of a matrix.

Supported distributions:

uniform distribution, giving the range (lower, upper). DEFAULT
gaussian distribution, giving the mean and the standard deviation
add_noise(v1,0, 1);

// uniform distribution between 0 and 1

v1.add_noise(0, 1, "uniform");

// the same

v1.add_noise(0, 1, "gaussian");

// gaussian distribution with 0 mean and stddev=1

void IMP::em2d::apply_circular_mask	(	const cv::Mat &	mat,
		cv::Mat &	result,
		int	radius,
		double	mask = `0.0`
	)

Applies a circular to a matrix. The center of the mask is the center of the matrx.

Parameters:

[in] Radius of the mask

void IMP::em2d::apply_diffusion_filter	(	const cv::Mat &	m,
		cv::Mat &	result,
		double	beta,
		double	pixelsize,
		unsigned int	time_steps
	)

Smoothing filter by application of the reaction-diffusion equation of Beltrami flow. Adiga, JSB, 2005

Parameters:

[in] beta contribution of diffusion versus edge enhancement. 0 - pure reaction, 90 - pure diffusion

Note:: The function only works for matrices containing doubles

void IMP::em2d::apply_mask	(	const cv::Mat &	m,
		cv::Mat &	result,
		const cvIntMat &	mask,
		double	val
	)

Applies a binary mask to an image.

Parameters:

[in]	m	Input matrix
[in]	result	matrix with the result
[in]	mask	If the mask is 0, the result has the value of val. Otherwise is the value of m.
[in]	value	value to apply when the mask is 0

void IMP::em2d::apply_threshold	(	cv::Mat &	m,
		cv::Mat &	result,
		double	threshold = `0.0`
	)

Applys a threshold to an image

Parameters:

[in] threshold. all pixels below this value are set to zero

void IMP::em2d::apply_variance_filter	(	const cv::Mat &	input,
		cv::Mat &	filtered,
		int	kernelsize
	)

Variance filter for an image. Computes the variance for each pixel using the surrounding ones.

Parameters:

[in]	input	image with the data
[out]	filtered	matrix result of the filtering with the variances
[in]	kernelsize	The variance is computed using kernelsize x kernelsize pixels around each one. Kernelsize can only be odd.

Images IMP::em2d::create_evenly_distributed_projections	(	const ParticlesTemp &	ps,
		unsigned int	n,
		const ProjectingOptions &	options
	)

This function is slightly different than the other ones. Only generates evenly distributed projections and determines the size of the images that encloses the particles. Should not be used unless this is exactly what you want.

Strings IMP::em2d::create_filenames	(	unsigned long	number,
		String	basic_name,
		String	extension
	)

generates consecutive filenames: basic_name-i.extension Adds zeros at the front of the number when neccessary

void IMP::em2d::do_combined_fill_holes_and_threshold	(	cv::Mat &	m,
		cv::Mat &	result,
		double	n_stddevs,
		double	threshold = `0.0`
	)

Combines the fill holes and tresholding operations together with normalize.

Parameters:

[in]	m	Input matrix
[out]	result	the result matrix
[in]	n_stddevs	Number of standard deviations used to compute the holes
[in]	threshold	Removes values below the threshold value

Note:: The function does normalize -> fill_holes -> normalize -> threshold -> normalize

void IMP::em2d::do_dilate_and_shrink_warp	(	cv::Mat &	m,
		const cv::Mat &	greyscale,
		cv::Mat &	kernel
	)

(U. Adiga, 2005)

Parameters:

[in]	m	binary matrix to dilate and shrink
[in]	greyscale	greyscale matrix that controls the shrinking
[in]	kernel	dilation kernel

Note:: Only tested with binary matrices m with background =0 and foreground = 1

void IMP::em2d::do_extend_borders	(	cv::Mat &	orig,
		cv::Mat &	dst,
		unsigned int	pix
	)

Extends the bordes of an image

Parameters:

[in]	orig	The image to extend
[in]	dst	The image destination
[in]	pix	number of pixels to extend the borders

void IMP::em2d::do_fill_holes	(	const cv::Mat &	m,
		cv::Mat &	result,
		double	h
	)

Fills the holes in the matrix m of height h.

Parameters:

[in]	m	the input matrix
[in]	result	the result matrix
[in]	h	the height

Note:: The function does not work in-place

template<class LinkageFunction >

ClusterSet IMP::em2d::do_hierarchical_agglomerative_clustering ( const FloatsList & distances )

Parameters:

[in]	distances	Vector of Floats containing all the possible distances(i,j) between elements to cluster. Given N elements to cluster, there are N vectors of size N
[in]	Function	to calculate distance between clusters.
[out]	a	ClusterSet class containing all the clustering steps.

int IMP::em2d::do_labeling	(	const cvIntMat &	m,
		cvIntMat &	mat_to_label
	)

Labeling function for a matrix.

Parameters:

[in]	m	binary matrix to scan. The matrix needs to contain zeros and ones but they can be stored as doubles, floats or ints
[out]	result	matrix it is returned as a matrix of ints
[out]	labels	The number of labels in the image

void IMP::em2d::do_matrix_to_image_flip ( cv::Mat & m )

Transforms a matrix as is given by FFT functions, into a image interpretation. Works the opposite way.

void IMP::em2d::do_morphologic_contrast_enhancement	(	const cv::Mat &	m,
		cv::Mat &	result,
		const cv::Mat &	kernel,
		unsigned int	iterations
	)

morphologic enhancement of the contrast This function detects areas in the images and enhances the contrast between them

Parameters:

[in]	m	Imput matrix
[out]	result
[in]	kernel	morphologic kernel to use
[in]	iterations	Higher number, more contrast

void IMP::em2d::do_morphologic_reconstruction	(	const cv::Mat &	mask,
		cv::Mat &	marker,
		int	neighbors_mode = `4`
	)

morphologic grayscale reconstruction (L Vincent, 1993)

Parameters:

[in]	mask	image to reconstruct
[out]	marker	this image contains the initial marker points and will contain the final result
[in]	neighbors_mode	number of neighbors for a pixel to consider when doing the morphologic reconstruction (values: 4, 8).

void IMP::em2d::do_normalize ( cv::Mat & m )

Normalize a openCV matrix to mean 0 and stddev 1. It is done in place.

void IMP::em2d::do_place	(	cv::Mat &	mask,
		cv::Mat &	m,
		const algebra::Vector2D &	v
	)

Parameters:

[in]	mask	matrix to place in m
[in]	m	matrix
[in]	v	Pixel of the matrix dest where the center of m is put.

void IMP::em2d::do_project_particles	(	const ParticlesTemp &	ps,
		cv::Mat &	m2,
		const algebra::Rotation3D &	R,
		const algebra::Vector3D &	translation,
		const ProjectingOptions &	options,
		MasksManagerPtr	masks
	)

Projects a set of particles. This is the core function that others call.

Parameters:

[in]	ps	particles to project
[in]	R	rotation to apply to the particles (respect to the centroid)
[in]	translation	Translation to apply after rotation
[in]	clear_matrix_before	If true the matrix is set to zero before projecting the particles. You want this 99% of the time, as setting to false will add one projection on top of the other

Note:: See the function get_projection() for the rest of the parameters

algebra::Vector2Ds IMP::em2d::do_project_vectors	(	const algebra::Vector3Ds &	ps,
		const algebra::Rotation3D &	R,
		const algebra::Vector3D &	translation
	)

Project the points contained in Vector3Ds to gen vectors in 2D.

Parameters:

[in]	ps	the points
[in]	R	Rotation to apply to the points to project them in the Z axis
[in]	translation	translation to apply to the points

Returns:: A set of Vector2D with the projected points

algebra::Vector2Ds IMP::em2d::do_project_vectors	(	const algebra::Vector3Ds &	ps,
		const algebra::Rotation3D &	R,
		const algebra::Vector3D &	translation,
		const algebra::Vector3D &	center
	)

Project the points contained in Vector3Ds.

Parameters:

[in]	ps	the points
[in]	R	Rotation to apply to the points to project them in the Z axis
[in]	translation	translation to apply to the points
[in]	center	Center point used for the rotation around it

Returns:: A set of Vector2D with the projected points

void IMP::em2d::do_remove_small_objects	(	cvIntMat &	m,
		double	percentage,
		int	background = `0`,
		int	foreground = `1`
	)

Removes small objects from a matrix of integers.

Parameters:

[in]	m	the matrix
[in]	percentage	The percentage respect to the largest object that other objects have to be in order to survive the removal.
[in]	background	value for the background after removed
[in]	background	value for the foreground after removed

void IMP::em2d::do_resample_polar	(	const cv::Mat &	input,
		cv::Mat &	resampled,
		const PolarResamplingParameters &	polar_params
	)

Resamples a matrix to polar coordinates.

Parameters:

[in]	m	matrix to resample
[out]	result	matrix to contain the resampling
[in]	polar	params Parameters used for the resampling. Extremely useful for speeding up the procedure if they are given with the transformation maps, that can be built in the PolarResamplingParameters class

void IMP::em2d::do_segmentation	(	const cv::Mat &	m,
		cv::Mat &	result,
		const SegmentationParameters &	params
	)

Segmentation of images.

Parameters:

[in]	m	The EM image to segment
[in]	result	The segmented image, with the shape of the molecule

void IMP::em2d::get_autocorrelation2d	(	const cv::Mat &	m,
		cv::Mat &	corr
	)

Returns the autocorrelation matrix.

Parameters:

[in]	m	first matrix
[out]	corr	matrix of results

void IMP::em2d::get_autocorrelation2d	(	Image *	im1,
		Image *	im2
	)

Autocorrelation image.

void IMP::em2d::get_autocorrelation2d_no_preprocessing	(	const cv::Mat &	M,
		cv::Mat &	corr
	)

Autocorrelation without preprocessing.

Parameters:

[in]	M	matrix containing the dft
[out]	corr	the matrix to store the autocorrelation. Must have the proper dimensions when passed

MatchTemplateResults IMP::em2d::get_best_template_matches	(	const cv::Mat &	m,
		const cv::Mat &	templ,
		unsigned int	n
	)

Gets the n first matches between an image and a template

Parameters:

[in]	m	Matrix
[in]	templ	Matrix with a template to be found in m
[in]	n	Number of positions to recover

ResultAlign2D IMP::em2d::get_complete_alignment	(	const cv::Mat &	input,
		cv::Mat &	m_to_align,
		bool	apply = `false`
	)

Aligns completely two matrices (rotationally and translationally). Uses the autocorrelation function to speed up the rotational alignment

Parameters:

[in]	input	Reference matrix
[in]	m_to_align	Matrix to align to the reference
[in]	apply	if true, apply the transformation to m_to_align after alignment

Returns:: The result. Check the definition of ResultAlign2D

em2d::ResultAlign2D IMP::em2d::get_complete_alignment_no_preprocessing	(	const cv::Mat &	input,
		const cv::Mat &	INPUT,
		const cv::Mat &	POLAR1,
		cv::Mat &	m_to_align,
		const cv::Mat &	POLAR2,
		bool	apply = `false`
	)

Aligns two matrices rotationally and translationally without performing preprocessing. Preprocessed data must be provided.

Parameters:

[in]	input	first matrix
[in]	INPUT	fft of the first matrix
[in]	POLAR1	fft of the autocorrelation (in polars) of the input.
[in]	m_to_align	the matrix to align with the input
[in]	POLAR2	fft of the autocorrelation (in polars) of m_to_align
[in]	apply	true if m_to_align is transformed at the end

Returns:: The result. Check the definition of ResultAlign2D

ResultAlign2D IMP::em2d::get_complete_alignment_with_centers_no_preprocessing	(	const algebra::Vector2D &	center1,
		const algebra::Vector2D &	center2,
		const cv::Mat &	AUTOC_POLAR1,
		const cv::Mat &	AUTOC_POLAR2
	)

Aligns two matrices (rotation and translation) using centers and no preprocessing. Preprocessed data must be provided.

Parameters:

[in]	center1	weighted centroid of the reference matrix
[in]	center2	weighted centroid of the matrix to align
[in]	AUTOC_POLAR1	fft of the autocorrelation (in polars) of the input.
[in]	AUTOC_POLAR2	fft of the autocorrelation (in polars) of m_to_align

Returns:: The result. Check the definition of ResultAlign2D

void IMP::em2d::get_correlation2d	(	const cv::Mat &	A,
		const cv::Mat &	B,
		cv::Mat &	corr
	)

Correlation matrix between two 2D matrices using FFT.

Parameters:

[in]	A	first matrix
[in]	B	second matrix
[out]	corr	matrix of results

void IMP::em2d::get_correlation2d	(	Image *	im1,
		Image *	im2,
		Image *	corr
	)

Cross correlation between two images.

void IMP::em2d::get_correlation2d_no_preprocessing	(	const cv::Mat &	M1,
		const cv::Mat &	M2,
		cv::Mat &	corr
	)

Correlation without preprocessing Returns the correlation matrix between two 2D matrices using FFT

Parameters:

[in]	M1	matrix containing the dft of the first matrix
[in]	M2	matrix containing the dft of the second matrix
[out]	corr	matrix of results (It MUST have the right size in advance)

double IMP::em2d::get_cross_correlation_coefficient	(	const cv::Mat &	m1,
		const cv::Mat &	m2
	)

Computes the cross-correlation coefficient between to matrices.

double IMP::em2d::get_cross_correlation_coefficient	(	Image *	im1,
		Image *	im2
	)

Cross correlation between two images.

void IMP::em2d::get_diffusion_filtering_partial_derivative	(	const cv::Mat &	m,
		cv::Mat &	der,
		double	dx,
		double	dy,
		double	ang
	)

Partial derivative with respect to time for an image filtered with difusion-reaction

Parameters:

[in]	m	input matrix
[in]	der	output derivative matrix
[in]	dx	- step for x
[in]	dy	- step for y
[in]	ang	- parameter for weight diffusion and edge detection (90-0)

void IMP::em2d::get_domes	(	cv::Mat &	m,
		cv::Mat &	result,
		double	h
	)

Gets the domes of m with height h.

Parameters:

[in]	m	the input matrix
[in]	result	the result matrix
[in]	h	the height

Note:: The function does not work in-place

unsigned int IMP::em2d::get_enclosing_image_size	(	const ParticlesTemp &	ps,
		double	pixel_size,
		unsigned int	slack
	)

Get an automatic size for an image that contains the particles

Parameters:

[in] slack is the number of pixels left as border

RegistrationResults IMP::em2d::get_evenly_distributed_registration_results ( unsigned int n_projections )

Provides a set of registration results with directions of projection evenly distributed in the semisphere

Parameters:

[in] n_projections the number of requested projections

void IMP::em2d::get_fft_using_optimal_size	(	const cv::Mat &	m,
		cv::Mat &	M
	)

Get the FFT of a matrix using padding with other matrix that can be computed with optimized FFT

double IMP::em2d::get_global_score ( const RegistrationResults & RRs )

Get the gloal score given a set of individual registration results from images

Note:

The function checks what time of registration results are given.

If the registration results correspond to a coarse registration, the score is based on the cross-correlation (currently, the score is a mean of the cross-correlation coefficients.
If the registration results are obtained after a fine registration, the score is the average of all the registration scores. This score g depends on the function selected. Eg. EM2DScore.

Floats IMP::em2d::get_histogram	(	const cv::Mat &	m,
		int	bins
	)

Computes the histogram of a matrix.

Parameters:

[in]	m	Matrix with the data
[in]	bins	Number of bins to use in the histogram
[out]	vector	with the values for each bin

void IMP::em2d::get_morphologic_gradient	(	const cv::Mat &	m,
		cv::Mat &	result,
		const cv::Mat &	kernel
	)

Morphologic gradient: dilation-erosion

Parameters:

[in]	m	Input matrix
[out]	result
[in]	kernel	morphologic kernel

double IMP::em2d::get_overlap_percentage	(	cv::Mat &	m1,
		cv::Mat &	m2,
		const IntPair &	center
	)

Get the percentage of overlap between two matrices. Two images are overlapping in a pixel if both have values > 0. The overlap is (pixels overlapping) / (pixels > 0 in m2)

Parameters:

[in]	m1	First matrix
[in]	m2	Matrix used to check the overlap. This matrix can be of the same size of m1 or smaller.
[in]	center	Indicates the position of m1 where to put the center m2. E.g., if center is (32,16) the center of m2 will be in the pixel (32,16) of m1.

void IMP::em2d::get_projection	(	em2d::Image *	img,
		const ParticlesTemp &	ps,
		const RegistrationResult &	reg,
		const ProjectingOptions &	options,
		MasksManagerPtr	masks = `MasksManagerPtr()`,
		String	name = `""`
	)

Generates a projection from particles.

Parameters:

[in]	ps	particles to project
[in]	reg	Registration value with the parameters of the projection
[in]	masks	Precomputed masks for projecting the particles. Very useful for speeding the projection procedure if they are given. If nullptr, they are computed
[out]	img	the projection will be stored here

Note:: See the function get_projections() for the rest of the parameters

em2d::Images IMP::em2d::get_projections	(	const ParticlesTemp &	ps,
		const algebra::SphericalVector3Ds &	vs,
		int	rows,
		int	cols,
		const ProjectingOptions &	options,
		Strings	names = `Strings()`
	)

Generates projectios from particles.

Parameters:

[in]	ps	particles to project
[in]	vs	set of spherical vectors with the directions of projection
[in]	rows	size of the images
[in]	cols
[in]	options	Options for control the projecting
[in]	names	names of the images

em2d::Images IMP::em2d::get_projections	(	const ParticlesTemp &	ps,
		const RegistrationResults &	registration_values,
		int	rows,
		int	cols,
		const ProjectingOptions &	options,
		Strings	names = `Strings()`
	)

Generates projectios from particles.

Parameters:

[in] registration_values Registration values with the parameters of the projections to generate

Note:: See the function get_projections() for the rest of the parameters

RegistrationResults IMP::em2d::get_random_registration_results	(	unsigned int	n,
		double	maximum_shift = `5.0`
	)

Provides a set of random registration results (or parameters)

Parameters:

[in]	n	the number of requested results
[in]	maximum_shift	shift from the center in pixels

double IMP::em2d::get_rotation_error	(	const RegistrationResult &	rr1,
		const RegistrationResult &	rr2
	)

angle in the axis-angle representation of the rotation that takes first to second

em2d::ResultAlign2D IMP::em2d::get_rotational_alignment	(	const cv::Mat &	input,
		cv::Mat &	m_to_align,
		bool	apply = `false`
	)

Aligns two matrices rotationally. Based on the autocorrelation function of the matrices.

Parameters:

[in]	input	Reference matrix
[in]	m_to_align	Matrix to align to the reference
[in]	apply	if true, apply the transformation to m_to_align after alignment

Returns:: The result. Check the definition of ResultAlign2D

ResultAlign2D IMP::em2d::get_rotational_alignment_no_preprocessing	(	const cv::Mat &	POLAR1,
		const cv::Mat &	POLAR2
	)

Computes the rotational alignment for two autocorrelation matrices It is assumed that the arguments are FFTs

Parameters:

[in]	M1	fft of the first autocorrelation (in polars)
[in]	M2	fft of the second autocorrelation (in polars)

Returns:: The result. Check the definition of ResultAlign2D

double IMP::em2d::get_shift_error	(	const RegistrationResult &	rr1,
		const RegistrationResult &	rr2
	)

Distance between the two in-plane translations.

void IMP::em2d::get_spectrum	(	const cv::Mat &	m,
		cv::Mat &	real,
		cv::Mat &	imag
	)

Computes the fft of a matrix and returns the real and imaginary matrices.

void IMP::em2d::get_transformed	(	const cv::Mat &	input,
		cv::Mat &	transformed,
		const algebra::Transformation2D &	T
	)

Applies a transformation to a matrix. First rotates the matrix using the matrix center as the origin of the rotation, and then applies the translation

ResultAlign2D IMP::em2d::get_translational_alignment	(	const cv::Mat &	input,
		cv::Mat &	m_to_align,
		bool	apply = `false`
	)

Aligns two matrices translationally.

Parameters:

[in]	input	Reference matrix
[in]	m_to_align	Matrix to align to the reference
[in]	apply	if true, apply the transformation to m_to_align after alignment

Returns:: The result. Check the definition of ResultAlign2D

ResultAlign2D IMP::em2d::get_translational_alignment_no_preprocessing	(	const cv::Mat &	M1,
		const cv::Mat &	M2
	)

Aligns two matrices translationally without preprocessing. The preprocessed data must be provided.

Parameters:

[in]	M1	the dft the first matrix (input)
[in]	M2	the dft of the matrix to align with the input

Returns:: The result. Check the definition of ResultAlign2D

Images IMP::em2d::read_images	(	const Strings &	names,
		const ImageReaderWriter *	rw
	)

A vector of reference counted pointers to EM images of type double.

Reads images from files (For compatibility with SPIDER format, the images are read from floats)

Parameters:

[in]	names	filenames of the images
[in]	rw	reader/writer to use

RegistrationResults IMP::em2d::read_registration_results ( const String & filename )

Reads a set of registration results.

Strings IMP::em2d::read_selection_file ( String fn )

Reads a selection file.

Parameters:

[in]	fn	Name of the selection file. First column is are file names and second are 1 (file is selected) or 0 (file ignored)
[out]	List	of the selected names.

void IMP::em2d::save_images	(	Images	images,
		const Strings &	names,
		const ImageReaderWriter *	rw
	)

Saves images to files (For compatibility with SPIDER format, the images are written to floats)

Parameters:

[in]	images	Images to save
[in]	names	filenames of the images
[in]	rw	reader/writer to use

void IMP::em2d::show	(	const cv::Mat &	m,
		std::ostream &	out = `std::cout`
	)

Prints a OpenCV matrix.

template<typename T >

void IMP::em2d::show	(	const cv::Mat_< T > &	m,
		std::ostream &	out = `std::cout`
	)

Show a Mat_.

void IMP::em2d::write_matrix	(	cv::Mat &	m,
		std::string	name
	)

Quick and dirty way of writing a OpenCV matrix to a Spider image.

void IMP::em2d::write_registration_results	(	String	filename,
		const RegistrationResults &	results
	)

Writes a set of registration results.

void IMP::em2d::write_vectors_as_pdb	(	const algebra::Vector2Ds	vs,
		const String	filename
	)

Generate a PDB file from a set of Vector2D (all the points are C-alpha) and the Z coordinate is set to 0.

Note:: This version deals with the problem of having more than 10000 points

Variable Documentation

const unsigned int IMP::em2d::ALIGN2D_NO_PREPROCESSING = 0

Methods for registration used by the finder.

Detailed Description

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation