Detailed Description

This module allows density maps to be used to generate restraints.

This module provides basic utilities for handling 2D and 3D density maps. The main functionalities are: (1) Reading and writing various density map formts such as XPLOR, MRC, EM and SPIDER. (2) Simulating density maps of particles, supports particles of any radiuii and mass. (3) Calculating cross-correlation scores bewteen a density map and a set of particles.

Examples:

Author(s)

Keren Lasker, Javier Velazquez-Muriel, Friedrich Foerster

Version

SVN 8931

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, “Integrative assembly modeling using IMP”, submitted, 2010. 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.

Data Structures
class	CoarseCC
	Responsible for performing coarse fitting between two density objects. More...
class	CoarseCCatIntervals
	Cross correlation coefficient calculator. More...
class	CoarseConvolution
	Convolutes two grids. More...
class	DensityHeader
class	DensityMap
	Class for handling density maps. More...
class	DistanceMask
	Calculates and stores a distance mask. More...
class	FitRestraint
	Calculate score based on fit to EM map. More...
class	FittingSolutions
	A simple list of fitting solutions. More...
class	HighDensityEmbedding
class	ImageHeader
	Class to deal with the header of Electron Microsocopy images in IMP. More...
class	KernelParameters
class	MapReaderWriter
	The base class to handle reading and writing of density maps. More...
class	MRCReaderWriter
class	RadiusDependentKernelParameters
	Calculates kernel parameters as a function of a specific radius. More...
class	SampledDensityMap
	Class for sampling a density map from particles. More...
struct	SpiderHeader
	Header for Spider images. IMP-EM is designed to be compatible with it. More...
class	SpiderMapReaderWriter
	Class to read EM maps (3D) in Spider and Xmipp formats. More...
class	SurfaceShellDensityMap
	The class repersents a molecule as shells of distance from the surface. More...
class	Voxel
class	WeightedExcludedVolumeRestraint
	Calculate score based on fit to EM map. More...
Typedefs
typedef double	emreal
typedef Decorators< Voxel, Particles >	Voxels
Functions
Float	approximate_molecular_mass (DensityMap *m, Float threshold)
DensityMap *	binarize (DensityMap *orig_map, float threshold)
void	calc_local_bounding_box (const em::DensityMap *d_map, double x, double y, double z, float kdist, int &iminx, int &iminy, int &iminz, int &imaxx, int &imaxy, int &imaxz)
	Calculate a bounding box around a 3D point within the EM grid.
Float	calculate_intersection_score (const SurfaceShellDensityMap d1, const SurfaceShellDensityMap d2)
Float	compute_fitting_score (const Particles &ps, DensityMap *em_map, FloatKey wei_key=atom::Mass::get_mass_key())
	Compute fitting scores for a given set of rigid transformations.
FittingSolutions	compute_fitting_scores (const Particles &ps, DensityMap *em_map, const FloatKey &wei_key, const algebra::Transformation3Ds &transformations, bool fast_version=false, bool local_score=false)
	Compute fitting scores for a given set of rigid transformations.
FittingSolutions	compute_fitting_scores (DensityMap em_map, core::RigidBody rb, Refiner refiner, const algebra::Transformation3Ds &transformations, const FloatKey &wei_key=atom::Mass::get_mass_key())
	Compute fitting scores for a given set of rigid transformations.
double	convolute (const DensityMap m1, const DensityMap m2)
DensityHeader	create_density_header (const algebra::BoundingBoxD< 3 > &bb, float spacing)
	Create a header from a bounding box 3D.
DensityMap *	create_density_map (int nx, int ny, int nz, double spacing)
	Create an empty density map.
DensityMap *	create_density_map (const algebra::BoundingBox3D &bb, double spacing)
	Create an empty density map from a boudning box.
Particles	density2particles (DensityMap dmap, Float threshold, Model m, int step=1)
	Converts a density grid to a set of paritlces.
