libcootapi
 
Loading...
Searching...
No Matches
coot-map-utils.hh
1/* coot-utils/coot-map-utils.hh
2 *
3 * Copyright 2004, 2005, 2006, 2007 The University of York
4 * Copyright 2015 by Medical Research Council
5 * Author: Paul Emsley
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or (at
10 * your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 */
22
23#ifndef COOT_MAP_UTILS_HH
24#define COOT_MAP_UTILS_HH
25
26#include <map>
27
28#include <clipper/core/coords.h>
29#include <clipper/core/xmap.h>
30#include <clipper/core/hkl_data.h>
31#include <clipper/contrib/sfcalc_obs.h>
32#include "coot-coord-utils.hh"
33#include "coot-density-stats.hh"
34#include <mmdb2/mmdb_manager.h>
35#include "amp-reso.hh"
36
37namespace coot {
38
39 namespace util {
40
41 clipper::RTop_orth make_rtop_orth_from(mmdb::mat44 mat);
42
43 // cubic interpolation
44 float density_at_point(const clipper::Xmap<float> &map_in,
45 const clipper::Coord_orth &co);
46 float density_at_point_by_cubic_interp(const clipper::NXmap<float> &map_in,
47 const clipper::Coord_map &cm);
48 // linear interpolation (faster) use for jiggle-fit of chains and the like
49 float density_at_point_by_linear_interpolation(const clipper::Xmap<float> &map_in,
50 const clipper::Coord_orth &co);
51 // nearest grid point - faster yet
52 float density_at_point_by_nearest_grid(const clipper::Xmap<float> &map_in,
53 const clipper::Coord_orth &co);
54 // NXmap versions
55 float density_at_point_by_nearest_grid(const clipper::NXmap<float> &nxmap,
56 const clipper::Coord_orth &co);
57 float density_at_point_by_linear_interp(const clipper::NXmap<float> &nxmap,
58 const clipper::Coord_orth &co);
59
60 float density_at_map_point(const clipper::Xmap<float> &map_in,
61 const clipper::Coord_map &cg);
62
63 clipper::Grad_orth<double> gradient_at_point(const clipper::Xmap<float> &map_in,
64 const clipper::Coord_orth &co);
65
66 // return a variance of -1 on error.
67 std::pair<float, float> mean_and_variance(const clipper::Xmap<float> &xmap);
68
69 density_stats_info_t density_around_point(const clipper::Coord_orth &point,
70 const clipper::Xmap<float> &xmap,
71 float d);
72
73 // This is a console/testing function. Should not be used in a
74 // real graphics program. Use instead import_map_from() with a
75 // precalculated map.
76 //
77 // return 1 if map is filled, 0 if not (e.g. mtz file not found).
78 //
79 bool map_fill_from_mtz(clipper::Xmap<float> *xmap,
80 std::string mtz_file_name,
81 std::string f_col,
82 std::string phi_col,
83 std::string weight_col,
84 short int use_weights,
85 float sampling_rate=1.5);
86
87 bool map_fill_from_mtz(clipper::Xmap<float> *xmap,
88 std::string mtz_file_name,
89 std::string f_col,
90 std::string phi_col,
91 std::string weight_col,
92 short int use_weights,
93 float reso_limit_high,
94 short int use_reso_limit_high,
95 float sampling_rate=1.5);
96
97 // needed by above:
98 void filter_by_resolution(clipper::HKL_data< clipper::datatypes::F_phi<float> > *fphidata,
99 const float &reso_low,
100 const float &reso_high);
101
102
103 // return the max gridding of the map, e.g. 0.5 for a 1A map.
104 //
105 // return the maximum Angstrom/grid of the given map.
106 //
107 float max_gridding(const clipper::Xmap<float> &xmap);
108
109
110 // The sum of the density at the atom centres, optionally
111 // weighted by atomic number.
112 //
113 float map_score(mmdb::PPAtom atom_selection,
114 int n_selected_atoms,
115 const clipper::Xmap<float> &xmap,
116 short int with_atomic_weighting);
117
118 // The sum of the density at the atom centres, weighted by occupancy
119 //
120 float map_score(std::vector<mmdb::Atom *> atoms, const clipper::Xmap<float> &xmap);
121
122 float map_score_atom(mmdb::Atom *atom, const clipper::Xmap<float> &xmap);
123
124 float map_score_by_residue_specs(mmdb::Manager *mol,
125 const std::vector<residue_spec_t> &res_specs,
126 const clipper::Xmap<float> &xmap,
127 bool main_chain_only_flag = false);
128
129 clipper::Xmap<float> sharpen_blur_map(const clipper::Xmap<float> &xmap_in, float b_factor);
130
131 // sharpen/blur self
132 void sharpen_blur_map(clipper::Xmap<float> *xmap, float b_factor);
133
134 clipper::Xmap<float> sharpen_blur_map_with_resample(const clipper::Xmap<float> &xmap_in, float b_factor,
135 float resample_factor);
136
137 clipper::Xmap<float> sharpen_blur_map_with_reduced_sampling(const clipper::Xmap<float> &xmap_in, float b_factor,
138 float resample_factor);
139
140 // pass a pointer to a vector of maps that has the same size as the number of B-factors
141 //
142 void multi_sharpen_blur_map(const clipper::Xmap<float> &xmap_in,
143 const std::vector<float> &b_factors,
144 std::vector<clipper::Xmap<float> > *maps_p);
145
146 // not sure if this works ATM
147 clipper::Xmap<float> sharpen_map(const clipper::Xmap<float> &xmap_in,
148 float sharpen_factor);
149
151 class map_molecule_centre_info_t {
152 public:
154 bool success;
156 clipper::Coord_orth updated_centre;
158 float suggested_contour_level;
160 float suggested_radius;
162 double sum_of_densities; // for scoring origins
163 map_molecule_centre_info_t() {
164 success = false;
165 sum_of_densities = -1;
166 suggested_contour_level = 0.0;
167 suggested_radius = -1;
168 }
169 };
170
171 map_molecule_centre_info_t map_molecule_centre(const clipper::Xmap<float> &xmap);
172
173 map_molecule_centre_info_t map_molecule_recentre_from_position(const clipper::Xmap<float> &xmap,
174 const clipper::Coord_orth &current_centre);
175
176 // if n_bins is -1, let the function decide how many bins
177 //
178 // actually, we return bins of amplitude squares.
179 std::vector<amplitude_vs_resolution_point>
180 amplitude_vs_resolution(const clipper::Xmap<float> &xmap_in, int n_bins = -1);
181
182 // pass a flag for the resolution limit saying if this limit should be used.
183 // rule of thumb: low resolution limit 0.12
184 float b_factor(const std::vector<amplitude_vs_resolution_point> &fsqrd_data,
185 std::pair<bool, float> reso_low_invresolsq = std::pair<bool, float>(false, -1),
186 std::pair<bool, float> reso_higy_invresolsq = std::pair<bool, float>(false, -1));
187
188 clipper::Xmap<float> transform_map(const clipper::Xmap<float> &xmap_in,
189 const clipper::Spacegroup &new_space_group,
190 const clipper::Cell &new_cell,
191 const clipper::RTop_orth &rtop,
192 const clipper::Coord_orth &about_pt,
193 float box_size);
194
195 clipper::Grid_sampling suggested_grid_sampling(const clipper::Grid_sampling &orig_sampling,
196 const clipper::Cell &orig_cell,
197 const clipper::Spacegroup &new_space_group,
198 const clipper::Cell &new_cell);
199
200 clipper::Xmap<float> laplacian_transform(const clipper::Xmap<float> &xmap_in);
201
202 std::vector<float> density_map_points_in_sphere(clipper::Coord_orth pt, float radius,
203 const clipper::Xmap<float> &xmap_in);
204
205 // pass a negative atom_selection to build an atom map for the whole molecule
206 //
207 clipper::Xmap<float> calc_atom_map(mmdb::Manager *mol,
208 int atom_selection_handle,
209 const clipper::Cell &cell,
210 const clipper::Spacegroup &space_group,
211 const clipper::Grid_sampling &sampling);
212
213 clipper::Xmap<float> mask_map(const clipper::Xmap<float> &xmap_in,
214 const std::vector<mmdb::Residue *> &neighbs);
215
216 clipper::Xmap<float> make_map_mask(const clipper::Spacegroup &space_group,
217 const clipper::Cell &cell,
218 const clipper::Grid_sampling &grid_sampling,
219 mmdb::Manager *mol,
220 int atom_selection_handle,
221 float radius,
222 float smooth);
223
224 // return a number less than -1 on badness
225 // (perhaps this should return the atom map and the mask map)
226 //
227 // 0: all-atoms
228 // 1: main-chain atoms if is standard amino-acid, else all atoms
229 // 2: side-chain atoms if is standard amino-acid, else all atoms
230 // 3: side-chain atoms-exclusing CB if is standard amino-acid, else all atoms
231 //
232 float map_to_model_correlation(mmdb::Manager *mol,
233 const std::vector<residue_spec_t> &specs_for_correl,
234 const std::vector<residue_spec_t> &specs_for_masking_neighbs,
235 unsigned short int atom_mask_mode,
236 float atom_radius, // for masking
237 const clipper::Xmap<float> &xmap_from_sfs);
238
239 density_correlation_stats_info_t
240 map_to_model_correlation_stats(mmdb::Manager *mol,
241 const std::vector<residue_spec_t> &specs_for_correl,
242 const std::vector<residue_spec_t> &specs_for_masking_neighbs,
243 unsigned short int atom_mask_mode,
244 float atom_radius, // for masking
245 const clipper::Xmap<float> &xmap_from_sfs,
246 map_stats_t map_stats_flag);
247
248 // the second of the pair contains the correlation for the given residue spec.
249 //
250 std::vector<std::pair<residue_spec_t, float> >
251 map_to_model_correlation_per_residue(mmdb::Manager *mol,
252 const std::vector<residue_spec_t> &specs,
253 unsigned short int atom_mask_mode,
254 float atom_radius, // for masking
255 const clipper::Xmap<float> &xmap_from_sfs);
256
257 std::map<coot::residue_spec_t, density_stats_info_t>
258 map_to_model_correlation_stats_per_residue(mmdb::Manager *mol,
259 const std::vector<residue_spec_t> &specs,
260 unsigned short int atom_mask_mode,
261 float atom_radius, // for masking
262 const clipper::Xmap<float> &xmap);
263
264 // n_residues_per_run should be an odd number more than 2 (say 11)
265 //
266 std::pair<std::map<coot::residue_spec_t, density_correlation_stats_info_t>, std::map<coot::residue_spec_t, density_correlation_stats_info_t> >
267 map_to_model_correlation_stats_per_residue_run(mmdb::Manager *mol,
268 const std::string &chain_id,
269 const clipper::Xmap<float> &xmap,
270 unsigned int n_residues_per_run,
271 bool exclude_CON,
272 float atom_mask_radius=2.8,
273 float NOC_mask_radius=1.8); // optimized on strepavidin
274
275 // helper
276 std::pair<clipper::Coord_frac, clipper::Coord_frac>
277 find_struct_fragment_coord_fracs_v2(const std::pair<clipper::Coord_orth, clipper::Coord_orth> &selection_extents,
278 const clipper::Cell &cell);
279
280
281 // which uses these for map statistics aggregation
282 class map_stats_holder_helper_t {
283 public:
284 double sum_x;
285 double sum_x_squared;
286 double sum_y;
287 double sum_y_squared;
288 double sum_xy;
289 int n;
290 map_stats_holder_helper_t() {
291 sum_x = 0;
292 sum_x_squared = 0;
293 sum_y = 0;
294 sum_y_squared = 0;
295 sum_xy = 0;
296 n = 0;
297 }
298 void add_xy(const double &x, const double &y) {
299 sum_x += x;
300 sum_y += y;
301 sum_x_squared += x*x;
302 sum_y_squared += y*y;
303 sum_xy += x*y;
304 n++;
305 }
306 };
307
308
309 // should this be here, or is it heavy?
310 std::vector<std::pair<double, double> >
311 qq_plot_for_map_over_model(mmdb::Manager *mol,
312 const std::vector<coot::residue_spec_t> &specs,
313 const std::vector<coot::residue_spec_t> &nb_residues,
314 int atom_mask_mode,
315 const clipper::Xmap<float> &xmap);
316
317 // return a map and its standard deviation. scale is applied to
318 // map_in_2 before substraction.
319 std::pair<clipper::Xmap<float>, float>
320 difference_map(const clipper::Xmap<float> &xmap_in_1,
321 const clipper::Xmap<float> &xmap_in_2,
322 float map_scale);
323
324 // like above, but average
325 clipper::Xmap<float>
326 average_map(const std::vector<std::pair<clipper::Xmap<float>, float> > &maps_and_scales_vec);
327
328
329 // like above, but variance
330 clipper::Xmap<float> variance_map(const std::vector<std::pair<clipper::Xmap<float>, float> > &maps_and_scales_vec);
331
332 // Similar to average_map() but modify the map, don't return a new one
333 // Also this function presumes that the maps have the same gridding (which makes it faster)
334 //
335 void
336 regen_weighted_map(clipper::Xmap<float> *xmap_in,
337 const std::vector<std::pair<clipper::Xmap<float> *, float> > &maps_and_scales_vec);
338
339 // Spin the torsioned atom round the rotatable bond and find the
340 // orientation (in degrees) from the current position that is in
341 // the highest density.
342 //
343 // return a torsion
344 std::pair<float, float> spin_search(const clipper::Xmap<float> &xmap, mmdb::Residue *res, coot::torsion tors);
345
346 // Return a map that is a copy of the given map with interpolation,
347 // with grid spacing at most 0.5A (by generated by integer scaling
348 // factor of the input map)
349 //
350 clipper::Xmap<float> reinterp_map_fine_gridding(const clipper::Xmap<float> &xmap);
351
352 // return a map that is a copy of the given map with interpolation
353 // e.g. a sampling_multiplier of 2 will double the number of grid points (in each direction).
354 //
355 clipper::Xmap<float> reinterp_map(const clipper::Xmap<float> &xmap_in, float sampling_multiplier);
356
357
358 // make a copy of map_in, but in the cell, spacegroup and gridding of reference_map
359 clipper::Xmap<float> reinterp_map(const clipper::Xmap<float> &xmap_in,
360 const clipper::Xmap<float> &reference_xmap);
361
362 // negative becomes positive and positive becomes negative.
363 // Apply an offset so that most of the map is above zero.
364 //
365 void reverse_map(clipper::Xmap<float> *xmap_p);
366
367 class map_fragment_info_t {
368 // sans recentre at origin
369 void init(const clipper::Xmap<float> &xmap,
370 const clipper::Coord_orth &centre,
371 float radius);
372 //
373 void init_making_map_centred_at_origin(const clipper::Xmap<float> &xmap,
374 const clipper::Coord_orth &centre,
375 float radius,
376 float tukey_alpha = 0.0f);
377 float box_radius_a_internal;
378 float box_radius_b_internal;
379 float box_radius_c_internal;
380 public:
381 map_fragment_info_t(const clipper::Xmap<float> &xmap,
382 const clipper::Coord_orth &centre,
383 float radius, bool centre_at_origin = false,
384 float tukey_alpha = 0.0f);
385 clipper::Xmap<float> xmap;
386 clipper::Coord_grid offset;
387 // transfer xmap (small, at origin) into xmap_p (big)
388 void unshift(clipper::Xmap<float> *xmap_p, const clipper::Coord_orth &centre);
389 void simple_origin_shift(const clipper::Xmap<float> &ip_xmap,
390 const clipper::Coord_orth &centre,
391 float radius);
392 clipper::Grid_map make_grid_map(const clipper::Xmap<float> &input_xmap,
393 const clipper::Coord_orth &centre) const;
394 };
395
396
397 //
398 class simple_residue_triple_t {
399 public:
400 mmdb::Residue *this_residue;
401 mmdb::Residue *next_residue;
402 mmdb::Residue *prev_residue;
403 std::string alt_conf;
404 simple_residue_triple_t() {
405 this_residue = 0;
406 prev_residue = 0;
407 next_residue = 0;
408 }
409 simple_residue_triple_t(mmdb::Residue *this_residue_in,
410 mmdb::Residue *prev_residue_in,
411 mmdb::Residue *next_residue_in,
412 const std::string &alt_conf_in) : alt_conf(alt_conf_in) {
413 this_residue = this_residue_in;
414 prev_residue = prev_residue_in;
415 next_residue = next_residue_in;
416 }
417 };
418
419 //
420 class residue_triple_t {
421 public:
422 mmdb::Residue *this_residue;
423 mmdb::Residue *next_residue;
424 mmdb::Residue *prev_residue;
425 std::string alt_conf;
426 residue_triple_t() {
427 this_residue = 0;
428 prev_residue = 0;
429 next_residue = 0;
430 }
431 residue_triple_t(mmdb::Residue *this_residue_in,
432 mmdb::Residue *prev_residue_in,
433 mmdb::Residue *next_residue_in,
434 const std::string &alt_conf_in) : alt_conf(alt_conf_in) {
435 this_residue = this_residue_in;
436 prev_residue = prev_residue_in;
437 next_residue = next_residue_in;
438 }
439 ~residue_triple_t() {
440 delete this_residue;
441 delete next_residue;
442 delete prev_residue;
443 }
444 residue_triple_t deep_copy() {
445 mmdb::Residue *this_residue_cp = deep_copy_this_residue(this_residue);
446 mmdb::Residue *prev_residue_cp = deep_copy_this_residue(this_residue);
447 mmdb::Residue *next_residue_cp = deep_copy_this_residue(this_residue);
448 return residue_triple_t(this_residue_cp,
449 prev_residue_cp,
450 next_residue_cp,
451 alt_conf);
452 }
453 };
454
455 class backrub_residue_triple_t : public residue_triple_t {
456
457 public:
458 // Note to self, the residue copy may need the deep_copy
459 // that does the atom index transfer too.
460
461 backrub_residue_triple_t(mmdb::Residue *this_residue_in,
462 mmdb::Residue *prev_residue_in,
463 mmdb::Residue *next_residue_in,
464 const std::string &alt_conf_in) : residue_triple_t(this_residue_in,
465 prev_residue_in,
466 next_residue_in,
467 alt_conf_in) {
468 trim_this_residue_atoms();
469 trim_prev_residue_atoms();
470 trim_next_residue_atoms();
471 }
472
473 // Delete atoms that don't have this alt conf (or "" alt conf).
474 void trim_this_residue_atoms();
475 // As above, and also delete all atoms that are not C or O
476 void trim_prev_residue_atoms();
477 // As trim_this_residue_atoms, and also delete all atoms that are not N or H.
478 void trim_next_residue_atoms();
479 void trim_residue_atoms_generic(mmdb::Residue *residue_p,
480 std::vector<std::string> keep_atom_vector,
481 bool use_keep_atom_vector);
482
483 };
484
485
486 class map_ref_triple_t {
487 public:
488 double dist_sq;
489 clipper::Xmap<float>::Map_reference_coord iw;
490 float density;
491 map_ref_triple_t(const double &d_in,
492 const clipper::Xmap<float>::Map_reference_coord &iw_in,
493 const float &den_in) {
494 dist_sq = d_in;
495 iw = iw_in;
496 density = den_in;
497 }
498 map_ref_triple_t() {}
499 bool operator<(const map_ref_triple_t &mrt) const {
500 return (mrt.dist_sq < dist_sq);
501 }
502 };
503
504
505 class segment_map {
506 enum {UNASSIGNED = -1, TOO_LOW = -2 };
507 // sorting function used by above
508 static bool compare_density_values_map_refs(const std::pair<clipper::Xmap_base::Map_reference_index, float> &v1,
509 const std::pair<clipper::Xmap_base::Map_reference_index, float> &v2);
510
511 // change values in segmented_map
512 //
513 void flood_fill_segmented_map(clipper::Xmap<std::pair<bool, int> > *segmented_map,
514 const clipper::Xmap<float> &xmap, // for Neighbours
515 const clipper::Coord_grid &seed_point,
516 int from_val, int to_val);
517
518 // return a vector of grid points as we trace the route to the
519 // local peak from start_point by steepest ascent.
520 //
521 std::vector<clipper::Coord_grid> path_to_peak(const clipper::Coord_grid &start_point,
522 const clipper::Xmap<float> &xmap_new);
523 static bool sort_segment_vec(const std::pair<int, int> &a,
524 const std::pair<int, int> &b);
525 int find_biggest_segment(const std::map<int, std::vector<clipper::Coord_grid> > &segment_id_map,
526 const std::map<int, int> &segment_id_counter_map) const;
527 // test function
528 int find_smallest_segment(const std::map<int, std::vector<clipper::Coord_grid> > &segment_id_map,
529 const std::map<int, int> &segment_id_counter_map) const;
530 void resegment_watershed_points(clipper::Xmap<int> *xmap_int,
531 const clipper::Xmap<float> &xmap) const;
532
533 public:
534 segment_map() {};
535 // Return the number of segments and the segmented map.
536 //
537 // -1 means no segment. low_level is the level below which
538 // segmentation should not occur (don't make blobs in the
539 // noise).
540 //
541 // This is Pintilie flooding (with extra watershed remapping)
542 //
543 std::pair<int, clipper::Xmap<int> > segment(const clipper::Xmap<float> &xmap_in, float low_level);
544
545 // This is the flood-down method
546 //
547 std::pair<int, clipper::Xmap<int> > segment_emsley_flood(const clipper::Xmap<float> &xmap_in,
548 float low_level);
549
550 // multi-scale segmentation. Return a segmented map.
551 //
552 std::pair<int, clipper::Xmap<int> > segment(const clipper::Xmap<float> &xmap_in,
553 float low_level,
554 float b_factor_increment, // per round
555 int n_rounds);
556 };
557
558 class soi_variance {
559 const clipper::Xmap<float> &xmap;
560 clipper::Xmap<float> make_variance_map() const;
561 clipper::Xmap<float> solvent_treatment_map() const;
562 clipper::Xmap<float> protein_treatment_map() const;
563 static void apply_variance_values(clipper::Xmap<float> &variance_map,
564 const clipper::Xmap<float> &xmap,
565 const std::vector<clipper::Coord_grid> &soi_gps,
566 const std::vector<clipper::Xmap_base::Map_reference_index> &grid_indices);
567 public:
568 soi_variance(const clipper::Xmap<float> &xmap_in) : xmap(xmap_in) { }
569 void proc(float solvent_content_frac);
570 static bool mri_var_pair_sorter(const std::pair<clipper::Xmap_base::Map_reference_index, float> &p1,
571 const std::pair<clipper::Xmap_base::Map_reference_index, float> &p2);
572 };
573
574 // attach the chain-id to each returned map
575 //
576 // you can set an informative "state" message
577 std::vector<std::pair<std::string, clipper::Xmap<float> > >
578 partition_map_by_chain(const clipper::Xmap<float> &xmap, mmdb::Manager *mol,
579 std::string *state_string_p);
580
581 bool is_EM_map(const clipper::Xmap<float> &xmap);
582
583
584 typedef std::pair<double, double> phitheta;
585
586 std::vector<phitheta> make_phi_thetas(unsigned int n_pts);
587 float average_of_sample_map_at_sphere_points(clipper::Coord_orth &centre,
588 float radius,
589 const std::vector<phitheta> &phi_thetas,
590 clipper::Xmap<float> &xmap);
591
592 std::vector<std::pair<clipper::Resolution, double> >
593 fsc(const clipper::Xmap<float> &xmap_1, const clipper::Xmap<float> &xmap_2);
594
595 // scale map_for_scaling using relion-like resolution binning
596 clipper::Xmap<float>
597 power_scale(const clipper::Xmap<float> &xmap_ref, const clipper::Xmap<float> &xmap_for_scaling);
598
599 void
600 compare_structure_factors(const clipper::Xmap<float> &xmap_1, const clipper::Xmap<float> &xmap_2);
601
602 void flip_hand(clipper::Xmap<float> *xmap_p);
603
604 // input is map and its rmsd
605 clipper::Xmap<float>
606 analyse_map_point_density_change(const std::vector<std::pair<clipper::Xmap<float> *, float> > &xmaps,
607 const clipper::Xmap<float> &xmap_for_mask);
608
609 clipper::Xmap<float> zero_dose_extrapolation(const std::vector<std::pair<clipper::Xmap<float> *, float> > &xmaps,
610 const clipper::Xmap<float> &xmap_for_mask);
611
612 clipper::Xmap<float> real_space_zero_dose_extrapolation(const std::vector<clipper::Xmap<float> *> &xmaps,
613 const clipper::Xmap<float> &xmap_for_mask);
614
615 int split_residue_using_map(mmdb::Residue *residue_p, mmdb::Manager *mol, const clipper::Xmap<float> &xmap);
616
617 std::vector<std::vector<float> >
618 get_density_on_cylinder(const clipper::Coord_orth &pt_1, const clipper::Coord_orth &pt_2,
619 const clipper::Coord_orth &pt_ref, const clipper::Xmap<float> &xmap,
620 double radius, unsigned int n_length, unsigned int n_ring);
621
622 }
623}
624
625#endif // COOT_MAP_UTILS_HH
coot::util::density_stats_info_t
Definition coot-density-stats.hh:36
coot::util::map_molecule_centre_info_t::suggested_radius
float suggested_radius
the suggested radius
Definition coot-map-utils.hh:160
coot::util::map_molecule_centre_info_t::sum_of_densities
double sum_of_densities
sum of densities - for whatever use that may be.
Definition coot-map-utils.hh:162
coot::util::map_molecule_centre_info_t::suggested_contour_level
float suggested_contour_level
suggested contour level
Definition coot-map-utils.hh:158
coot::util::map_molecule_centre_info_t::updated_centre
clipper::Coord_orth updated_centre
new centre
Definition coot-map-utils.hh:156
coot::util::map_molecule_centre_info_t::success
bool success
success flag
Definition coot-map-utils.hh:154