IMP  2.1.0
The Integrative Modeling Platform
IMP::em2d Namespace Reference

See IMP.em2d for more information.

Namespaces

 argminmax
 Utility functions to extract min/max from the inputs.
 
 
 
 Database
 Utility functions to manage SQL databases with sqlite3.
 
 restraints
 Utility functions to handle restraints.
 
 solutions_io
 Utility functions to store and retrieve solution information.
 

Classes

class  CenteredMat
 
class  ChiSquaredScore
 Score based on Chi^2 = ((pixels_iamge - pixels_projection)/stddev_image)^2. More...
 
class  CollisionCrossSection
 Determine the collision cross section for some projections of particles. More...
 
class  DistanceFilter
 SubsetFilter for checking overlap between projections and images. 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  ImageReaderWriter
 Virtual class for reader/writers of images. 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  MeanAbsoluteDifference
 Score based on the mean of the absolute difference. More...
 
class  ParticlesDummyRestraint
 Dummy restraint for a set of particles. Same use as DummyRestraint. More...
 
class  PolarResamplingParameters
 
class  ProjectingOptions
 Parameters given as options to the get_projections() functions. More...
 
class  ProjectingParameters
 Parameters needed for the core projection routine. More...
 
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  RelativePositionMover
 
class  RigidBodiesImageFitRestraint
 Fit rigid bodies to an image. 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
 
class  TIFFImageReaderWriter
 Management of reading/writing TIFF images. More...
 

Typedefs

typedef IMP::base::Vector
< AverageDistanceLinkage > 
AverageDistanceLinkages
 
typedef IMP::base::Vector
< IMP::base::Pointer
< ChiSquaredScore > > 
ChiSquaredScores
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< ChiSquaredScore > > 
ChiSquaredScoresTemp
 
typedef IMP::base::Vector
< ClusterSet > 
ClusterSets
 
typedef IMP::base::Vector
< IMP::base::Pointer
< CollisionCrossSection > > 
CollisionCrossSections
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< CollisionCrossSection > > 
CollisionCrossSectionsTemp
 
typedef IMP::base::Vector
< CompleteLinkage > 
CompleteLinkages
 
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 IMP::base::Vector
< IMP::base::Pointer
< DistanceFilter > > 
DistanceFilters
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< DistanceFilter > > 
DistanceFiltersTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer
< DistanceFilterTable > > 
DistanceFilterTables
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< DistanceFilterTable > > 
DistanceFilterTablesTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer
< DummyRestraint > > 
DummyRestraints
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< DummyRestraint > > 
DummyRestraintsTemp
 
typedef IMP::base::Vector
< Em2DRestraintParameters > 
Em2DRestraintParametersList
 
typedef IMP::base::Vector
< IMP::base::Pointer
< Em2DRestraint > > 
Em2DRestraints
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< Em2DRestraint > > 
Em2DRestraintsTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer
< EM2DScore > > 
EM2DScores
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< EM2DScore > > 
EM2DScoresTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer
< Fine2DRegistrationRestraint > > 
Fine2DRegistrationRestraints
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< Fine2DRegistrationRestraint > > 
Fine2DRegistrationRestraintsTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer
< GridStates > > 
GridStatesList
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< GridStates > > 
GridStatesListTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer< Image > > 
Images
 A vector of reference counted pointers to EM images of type double. More...
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< Image > > 
ImagesTemp
 
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 IMP::base::Vector
< MasksManager
MasksManagers
 
typedef IMP::base::Vector
< MatchTemplateResult
MatchTemplateResults
 
typedef IMP::base::Vector
< IMP::base::Pointer
< MeanAbsoluteDifference > > 
MeanAbsoluteDifferences
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< MeanAbsoluteDifference > > 
MeanAbsoluteDifferencesTemp
 
typedef std::pair< unsigned
int,double > 
pair_cluster_id_distance
 
typedef IMP::base::Vector
< IMP::base::Pointer
< ParticlesDummyRestraint > > 
ParticlesDummyRestraints
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< ParticlesDummyRestraint > > 
ParticlesDummyRestraintsTemp
 