std::vector< algebra::VectorD< 3 > >	density2vectors (DensityMap *dmap, Float threshold)
	Converts a density grid to a set of paritlces.
void	DensityHeader_to_ImageHeader (const DensityHeader &header, ImageHeader &h)
double	EXP (float y)
algebra::BoundingBoxD< 3 >	get_bounding_box (const DensityMap *m)
algebra::BoundingBoxD< 3 >	get_bounding_box (const DensityMap *m, Float threshold)
std::string	get_data_path (std::string file_name)
	Return the path to installed data for this module.
double	get_density (const DensityMap *m, const algebra::VectorD< 3 > &v)
	rotate a grid
std::string	get_example_path (std::string file_name)
	Return the path to installed example data for this module.
bool	get_interiors_intersect (const DensityMap d1, const DensityMap d2)
DensityMap *	get_max_map (DensityMaps maps)
std::string	get_module_name ()
const VersionInfo &	get_module_version_info ()
Float	get_molecular_mass_at_threshold (DensityMap *m, Float threshold, atom::ProteinDensityReference ref=atom::HARPAZ)
	Compute an approximate molecular mass.
long	get_number_of_particles_outside_of_the_density (DensityMap *dmap, const Particles &ps, const IMP::algebra::Transformation3D &t=IMP::algebra::get_identity_transformation_3d(), float thr=0.0)
	Get the number of particles that are outside of the density.
DensityMap *	get_resampled (DensityMap *in, double scaling)
DensityMap *	get_segment (DensityMap *map_to_segment, int nx_start, int nx_end, int ny_start, int ny_end, int nz_start, int nz_end)
	Get a segment of the map according to xyz indexes.
Float	get_threshold_for_approximate_mass (DensityMap *m, Float desired_mass, atom::ProteinDensityReference ref=atom::HARPAZ)
	Computes the threshold to consider in an EM map to get a desired mass.
Float	get_threshold_for_approximate_volume (DensityMap *m, Float desired_volume)
	Computes the threshold consider in an EM map to get a desired volume.
DensityMap *	get_transformed (const DensityMap *in, const algebra::Transformation3D &tr, double threshold)
DensityMap *	get_transformed (DensityMap *in, const algebra::Transformation3D &tr)
void	get_transformed_into (const DensityMap from, const algebra::Transformation3D &tr, DensityMap into, bool calc_rms=true)
	Rotate a density map into another maps.
Float	get_volume_at_threshold (DensityMap *m, Float threshold)
	Compute an approximate volume.
void	ImageHeader_to_DensityHeader (const ImageHeader &h, DensityHeader &header)
FittingSolutions	local_rigid_fitting (core::RigidBody rb, Refiner refiner, const FloatKey &weight_key, DensityMap dmap, OptimizerState *display_log=NULL, Int number_of_optimization_runs=5, Int number_of_mc_steps=10, Int number_of_cg_steps=100, Float max_translation=2., Float max_rotation=.3, bool fast=true)
	Local rigid fitting of a rigid body.
FittingSolutions	local_rigid_fitting_around_point (core::RigidBody rb, Refiner refiner, const FloatKey &weight_key, DensityMap dmap, const algebra::VectorD< 3 > &anchor_centroid, OptimizerState *display_log, Int number_of_optimization_runs=5, Int number_of_mc_steps=10, Int number_of_cg_steps=100, Float max_translation=2., Float max_rotation=.3, bool fast=false)
	Local rigid fitting of a rigid body around a center point.
FittingSolutions	local_rigid_fitting_around_points (core::RigidBody rb, Refiner refiner, const FloatKey &wei_key, DensityMap dmap, const std::vector< algebra::VectorD< 3 > > &anchor_centroids, OptimizerState *display_log, Int number_of_optimization_runs=5, Int number_of_mc_steps=10, Int number_of_cg_steps=100, Float max_translation=2., Float max_rotation=.3)
	Local rigid fitting of a rigid body around a set of center points.
