RDKit
Open-source cheminformatics and machine learning.
MolDraw2DUtils.h
Go to the documentation of this file.
1 //
2 // Copyright (C) 2016-2021 Greg Landrum and other RDKit contributors
3 //
4 // @@ All Rights Reserved @@
5 // This file is part of the RDKit.
6 // The contents are covered by the terms of the BSD license
7 // which is included in the file license.txt, found at the root
8 // of the RDKit source tree.
9 //
10 
11 #include <RDGeneral/export.h>
12 #ifndef MOLDRAW2DUTILS_H
13 #define MOLDRAW2DUTILS_H
14 #include <GraphMol/RWMol.h>
15 
16 #include <boost/tuple/tuple.hpp>
17 
18 // ****************************************************************************
19 
20 namespace RDKit {
21 class MolDraw2D;
22 class MolDraw2DColour;
23 
24 namespace MolDraw2DUtils {
25 
26 //! Does some cleanup operations on the molecule to prepare it to draw nicely
27 /*
28 The operations include: kekulization, addition of chiral Hs (so that we can draw
29 wedges to them), wedging of bonds at chiral centers, and generation of a 2D
30 conformation if the molecule does not already have a conformation
31 
32 \param mol: the molecule to be modified
33 \param kekulize: toggles kekulization (this can fail, see below)
34 \param addChiralHs: adds Hs to the graph on chiral atoms
35 \param wedgeBonds: calls WedgeMolBonds()
36 \param forceCoords: generates a 2D conformation even if one is present already
37 \param wavyBonds: calls addWavyBondsForStereoAny() and clears other markers that
38  double bond stereo is unknown
39 
40 NOTE: the kekulization step can fail, throwing a MolSanitizeExecption. If this
41 happens the molecule will be in an inconsistent, partially kekulized, state.
42 This isn't normally a problem for molecules that have been sanitized, but can be
43 problematic if the molecules have been modified post santitization.
44 */
46  RWMol &mol, bool kekulize = true, bool addChiralHs = true,
47  bool wedgeBonds = true, bool forceCoords = false, bool wavyBonds = false);
48 
49 //! prepare a molecule for drawing and draw it
50 /*
51  \param mol: the molecule to draw
52  \param legend: (optional) the legend (to be drawn under the molecule)
53  \param highlight_atoms: (optional) vector of atom ids to highlight
54  \param highlight_atoms: (optional) vector of bond ids to highlight
55  \param highlight_atom_map: (optional) map from atomId -> DrawColour
56  providing the highlight colors. If not provided the default
57  highlight colour from \c drawOptions() will be used.
58  \param highlight_bond_map: (optional) map from bondId -> DrawColour
59  providing the highlight colors. If not provided the default
60  highlight colour from \c drawOptions() will be used.
61  \param highlight_radii: (optional) map from atomId -> radius (in molecule
62  coordinates) for the radii of atomic highlights. If not provided
63  the default value from \c drawOptions() will be used.
64  \param confId: (optional) conformer ID to be used for atomic coordinates
65 
66 */
68  MolDraw2D &drawer, const ROMol &mol, const std::string &legend = "",
69  const std::vector<int> *highlight_atoms = nullptr,
70  const std::vector<int> *highlight_bonds = nullptr,
71  const std::map<int, DrawColour> *highlight_atom_map = nullptr,
72  const std::map<int, DrawColour> *highlight_bond_map = nullptr,
73  const std::map<int, double> *highlight_radii = nullptr, int confId = -1,
74  bool kekulize = true);
75 
77  const char *json);
79  const std::string &json);
80 
81 struct ContourParams {
82  bool setScale = true; // assumes the grid is drawn first
83  bool dashNegative = true; // use dashed lines for negative contours
84  bool fillGrid = false; // shade the grid
85  double gridResolution = 0.15; // spacing between elements of the grid
86  double contourWidth = 1.0; // linewidth for drawing contours
87  double extraGridPadding = 0.0; // extra padding (in molecule coordinates)
88  DrawColour contourColour = {0.5, 0.5, 0.5,
89  0.5}; // color for drawing contours
90  std::vector<DrawColour> colourMap = {
91  {0.557, 0.004, 0.322, 0.5},
92  {1, 1, 1, 0.5},
93  {0.153, 0.392, 0.098, 0.5}}; // similarity map color scheme
94 };
95 
96 //! Generates and draws contours for data on a grid
97 /*
98  \param drawer: the MolDraw2D object to use
99  \param grid: the data to be contoured
100  \param xcoords: x positions of the grid points
101  \param ycoords: y positions of the grid points
102  \param nContours: the number of contours to draw
103  \param levels: the contours to use
104  \param ps: additional parameters controlling the contouring.
105  \param mol: molecule to be used to adjust the scale of the drawing.
106  If the \c levels argument is empty, the contour levels will be determined
107  automatically from the max and min values on the grid and \c levels will
108  be updated to include the contour levels.
109 
110  If \c ps.fillGrid is set, the data on the grid will also be drawn using
111  the color scheme in \c ps.colourMap
112 
113  if the \c mol argument is given, it will be used to adjust the scale of
114  drawing. This is because a common use is to draw the molecule onto
115  the contour, and it makes sense if it fits.
116 
117 */
119  MolDraw2D &drawer, const double *grid, const std::vector<double> &xcoords,
120  const std::vector<double> &ycoords, size_t nContours,
121  std::vector<double> &levels, const ContourParams &ps = ContourParams(),
122  const ROMol *mol = nullptr);
123 //! \overload
125  MolDraw2D &drawer, const double *grid, const std::vector<double> &xcoords,
126  const std::vector<double> &ycoords, size_t nContours = 10,
127  const ContourParams &ps = ContourParams(), const ROMol *mol = nullptr) {
128  std::vector<double> levels;
129  contourAndDrawGrid(drawer, grid, xcoords, ycoords, nContours, levels, ps,
130  mol);
131 };
132 
133 //! Generates and draws contours for a set of gaussians
134 /*
135  \param drawer: the MolDraw2D object to use
136  \param locs: locations of the gaussians
137  \param heights: the heights (or weights) of the gaussians
138  \param widths: the standard deviations of the gaussians
139  \param nContours: the number of contours to draw
140  \param levels: the contours to use
141  \param ps: additional parameters controlling the contouring.
142  \param mol: molecule to be used to adjust the scale of the drawing.
143 
144  The values are calculated on a grid with spacing \c ps.gridResolution.
145  If \c ps.setScale is set, the grid size will be calculated based on the
146  locations of the gaussians and \c ps.extraGridPadding. Otherwise the current
147  size of the viewport will be used.
148 
149  If the \c levels argument is empty, the contour levels will be determined
150  automatically from the max and min values on the grid and \c levels will
151  be updated to include the contour levels.
152 
153  If \c ps.fillGrid is set, the data on the grid will also be drawn using
154  the color scheme in \c ps.colourMap
155 
156  if the \c mol argument is given, it will be used to adjust the scale of
157  drawing. This is because a common use is to draw the molecule onto
158  the contour, and it makes sense if it fits.
159 
160 */
162  MolDraw2D &drawer, const std::vector<Point2D> &locs,
163  const std::vector<double> &heights, const std::vector<double> &widths,
164  size_t nContours, std::vector<double> &levels,
165  const ContourParams &ps = ContourParams(), const ROMol *mol = nullptr);
166 //! \overload
168  MolDraw2D &drawer, const std::vector<Point2D> &locs,
169  const std::vector<double> &heights, const std::vector<double> &widths,
170  size_t nContours = 10, const ContourParams &ps = ContourParams(),
171  const ROMol *mol = nullptr) {
172  std::vector<double> levels;
173  contourAndDrawGaussians(drawer, locs, heights, widths, nContours, levels, ps,
174  mol);
175 };
176 
177 } // namespace MolDraw2DUtils
178 } // namespace RDKit
179 #endif // MOLDRAW2DUTILS_H
Defines the editable molecule class RWMol.
MolDraw2D is the base class for doing 2D renderings of molecules.
Definition: MolDraw2D.h:47
RWMol is a molecule class that is intended to be edited.
Definition: RWMol.h:32
#define RDKIT_MOLDRAW2D_EXPORT
Definition: export.h:273
RDKIT_MOLDRAW2D_EXPORT void contourAndDrawGrid(MolDraw2D &drawer, const double *grid, const std::vector< double > &xcoords, const std::vector< double > &ycoords, size_t nContours, std::vector< double > &levels, const ContourParams &ps=ContourParams(), const ROMol *mol=nullptr)
Generates and draws contours for data on a grid.
RDKIT_MOLDRAW2D_EXPORT void prepareMolForDrawing(RWMol &mol, bool kekulize=true, bool addChiralHs=true, bool wedgeBonds=true, bool forceCoords=false, bool wavyBonds=false)
Does some cleanup operations on the molecule to prepare it to draw nicely.
RDKIT_MOLDRAW2D_EXPORT void updateDrawerParamsFromJSON(MolDraw2D &drawer, const char *json)
RDKIT_MOLDRAW2D_EXPORT void contourAndDrawGaussians(MolDraw2D &drawer, const std::vector< Point2D > &locs, const std::vector< double > &heights, const std::vector< double > &widths, size_t nContours, std::vector< double > &levels, const ContourParams &ps=ContourParams(), const ROMol *mol=nullptr)
Generates and draws contours for a set of gaussians.
RDKIT_MOLDRAW2D_EXPORT void prepareAndDrawMolecule(MolDraw2D &drawer, const ROMol &mol, const std::string &legend="", const std::vector< int > *highlight_atoms=nullptr, const std::vector< int > *highlight_bonds=nullptr, const std::map< int, DrawColour > *highlight_atom_map=nullptr, const std::map< int, DrawColour > *highlight_bond_map=nullptr, const std::map< int, double > *highlight_radii=nullptr, int confId=-1, bool kekulize=true)
prepare a molecule for drawing and draw it
Std stuff.
Definition: Abbreviations.h:18
std::vector< DrawColour > colourMap