typedef IMP::base::Vector
< PolarResamplingParameters
PolarResamplingParametersList
 
typedef IMP::base::Vector
< ProjectingOptions
ProjectingOptionsList
 
typedef IMP::base::Vector
< ProjectingParameters
ProjectingParametersList
 
typedef IMP::base::Vector
< IMP::base::Pointer
< ProjectionFinder > > 
ProjectionFinders
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< ProjectionFinder > > 
ProjectionFindersTemp
 
typedef boost::shared_ptr
< ProjectionMask
ProjectionMaskPtr
 
typedef IMP::base::Vector
< ProjectionMask
ProjectionMasks
 
typedef IMP::base::Vector
< ProjectionParameters
ProjectionParametersList
 
typedef IMP::base::Vector
< IMP::base::Pointer
< ProjectionStates > > 
ProjectionStatesList
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< ProjectionStates > > 
ProjectionStatesListTemp
 
typedef IMP::base::Vector
< RegistrationResult
RegistrationResults
 
typedef std::pair
< algebra::Transformation2D,
double > 
ResultAlign2D
 
typedef IMP::base::Vector
< IMP::base::Pointer
< RigidBodiesImageFitRestraint > > 
RigidBodiesImageFitRestraints
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< RigidBodiesImageFitRestraint > > 
RigidBodiesImageFitRestraintsTemp
 
typedef IMP::base::Vector
< IMP::base::Pointer
< ScoreFunction > > 
ScoreFunctions
 
typedef IMP::base::Vector
< IMP::base::WeakPointer
< ScoreFunction > > 
ScoreFunctionsTemp
 
typedef IMP::base::Vector
< SegmentationParameters
SegmentationParametersList
 
typedef IMP::base::Vector
< SingleLinkage > 
SingleLinkages
 
typedef std::vector
< algebra::Transformation3Ds
Transformation3DsList
 
typedef FloatsList VectorOfFloats
 
typedef IntsList VectorOfInts
 

Functions

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. More...
 
void add_noise (Image *im1, double op1, double op2, const String &mode="uniform", double df=3)
 
void apply_circular_mask (const cv::Mat &mat, cv::Mat &result, int radius, double value=0.0)
 
void apply_diffusion_filter (const cv::Mat &m, cv::Mat &result, double beta, double pixelsize, unsigned int time_steps)
 
void apply_diffusion_filter (Image *input, Image *filtered, double beta, double pixelsize, 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. More...
 
void apply_mean_outside_mask (Image *img, double radius)
 
void apply_threshold (cv::Mat &m, cv::Mat &result, double threshold=0.0)
 
void apply_variance_filter (const cv::Mat &input, cv::Mat &filtered, int kernelsize)
 
void apply_variance_filter (Image *input, Image *filtered, int kernelsize)
 
cvIntMat create_circular_mask (int rows, int cols, int radius)
 
Images create_evenly_distributed_projections (const kernel::ParticlesTemp &ps, unsigned int n, const ProjectingOptions &options)
 
void crop (Image *img, const IntPair &center, int size)
 
cv::Mat crop (const cv::Mat &m, const IntPair &center, int size)
 
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. More...
 
void do_combined_fill_holes_and_threshold (Image *input, Image *result, double n_stddevs)
 
void do_dilate_and_shrink_warp (cv::Mat &m, const cv::Mat &greyscale, cv::Mat &kernel)
 (U. Adiga, 2005) More...
 
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 (const cv::Mat &m, cv::Mat &result, double h)
 Fills the holes in the matrix m of height h. More...
 
void do_fill_holes (Image *input, Image *result, double n_stddevs)
 
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. More...
 
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) More...
 
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 kernel::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. More...
 
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. More...
 
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. More...
 
void do_remove_small_objects (cvIntMat &m, double percentage, int background=0, int foreground=1)
 Removes small objects from a matrix of integers. More...
 
void do_remove_small_objects (Image *input, double percentage, int background=0, int foreground=1)
 
void do_resample_polar (const cv::Mat &input, cv::Mat &resampled, const PolarResamplingParameters &polar_params)
 Resamples a matrix to polar coordinates. More...
 