FittingSolutions	local_rigid_fitting_grid_search (const Particles &ps, const FloatKey &wei_key, DensityMap *dmap, Int max_voxels_translation=2, Int translation_step=1, Float max_angle_in_radians=0.174, Int number_of_rotations=100)
	Local grid search rigid fitting.
DensityMap *	mask_and_norm (em::DensityMap dmap, em::DensityMap mask)
DensityMap *	multiply (const DensityMap m1, const DensityMap m2)
SampledDensityMap *	particles2density (const Particles &ps, Float resolution, Float apix, int sig_cutoff=3, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
	Resample a set of particles into a density grid.
SurfaceShellDensityMap *	particles2surface (const Particles &ps, Float apix, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
	Resample a set of particles into a density grid.
DensityMap *	read_map (const char filename, MapReaderWriter reader)
DensityMap *	read_map (const char *filename)
void	write_map (DensityMap m, const char filename, MapReaderWriter *writer)
Variables
const double	EPS = 1e-16

Function Documentation

Float IMP::em::approximate_molecular_mass	(	DensityMap *	m,
		Float	threshold
	)

Parameters:

[in]	m	a density map
[in]	threshold	consider volume of only voxels above this threshold

Note:: The method assumes 1.21 cubic A per dalton (Harpaz 1994).

DensityMap* IMP::em::binarize	(	DensityMap *	orig_map,
		float	threshold
	)

Return a map with 0 for all voxels below the threshold and 1 for thoes above

void IMP::em::calc_local_bounding_box	(	const em::DensityMap *	d_map,
		double	x,
		double	y,
		double	z,
		float	kdist,
		int &	iminx,
		int &	iminy,
		int &	iminz,
		int &	imaxx,
		int &	imaxy,
		int &	imaxz
	)

Calculate a bounding box around a 3D point within the EM grid.

Parameters:

[in]	d_map	the density map
[in]	x	coordinates of the point to sample around
[in]	y	coordinates of the point to sample around
[in]	z	coordinates of the point to sample around
[in]	kdist	the lenght of the box
[out]	iminx	the minimum index on the X axis of the output bounding box
[out]	iminy	the minimum index on the Y axis of the output bounding box
[out]	iminz	the minimum index on the Z axis of the output bounding box
[out]	imaxx	the maximum index on the X axis of the output bounding box
[out]	imaxy	the maximum index on the Y axis of the output bounding box
[out]	imaxz	the maximum index on the Z axis of the output bounding box

Float IMP::em::compute_fitting_score	(	const Particles &	ps,
		DensityMap *	em_map,
		FloatKey	wei_key = `atom::Mass::get_mass_key()`
	)

Compute fitting scores for a given set of rigid transformations.

Scores how well a set of particles fit a map

Parameters:

[in]	ps	The particles to be fitted
[in]	em_map	The density map to fit to
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body

Note:: the function assumes the density map holds its density

FittingSolutions IMP::em::compute_fitting_scores	(	const Particles &	ps,
		DensityMap *	em_map,
		const FloatKey &	wei_key,
		const algebra::Transformation3Ds &	transformations,
		bool	fast_version = `false`,
		bool	local_score = `false`
	)

Compute fitting scores for a given set of rigid transformations.

Score how well a set of particles fit to the map in various rigid transformations.

Parameters:

[in]	ps	The particles to be fitted (treated rigid)
[in]	em_map	The density map to fit to
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body
[in]	fast_version	If fast_version is used the sampled density map of the input particles (ps) is not resampled for each transformation but instead the corresponding grid is rotated. This option significantly improves the running times but the returned scores are less accurate
[in]	transformations	A set of rigid transformations
[in]	fast_version	if true the density map of each transformation is interpolated
[in]	local_score	if true a local cross correlation score is used

Returns:: The scored fitting solutions

Note:: the function assumes the density map holds its density

FittingSolutions IMP::em::compute_fitting_scores	(	DensityMap *	em_map,
		core::RigidBody	rb,
		Refiner *	refiner,
		const algebra::Transformation3Ds &	transformations,
		const FloatKey &	wei_key = `atom::Mass::get_mass_key()`
	)

Compute fitting scores for a given set of rigid transformations.

Score how well a rigid body fits to the map

Parameters:

[in]	em_map	The density map to fit to
[in]	rb	The rigid body
[in]	refiner	The rigid body refiner
[in]	transformations	Transformations of the rigid body
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body

Returns:: The scored fitting solutions

Note:: the function assumes the density map holds its density

double IMP::em::convolute	(	const DensityMap *	m1,
		const DensityMap *	m2
	)

Return a convolution between density maps m1 and m2. The function assumes m1 and m2 are of the same dimensions.

Particles IMP::em::density2particles	(	DensityMap *	dmap,
		Float	threshold,
		Model *	m,
		int	step = `1`
	)

Converts a density grid to a set of paritlces.

Each such particle will be have xyz attributes and a density_val attribute of type Float.

Parameters:

[in]	dmap	the density map
[in]	threshold	only voxels with density above the given threshold will be converted to particles
[in]	m	model to store the new particles
[in]	step	sample every X steps in each direction

Returns:: particles corresponding to all voxels above the threshold

std::vector<algebra::VectorD<3> > IMP::em::density2vectors	(	DensityMap *	dmap,
		Float	threshold
	)

Converts a density grid to a set of paritlces.

Each such particle will be have xyz attributes and a density_val attribute of type Float.

Parameters:

[in]	dmap	the density map
[in]	threshold	only voxels with density above the given threshold will be converted to particles

Returns:: a set of vector3Ds corresponding to the positions of all voxels above the threshold

void IMP::em::DensityHeader_to_ImageHeader	(	const DensityHeader &	header,
		ImageHeader &	h
	)

Function to transfer the (compatible) information content from DensityHeader to ImageHeader

algebra::BoundingBoxD<3> IMP::em::get_bounding_box	(	const DensityMap *	m,
		Float	threshold
	)

Parameters:

[in]	m	a density map
[in]	threshold	find the boudning box for voxels with value above the threshold

std::string IMP::em::get_data_path ( std::string file_name )

Return the path to installed data for this module.

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 tools/imppy.sh script.

double get_density	(	const DensityMap *	m,
		const algebra::VectorD< 3 > &	v
	)

rotate a grid

/param[in] orig_dens the density map to rotate /param[in] trans the transformation

Note:: this is a low resolution operation. DensityMap* rotate_grid(const DensityMap *orig_dens, const algebra::Transformation3D &trans); Return the value for the density map, m, at point v, interpolating linearly from the sample values. The resulting function is C0 over R3.

std::string IMP::em::get_example_path ( std::string file_name )

Return the path to installed example data for this module.

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

    IMP::atom::read_pdb(IMP::atom::get_example_path("example_protein.pdb", model));

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

DensityMap* IMP::em::get_max_map ( DensityMaps maps )

Return a density map for which each voxel is the maximum value from the input densities.

Note:: all input maps should have the same extent

Float IMP::em::get_molecular_mass_at_threshold	(	DensityMap *	m,
		Float	threshold,
		atom::ProteinDensityReference	ref = `atom::HARPAZ`
	)

Compute an approximate molecular mass.

Compute an approximate molecular mass for the set of voxels with intensity under a given threshold

Parameters:

[in]	m	a density map
[in]	threshold,only	voxels above this threshold will be considered
[in]	ref,the	protein density reference to use in the computation. The default protein density for this computation is HARPAZ

Returns:: an approximate molecular mass for the set of voxels with intensity under the provided threshold (mass in Da)

long IMP::em::get_number_of_particles_outside_of_the_density	(	DensityMap *	dmap,
		const Particles &	ps,
		const IMP::algebra::Transformation3D &	t = `IMP::algebra::get_identity_transformation_3d()`,
		float	thr = `0.0`
	)

Get the number of particles that are outside of the density.

/note the function assumes that all of the particles have XYZ coordinates

DensityMap * get_resampled	(	DensityMap *	in,
		double	scaling
	)

Get a resampled version of the map. The spacing is multiplied by scaling. That means, scaling values greater than 1 increase the voxel size.

DensityMap* IMP::em::get_segment	(	DensityMap *	map_to_segment,
		int	nx_start,
		int	nx_end,
		int	ny_start,
		int	ny_end,
		int	nz_start,
		int	nz_end
	)

Get a segment of the map according to xyz indexes.

Note:: the output map will be cover the region [[nx_start,nx_end],[]ny_start,ny_end,[nz_start,nz_end]]

Float IMP::em::get_threshold_for_approximate_mass	(	DensityMap *	m,
		Float	desired_mass,
		atom::ProteinDensityReference	ref = `atom::HARPAZ`
	)

Computes the threshold to consider in an EM map to get a desired mass.

Computes the threshold to consider in an EM map to get a desired mass (only voxels with intensity greater than the threshold are considered)

Parameters:

[in]	m	a density map
[in]	desired_mass	(in Da)
[in]	ref,the	protein density reference to use in the computation. The default protein density for this computation is HARPAZ

Float IMP::em::get_threshold_for_approximate_volume	(	DensityMap *	m,
		Float	desired_volume
	)

Computes the threshold consider in an EM map to get a desired volume.

Computes the threshold consider in an EM map to get a desired volume (i.e, the set of voxels with intensity greater than the threshold occupies that volume)

Parameters:

[in]	m	a density map
[in]	desired_volume	(in A^3)

DensityMap * get_transformed	(	const DensityMap *	in,
		const algebra::Transformation3D &	tr,
		double	threshold
	)

Return a new density map containing a rotated version of the old one. Only voxels whose value is above threshold are considered when computing the bounding box of the new map (set IMP::em::get_bounding_box()).

DensityMap * get_transformed	(	DensityMap *	in,
		const algebra::Transformation3D &	tr
	)

Return a new density map containing a rotated version of the old one. The dimension of the new map is the same as the old one.

void get_transformed_into	(	const DensityMap *	from,
		const algebra::Transformation3D &	tr,
		DensityMap *	into,
		bool	calc_rms = `true`
	)

Rotate a density map into another maps.

Parameters:

[in]	from	the map to transform
[in]	tr	transform the from density map by this transformation
[out]	into	the map to tranform into
[in]	calc_rms	if true RMS is calculated on the transformed map

Float IMP::em::get_volume_at_threshold	(	DensityMap *	m,
		Float	threshold
	)

Compute an approximate volume.

Compute an approximate volume for the set of voxels with intensity under a given threshold

Parameters:

[in]	m	a density map
[in]	threshold,consider	volume of only voxels above this threshold

Returns:: a volume for the set of voxels with intensity under the provided threshold

void IMP::em::ImageHeader_to_DensityHeader	(	const ImageHeader &	h,
		DensityHeader &	header
	)

Function to transfer the (compatible) information content from ImageHeader to DensityHeader

FittingSolutions IMP::em::local_rigid_fitting	(	core::RigidBody	rb,
		Refiner *	refiner,
		const FloatKey &	weight_key,
		DensityMap *	dmap,
		OptimizerState *	display_log = `NULL`,
		Int	number_of_optimization_runs = `5`,
		Int	number_of_mc_steps = `10`,
		Int	number_of_cg_steps = `100`,
		Float	max_translation = `2.`,
		Float	max_rotation = `.3`,
		bool	fast = `true`
	)

Local rigid fitting of a rigid body.

Fit a set of particles to a density map around their centroid. The fitting is assessed using the cross-correaltion score. The optimization is a standard MC/CG procedure. The function returns a list of solutions sortedo the cross-correlation score.

Note:: The returned cross-correlation score is 1-cc, as we usually want to minimize a scroing function. Thus a score of 1 means no-correlation and a score of 0. is perfect correlation.; The input rigid body should be also IMP::atom::Hierarchy

Parameters:

[in]	rb	The rigid body to fit
[in]	radius_key	The raidus key of the particles in the rigid body
[in]	weight_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	display_log	If provided, then intermediate states in during the optimization procedure are printed
[in]	number_of_optimization_runs	number of Monte Carlo optimizations
[in]	number_of_mc_steps	number of steps in a Monte Carlo optimization
[in]	number_of_cg_steps	number of Conjugate Gradients steps in a Monte Carlo step
[in]	max_translation	maximum translation step in a MC optimization step
[in]	max_rotation	maximum rotation step in radians in a single MC optimization step
[in]	fast	if true the density map of the rigid body is not resampled but transformed at each iteration of the optimization

Returns:: the refined fitting solutions

FittingSolutions IMP::em::local_rigid_fitting_around_point	(	core::RigidBody	rb,
		Refiner *	refiner,
		const FloatKey &	weight_key,
		DensityMap *	dmap,
		const algebra::VectorD< 3 > &	anchor_centroid,
		OptimizerState *	display_log,
		Int	number_of_optimization_runs = `5`,
		Int	number_of_mc_steps = `10`,
		Int	number_of_cg_steps = `100`,
		Float	max_translation = `2.`,
		Float	max_rotation = `.3`,
		bool	fast = `false`
	)

Local rigid fitting of a rigid body around a center point.

Fit a set of particles to a density map around an anchor point. The fitting is assessed using the cross-correaltion score. The optimization is a standard MC/CG procedure. The function returns a list of solutions sortedo the cross-correlation score.

Note:: The returned cross-correlation score is 1-cc, as we usually want to minimize a scroing function. Thus a score of 1 means no-correlation and a score of 0. is perfect correlation.; The input rigid body should be also IMP::atom::Hierarchy

Parameters:

[in]	rb	The rigid body to fit
[in]	radius_key	The raidus key of the particles in the rigid body
[in]	weight_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	anchor_centroid	The point to fit the particles around
[in]	display_log	If provided, then intermediate states in during the optimization procedure are printed
[in]	number_of_optimization_runs	number of Monte Carlo optimizations
[in]	number_of_mc_steps	number of steps in a Monte Carlo optimization
[in]	number_of_cg_steps	number of Conjugate Gradients steps in a Monte Carlo step
[in]	max_translation	maximum translation step in a MC optimization step
[in]	max_rotation	maximum rotation step in a single MC optimization step
[in]	fast	if true the density map of the rigid body is not resampled but transformed at each iteration of the optimization

Returns:: the refined fitting solutions

FittingSolutions IMP::em::local_rigid_fitting_around_points	(	core::RigidBody	rb,
		Refiner *	refiner,
		const FloatKey &	wei_key,
		DensityMap *	dmap,
		const std::vector< algebra::VectorD< 3 > > &	anchor_centroids,
		OptimizerState *	display_log,
		Int	number_of_optimization_runs = `5`,
		Int	number_of_mc_steps = `10`,
		Int	number_of_cg_steps = `100`,
		Float	max_translation = `2.`,
		Float	max_rotation = `.3`
	)

Local rigid fitting of a rigid body around a set of center points.

Fit a set of particles to a density map around each of the input points. The function apply local_rigid_fitting_around_point around each center.

Note:: The input rigid body should be also IMP::atom::Hierarchy

Parameters:

[in]	rb	The rigid body to fit
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	anchor_centroids	The points to fit the particles around
[in]	display_log	If provided, then intermediate states in during the optimization procedure are printed
[in]	number_of_optimization_runs	number of Monte Carlo optimizations
[in]	number_of_mc_steps	number of steps in a Monte Carlo optimization
[in]	number_of_cg_steps	number of Conjugate Gradients steps in a Monte Carlo step
[in]	max_translation	maximum translation step in a MC optimization step
[in]	max_rotation	maximum rotation step in a single MC optimization step

Returns:: the refined fitting solutions

FittingSolutions IMP::em::local_rigid_fitting_grid_search	(	const Particles &	ps,
		const FloatKey &	wei_key,
		DensityMap *	dmap,
		Int	max_voxels_translation = `2`,
		Int	translation_step = `1`,
		Float	max_angle_in_radians = `0.174`,
		Int	number_of_rotations = `100`
	)

Local grid search rigid fitting.

Fit a set of particles to a density map around their centroid. The fitting is assessed using the cross-correaltion score. The optimization is a grid search

Note:: The transformations are not clustered.; The returned cross-correlation score is 1-cc, as we usually want to minimize a scroing function. Thus a score of 1 means no-correlation and a score of 0. is perfect correlation.

Parameters:

[in]	ps	The particles to be fitted (treated rigid)
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	max_voxels_translation	Sample translations within -max_voxel_translation to max_voxel_translation
[in]	translation_step	The translation sampling step
[in]	max_angle_in_radians	Sample rotations with +- max_angle_in_radians around the current rotation
[in]	number_of_rotations	The number of rotations to sample

Returns:: the refined fitting solutions

DensityMap* IMP::em::mask_and_norm	(	em::DensityMap *	dmap,
		em::DensityMap *	mask
	)

Return a masked density , and normalize the output map within the masked region

Parameters:

[in]	dmap	the density map to mask
[in]	mask	the mask

Returns:: the masked and normalized map

DensityMap* IMP::em::multiply	(	const DensityMap *	m1,
		const DensityMap *	m2
	)

Return a density map for which voxel i contains the result of m1[i]*m2[i]. The function assumes m1 and m2 are of the same dimensions.

SampledDensityMap * particles2density	(	const Particles &	ps,
		Float	resolution,
		Float	apix,
		int	sig_cutoff = `3`,
		const FloatKey &	weight_key = `IMP::atom::Mass::get_mass_key()`
	)

Resample a set of particles into a density grid.

Each such particle should be have xyz radius and weight attributes

Parameters:

[in]	ps	the particles to sample
[in]	resolution	the resolution of the new sampled map
[in]	apix	the voxel size of the sampled map
[in]	sig_cutoff	sigma cutoff used in sampling
[in]	rad_key	the radius attribute key of the particles
[in]	weight_key	the weight attribute key of the particles

Returns:: the sampled density grid

SurfaceShellDensityMap * particles2surface	(	const Particles &	ps,
		Float	apix,
		const FloatKey &	weight_key = `IMP::atom::Mass::get_mass_key()`
	)

Resample a set of particles into a density grid.

Each such particle should be have xyz radius and weight attributes

Parameters:

[in]	ps	the particles to sample
[in]	apix	the voxel size of the surface map
[in]	rad_key	the radius attribute key of the particles
[in]	weight_key	the weight attribute key of the particles

Returns:: the surface grid

DensityMap * read_map	(	const char *	filename,
		MapReaderWriter *	reader
	)

Read a density map from a file and return it.

DensityMap * read_map ( const char * filename )

Read a density map from a file and return it. Guess the file type from the file name. The file formats supported are:

.mrc
.em
.vol
.xplor

void write_map	(	DensityMap *	m,
		const char *	filename,
		MapReaderWriter *	writer
	)

Write a density map to a file.

IMP::em Namespace Reference

Detailed Description

Author(s)

Version

License:

Publications:

Data Structures

Typedefs

Functions

Variables

Function Documentation