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