void do_resample_polar (Image *im1, Image *im2, const PolarResamplingParameters &polar_params)
 
void do_segmentation (const cv::Mat &m, cv::Mat &result, const SegmentationParameters &params)
 Segmentation of images. More...
 
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)
 
void get_autocorrelation2d (Image *im1, Image *im2)
 
void get_autocorrelation2d_no_preprocessing (const cv::Mat &M, cv::Mat &corr)
 Autocorrelation without preprocessing. More...
 
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. More...
 
void get_correlation2d (Image *im1, Image *im2, Image *corr)
 
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. More...
 
std::string get_data_path (std::string file_name)
 Return the full path to installed data. More...
 
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. More...
 
unsigned int get_enclosing_image_size (const kernel::ParticlesTemp &ps, double pixel_size, unsigned int slack)
 Get an automatic size for an image that contains the particles. More...
 
RegistrationResults get_evenly_distributed_registration_results (unsigned int n_projections)
 
std::string get_example_path (std::string file_name)
 Return the path to installed example data for this module. More...
 
void get_fft_using_optimal_size (const cv::Mat &m, cv::Mat &M)
 
double get_global_score (const RegistrationResults &RRs)
 
Floats get_histogram (const cv::Mat &m, int bins)
 Computes the histogram of a matrix. More...
 
Floats get_histogram (Image *img, int bins)
 
double get_mean (const cv::Mat &mat, const cvIntMat &mask)
 
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 kernel::ParticlesTemp &ps, const RegistrationResult &reg, const ProjectingOptions &options, MasksManagerPtr masks=MasksManagerPtr(), String name="")
 Generates a projection from particles. More...
 
em2d::Images get_projections (const kernel::ParticlesTemp &ps, const algebra::SphericalVector3Ds &vs, int rows, int cols, const ProjectingOptions &options, Strings names=Strings())
 Generates projections from particles. More...
 
em2d::Images get_projections (const kernel::ParticlesTemp &ps, const RegistrationResults &registration_values, int rows, int cols, const ProjectingOptions &options, Strings names=Strings())
 Generates projections from particles. More...
 
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) More...
 
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)
 
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. More...
 
ResultAlign2D get_translational_alignment_no_preprocessing (const cv::Mat &M1, const cv::Mat &M2)
 
Ints get_unique_index (const algebra::Rotation3D &rot)
 
void my_meanStdDev (const cv::Mat &m, cv::Scalar &mean, cv::Scalar &stddev)
 
template<class T >
void print_vector (const std::vector< T > &v)
 
Images read_images (const Strings &names, const ImageReaderWriter *rw)
 
RegistrationResults read_registration_results (const String &filename)
 Reads a set of registration results.
 
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)
 
void write_vectors_as_pdb (const algebra::Vector3Ds 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
 

Standard module methods

All IMP modules have a set of standard methods to help get information about the module and about files associated with the module.

std::string get_module_version ()
 
std::string get_module_name ()
 

Typedef Documentation

typedef IMP::base::Vector< AverageDistanceLinkage > IMP::em2d::AverageDistanceLinkages

Pass or store a set of AverageDistanceLinkage .

Definition at line 202 of file hierarchical_clustering.h.

Store a set of objects.

Definition at line 96 of file scores2D.h.

Pass a \ set of \ objects. \ See \ ChiSquaredScore

Definition at line 96 of file scores2D.h.

Pass or store a set of ClusterSet .

Definition at line 126 of file hierarchical_clustering.h.

typedef IMP::base::Vector< CompleteLinkage > IMP::em2d::CompleteLinkages

Pass or store a set of CompleteLinkage .

Definition at line 179 of file hierarchical_clustering.h.

Store a set of objects.

Definition at line 60 of file domino_filters.h.

Pass a \ set of \ objects. \ See \ DistanceFilter

Definition at line 60 of file domino_filters.h.

Store a set of objects.

Definition at line 69 of file DummyRestraint.h.

Pass a \ set of \ objects. \ See \ DummyRestraint

Definition at line 69 of file DummyRestraint.h.

typedef IMP::base::Vector< Em2DRestraintParameters > IMP::em2d::Em2DRestraintParametersList

Pass or store a set of Em2DRestraintParameters .

Definition at line 72 of file ProjectionFinder.h.

Store a set of objects.

Definition at line 143 of file Em2DRestraint.h.

Pass a \ set of \ objects. \ See \ Em2DRestraint

Definition at line 143 of file Em2DRestraint.h.

Store a set of objects.

Definition at line 110 of file scores2D.h.

Pass a \ set of \ objects. \ See \ EM2DScore

Definition at line 110 of file scores2D.h.

Store a set of objects.

Definition at line 72 of file domino_particle_states.h.

Pass a \ set of \ objects. \ See \ GridStates

Definition at line 72 of file domino_particle_states.h.

Store a set of objects.

Definition at line 216 of file Image.h.

Pass a \ set of \ objects. \ See \ Image

Definition at line 216 of file Image.h.

Pass or store a set of MasksManager .

Definition at line 208 of file ProjectionMask.h.

Pass or store a set of MatchTemplateResult .

Definition at line 91 of file image_processing.h.

Store a set of objects.

Definition at line 119 of file scores2D.h.

Pass or store a set of ProjectingOptions .

Definition at line 107 of file project.h.

Pass or store a set of ProjectingParameters .

Definition at line 53 of file project.h.

Store a set of objects.

Definition at line 226 of file ProjectionFinder.h.

Pass a \ set of \ objects. \ See \ ProjectionFinder

Definition at line 226 of file ProjectionFinder.h.

Pass or store a set of ProjectionMask .

Definition at line 77 of file ProjectionMask.h.

Pass or store a set of RegistrationResult .

Definition at line 163 of file RegistrationResult.h.

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

Definition at line 22 of file align2D.h.

Store a set of objects.

Definition at line 84 of file scores2D.h.

Pass a \ set of \ objects. \ See \ ScoreFunction

Definition at line 84 of file scores2D.h.

typedef IMP::base::Vector< SingleLinkage > IMP::em2d::SingleLinkages

Pass or store a set of SingleLinkage .

Definition at line 155 of file hierarchical_clustering.h.

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.

Definition at line 30 of file RelativePositionMover.h.

Function Documentation

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

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  value = 0.0 
)

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

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

beta is the 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_diffusion_filter ( Image *  input,
Image *  filtered,
double  beta,
double  pixelsize,
int  time_steps 
)

Apply the diffusion filter

Parameters
inputInput image
filteredThe image containing the result
betaThe beta parameter of the difussion filter
pixelsizeThe pixel size of the image
time_stepsThe number of time steps used for the diffusion

Definition at line 309 of file Image.h.

+ Here is the call graph for this function:

void IMP::em2d::apply_mask ( const cv::Mat &  m,
cv::Mat &  result,
const cvIntMat &  mask,
double  val 
)
Parameters
[in]mInput matrix
[in]resultmatrix with the result
[in]maskIf the mask is 0, the result has the value of val. Otherwise is the value of m.
[in]valvalue to apply when the mask is 0
void IMP::em2d::apply_mean_outside_mask ( Image *  img,
double  radius 
)

Fills the values that are outside a circle centered at the center of the image with the mean of the values inside the circle the matrix center

Parameters
[in]imgImage. It is modified in situ
[in]radiusof the circle
void IMP::em2d::apply_threshold ( cv::Mat &  m,
cv::Mat &  result,
double  threshold = 0.0 
)

Applys a threshold to an image threshold is a value such that 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]inputimage with the data
[out]filteredmatrix result of the filtering with the variances
[in]kernelsizeThe variance is computed using kernelsize x kernelsize pixels around each one. Kernelsize can only be odd.
void IMP::em2d::apply_variance_filter ( Image *  input,
Image *  filtered,
int  kernelsize 
)

Apply a variance filter to an image

Parameters
inputInput image
filteredThe image containing the result
kernelsizeThe size of the kernel to use. The matrix used as kernel will have the same number of rows and columns

Definition at line 296 of file Image.h.

+ Here is the call graph for this function:

cvIntMat IMP::em2d::create_circular_mask ( int  rows,
int  cols,
int  radius 
)

Creates a circular matrix that is a mask

Parameters
[in]rows
[in]cols
[in]radiusThe radius of the mask. The center of the mask is the center of the matrix
Returns
A binary matrix (0/1) with value 1 inside the radius
Images IMP::em2d::create_evenly_distributed_projections ( const kernel::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.

void IMP::em2d::crop ( Image *  img,
const IntPair &  center,
int  size 
)

Crops an image.

Parameters
[in]imgImage to crop. It is modified in place
[in]centerThe pixel used as the center for cropping
[in]sizeThe size of the new image
cv::Mat IMP::em2d::crop ( const cv::Mat &  m,
const IntPair &  center,
int  size 
)

Crop an image

Parameters
[in]mMatrix to crop
[in]centerThe pixel used as the center for cropping
[in]sizeThe size of the new image
Returns
A matrix with the cropped region
void IMP::em2d::do_combined_fill_holes_and_threshold ( cv::Mat &  m,
cv::Mat &  result,
double  n_stddevs,
double  threshold = 0.0 
)
Parameters
[in]mInput matrix
[out]resultthe result matrix
[in]n_stddevsNumber of standard deviations used to compute the holes
[in]thresholdRemoves 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 
)
Parameters
[in]mbinary matrix to dilate and shrink
[in]greyscalegreyscale matrix that controls the shrinking
[in]kerneldilation 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]origThe image to extend
[in]dstThe image destination
[in]pixnumber of pixels to extend the borders
void IMP::em2d::do_fill_holes ( const cv::Mat &  m,
cv::Mat &  result,
double  h 
)
Parameters
[in]mthe input matrix
[in]resultthe result matrix
[in]hthe height
Note
The function does not work in-place
template<class LinkageFunction >
ClusterSet IMP::em2d::do_hierarchical_agglomerative_clustering ( const FloatsList &  distances)
Parameters
[in]distancesVector 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
Returns
a ClusterSet class containing all the clustering steps.

Definition at line 216 of file hierarchical_clustering.h.

int IMP::em2d::do_labeling ( const cvIntMat &  m,
cvIntMat &  mat_to_label 
)
Parameters
[in]mbinary matrix to scan. The matrix needs to contain zeros and ones but they can be stored as doubles, floats or ints
[out]mat_to_labelmatrix it is returned as a matrix of ints
Returns
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 too.

Parameters
mThe matrix to flip. The it is changed in situ
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]mImput matrix
[out]result
[in]kernelmorphologic kernel to use
[in]iterationsHigher number, more contrast
void IMP::em2d::do_morphologic_reconstruction ( const cv::Mat &  mask,
cv::Mat &  marker,
int  neighbors_mode = 4 
)
Parameters
[in]maskimage to reconstruct
[out]markerthis image contains the initial marker points and will contain the final result
[in]neighbors_modenumber of neighbors for a pixel to consider when doing the morphologic reconstruction (values: 4, 8).
void IMP::em2d::do_normalize ( Image *  im,
bool  force = false 
)

Normalize an image subtracting the mean and dividing by the standard deviation

Parameters
imImage
forceIf true, the image is normalized even if the header says that it is already normalized
void IMP::em2d::do_place ( cv::Mat &  mask,
cv::Mat &  m,
const algebra::Vector2D &  v 
)
Parameters
[in]maskmatrix to place in m
[in]mmatrix
[in]vPixel of the matrix dest where the center of m is put.

Definition at line 91 of file ProjectionMask.h.

+ Here is the call graph for this function:

void IMP::em2d::do_project_particles ( const kernel::ParticlesTemp &  ps,
cv::Mat &  m2,
const algebra::Rotation3D &  R,
const algebra::Vector3D &  translation,
const ProjectingOptions &  options,
MasksManagerPtr  masks 
)
Parameters
[in]psparticles to project
[in]m2
[in]Rrotation to apply to the particles (respect to the centroid)
[in]translationTranslation to apply after rotation
[in]options
[in]masks
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 
)
Parameters
[in]psthe points
[in]RRotation to apply to the points to project them in the Z axis
[in]translationtranslation 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 
)
Parameters
[in]psthe points
[in]RRotation to apply to the points to project them in the Z axis
[in]translationtranslation to apply to the points
[in]centerCenter 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 
)
Parameters
[in]mthe matrix
[in]percentageThe percentage respect to the largest object that other objects have to be in order to survive the removal.
[in]backgroundvalue for the background after removed
[in]foregroundvalue for the foreground after removed
void IMP::em2d::do_resample_polar ( const cv::Mat &  input,
cv::Mat &  resampled,
const PolarResamplingParameters &  polar_params 
)
Parameters
[in]inputmatrix to resample
[out]resampledreresult matrix to contain the resampling
[in]polar_paramsParameters 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_resample_polar ( Image *  im1,
Image *  im2,
const PolarResamplingParameters &  polar_params 
)

Resample an image to polar coordinates

Parameters
im1The input image
im2The output image
polar_paramsThe parameters used for the sampling
void IMP::em2d::do_segmentation ( const cv::Mat &  m,
cv::Mat &  result,
const SegmentationParameters &  params 
)
Parameters
[in]mThe EM image to segment
[in]resultThe segmented image, with the shape of the molecule
[in]params
void IMP::em2d::do_subtract_images ( Image *  first,
Image *  second,
Image *  result 
)

Subtract two images

Parameters
firstFirst image
secondThe second image is subtracted from the second
resultResult image
void IMP::em2d::get_autocorrelation2d ( const cv::Mat &  m,
cv::Mat &  corr 
)

Computes the autocorrelation matrix

Parameters
mThe input matrix
corrThe result matrix containing the autocorrelation
void IMP::em2d::get_autocorrelation2d ( Image *  im1,
Image *  im2 
)

Compute the autocorrelation for an image

Parameters
im1The input image
im2The output image

Definition at line 254 of file Image.h.

+ Here is the call graph for this function:

void IMP::em2d::get_autocorrelation2d_no_preprocessing ( const cv::Mat &  M,
cv::Mat &  corr 
)
Parameters
[in]Mmatrix containing the dft
[out]corrthe matrix to store the autocorrelation. Must have the proper dimensions when passed Autocorrelation without preprocessing.
Mmatrix containing the dft
corrThe 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]mMatrix
[in]templMatrix with a template to be found in m
[in]nNumber 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]inputReference matrix
[in]m_to_alignMatrix to align to the reference
[in]applyif 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]inputfirst matrix
[in]INPUTfft of the first matrix
[in]POLAR1fft of the autocorrelation (in polars) of the input.
[in]m_to_alignthe matrix to align with the input
[in]POLAR2fft of the autocorrelation (in polars) of m_to_align
[in]applytrue 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]center1weighted centroid of the reference matrix
[in]center2weighted centroid of the matrix to align
[in]AUTOC_POLAR1fft of the autocorrelation (in polars) of the input.
[in]AUTOC_POLAR2fft 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 
)
Parameters
[in]Afirst matrix
[in]Bsecond matrix
[out]corrmatrix of results
void IMP::em2d::get_correlation2d ( Image *  im1,
Image *  im2,
Image *  corr 
)

Compute the cross correlation matrix between two images

Parameters
im1First input image
im2First second image
corrThe output image of cross correlation values

Definition at line 264 of file Image.h.

+ Here is the call graph for this function:

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]M1matrix containing the dft of the first matrix
[in]M2matrix containing the dft of the second matrix
[out]corrmatrix of results (It MUST have the right size in advance)
double IMP::em2d::get_cross_correlation_coefficient ( Image *  im1,
Image *  im2 
)

Get the cross correlation coefficient between 2 images

Parameters
im1First image
im2Second image
Returns
The value of the coefficient. Ranges from 0 to 1
std::string IMP::em2d::get_data_path ( std::string  file_name)

Each module has its own data directory, so be sure to use the version of this function in the correct module. To read the data file "data_library" that was placed in the data directory of module "mymodule", do something like

std::ifstream in(IMP::mymodule::get_data_path("data_library"));

This will ensure that the code works when IMP is installed or used via the setup_environment.sh script.

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]minput matrix
[in]deroutput 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 
)
Parameters
[in]mthe input matrix
[in]resultthe result matrix
[in]hthe height
Note
The function does not work in-place
unsigned int IMP::em2d::get_enclosing_image_size ( const kernel::ParticlesTemp &  ps,
double  pixel_size,
unsigned int  slack 
)

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_projectionsthe number of requested projections
std::string IMP::em2d::get_example_path ( std::string  file_name)

Each module has its own example directory, so be sure to use the version of this function in the correct module. For example to read the file example_protein.pdb located in the examples directory of the IMP::atom module, do

model));

This will ensure that the code works when IMP is installed or used via the setup_environment.sh script.

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 FFT in an optimal way. i.e. with a size that makes the FFT algorithm work faster

Parameters
mThe input matrix
MThe output matrix with the FFT
Note
The output matrix can have (and frequently will have) different dimensions than the input matrix
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 
)
Parameters
[in]mMatrix with the data
[in]binsNumber of bins to use in the histogram
Returns
vector with the values for each bin
Floats IMP::em2d::get_histogram ( Image *  img,
int  bins 
)

Gets an histogram of the values of the image

Parameters
imgThe image
binsThe number of bins to use to build the histogram
Returns
The histogram: number of points per bin

Definition at line 284 of file Image.h.

+ Here is the call graph for this function:

double IMP::em2d::get_mean ( const cv::Mat &  mat,
const cvIntMat &  mask 
)

Mean of an matrix inside a mask

Parameters
[in]matThe matrix
[in]maskIf a pixel is not zero, is considered for computing the mean
Returns
The mean
void IMP::em2d::get_morphologic_gradient ( const cv::Mat &  m,
cv::Mat &  result,
const cv::Mat &  kernel 
)

Morphologic gradient: dilation-erosion

Parameters
[in]mInput matrix
[out]result
[in]kernelmorphologic 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]m1First matrix
[in]m2Matrix used to check the overlap. This matrix can be of the same size of m1 or smaller.
[in]centerIndicates 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 kernel::ParticlesTemp &  ps,
const RegistrationResult &  reg,
const ProjectingOptions &  options,
MasksManagerPtr  masks = MasksManagerPtr(),
String  name = "" 
)
Parameters
[in]img
[in]psparticles to project
[in]regRegistration value with the parameters of the projection
[in]options
[in]masksPrecomputed masks for projecting the particles. Very useful for speeding the projection procedure if they are given. If nullptr, they are computed
[in]name
Returns
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 kernel::ParticlesTemp &  ps,
const algebra::SphericalVector3Ds &  vs,
int  rows,
int  cols,
const ProjectingOptions &  options,
Strings  names = Strings() 
)
Parameters
[in]psparticles to project
[in]vsset of spherical vectors with the directions of projection
[in]rowssize of the images
[in]cols
[in]optionsOptions for control the projecting
[in]namesnames of the images
em2d::Images IMP::em2d::get_projections ( const kernel::ParticlesTemp &  ps,
const RegistrationResults &  registration_values,
int  rows,
int  cols,
const ProjectingOptions &  options,
Strings  names = Strings() 
)

registration_values describes 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 
)
Parameters
[in]nthe number of requested results
[in]maximum_shiftshift 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]inputReference matrix
[in]m_to_alignMatrix to align to the reference
[in]applyif 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]POLAR1fft of the first autocorrelation (in polars)
[in]POLAR2fft of the second autocorrelation (in polars)
Returns
The result. Check the definition of ResultAlign2D
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

Parameters
mThe input matrix
realThe matrix with the real part of the FFT matrix
imagThe imaginary part of the FFT matrix
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 
)
Parameters
[in]inputReference matrix
[in]m_to_alignMatrix to align to the reference
[in]applyif 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]M1the dft the first matrix (input)
[in]M2the 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 
)

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

Parameters
[in]namesfilenames of the images
[in]rwreader/writer to use
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]imagesImages to save
[in]namesfilenames of the images
[in]rwreader/writer to use
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