RDKit: MolDraw2DUtils.h Source File

| RDKit Open-source cheminformatics and machine learning.

Loading...
Searching...
No Matches
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 <tuple>
17
18// ****************************************************************************
19
20namespace RDKit {
21class MolDraw2D;
22
23 namespace MolDraw2DUtils {
24
25//! Does some cleanup operations on the molecule to prepare it to draw nicely
26/*
27The operations include: kekulization, addition of chiral Hs (so that we can draw
28wedges to them), wedging of bonds at chiral centers, and generation of a 2D
29conformation if the molecule does not already have a conformation
30
31\param mol: the molecule to be modified
32\param kekulize: toggles kekulization (this can fail, see below)
33\param addChiralHs: adds Hs to the graph on chiral atoms
34\param wedgeBonds: calls WedgeMolBonds()
35\param forceCoords: generates a 2D conformation even if one is present already
36\param wavyBonds: calls addWavyBondsForStereoAny() and clears other markers that
37 double bond stereo is unknown
38
39NOTE: the kekulization step can fail, throwing a MolSanitizeExecption. If this
40happens the molecule will be in an inconsistent, partially kekulized, state.
41This isn't normally a problem for molecules that have been sanitized, but can be
42problematic if the molecules have been modified post santitization.
43*/
44 RDKIT_MOLDRAW2D_EXPORT void prepareMolForDrawing(
45 RWMol &mol, bool kekulize = true, bool addChiralHs = true,
46 bool wedgeBonds = true, bool forceCoords = false, bool wavyBonds = false);
47
48//! prepare a molecule for drawing and draw it
49/*
50 \param mol: the molecule to draw
51 \param legend: (optional) the legend (to be drawn under the molecule)
52 \param highlight_atoms: (optional) vector of atom ids to highlight
53 \param highlight_atoms: (optional) vector of bond ids to highlight
54 \param highlight_atom_map: (optional) map from atomId -> DrawColour
55 providing the highlight colors. If not provided the default
56 highlight colour from \c drawOptions() will be used.
57 \param highlight_bond_map: (optional) map from bondId -> DrawColour
58 providing the highlight colors. If not provided the default
59 highlight colour from \c drawOptions() will be used.
60 \param highlight_radii: (optional) map from atomId -> radius (in molecule
61 coordinates) for the radii of atomic highlights. If not provided
62 the default value from \c drawOptions() will be used.
63 \param confId: (optional) conformer ID to be used for atomic coordinates
64
65*/
66 RDKIT_MOLDRAW2D_EXPORT void prepareAndDrawMolecule(
67 MolDraw2D &drawer, const ROMol &mol, const std::string &legend = "",
68 const std::vector<int> *highlight_atoms = nullptr,
69 const std::vector<int> *highlight_bonds = nullptr,
70 const std::map<int, DrawColour> *highlight_atom_map = nullptr,
71 const std::map<int, DrawColour> *highlight_bond_map = nullptr,
72 const std::map<int, double> *highlight_radii = nullptr, int confId = -1,
73 bool kekulize = true, bool addChiralHs = true, bool wedgeBonds = true,
74 bool forceCoords = false, bool wavyBonds = false);
75
76 RDKIT_MOLDRAW2D_EXPORT void updateDrawerParamsFromJSON(MolDraw2D &drawer,
77 const char *json);
78 RDKIT_MOLDRAW2D_EXPORT void updateDrawerParamsFromJSON(MolDraw2D &drawer,
79 const std::string &json);
80 RDKIT_MOLDRAW2D_EXPORT void updateMolDrawOptionsFromJSON(MolDrawOptions &opts,
81 const char *json);
82 RDKIT_MOLDRAW2D_EXPORT void updateMolDrawOptionsFromJSON(
83 MolDrawOptions &opts, const std::string &json);
84
85 struct ContourParams {
86 bool setScale = true; // assumes the grid is drawn first
87 bool dashNegative = true; // use dashed lines for negative contours
88 bool fillGrid = false; // shade the grid
89 double gridResolution = 0.15; // spacing between elements of the grid
90 double contourWidth = 1.0; // linewidth for drawing contours
91 double extraGridPadding = 0.0; // extra padding (in molecule coordinates)
92 DrawColour contourColour = {0.5, 0.5, 0.5,
93 0.5}; // color for drawing contours
94 std::vector<DrawColour> colourMap = {
95 {0.557, 0.004, 0.322, 0.5},
96 {1, 1, 1, 0.5},
97 {0.153, 0.392, 0.098, 0.5}}; // similarity map color scheme
98 bool drawAsLines =
99 true; // draws the contours as continuous lines instead of line segments.
100 double coordScaleForQuantization =
101 1000.; // caling factor used to convert coordinates to ints when forming
102 // the continuous lines
103 double isovalScaleForQuantization =
104 1e6; // scaling factor used to convert isovalues to ints when forming the
105 // continuous lines
106 bool useFillThreshold =
107 false; // use a magnitude threshold to determine if a grid box is filled
108 double fillThreshold = 0.01; // magnitude threshold for filling grid boxes
109 bool fillThresholdIsFraction = true; // if true, the fill threshold is a
110 // fraction of the range of the data
111};
112
113//! Generates and draws contours for data on a grid
114/*
115 \param drawer: the MolDraw2D object to use
116 \param grid: the data to be contoured
117 \param xcoords: x positions of the grid points
118 \param ycoords: y positions of the grid points
119 \param nContours: the number of contours to draw
120 \param levels: the contours to use
121 \param ps: additional parameters controlling the contouring.
122 \param mol: molecule to be used to adjust the scale of the drawing.
123 If the \c levels argument is empty, the contour levels will be determined
124 automatically from the max and min values on the grid and \c levels will
125 be updated to include the contour levels.
126
127 If \c ps.fillGrid is set, the data on the grid will also be drawn using
128 the color scheme in \c ps.colourMap
129
130 if the \c mol argument is given, it will be used to adjust the scale of
131 drawing. This is because a common use is to draw the molecule onto
132 the contour, and it makes sense if it fits.
133
134*/
135 RDKIT_MOLDRAW2D_EXPORT void contourAndDrawGrid(
136 MolDraw2D &drawer, const double *grid, const std::vector<double> &xcoords,
137 const std::vector<double> &ycoords, size_t nContours,
138 std::vector<double> &levels, const ContourParams &ps = ContourParams(),
139 const ROMol *mol = nullptr);
140//! \overload
141 RDKIT_MOLDRAW2D_EXPORT inline void contourAndDrawGrid(
142 MolDraw2D &drawer, const double *grid, const std::vector<double> &xcoords,
143 const std::vector<double> &ycoords, size_t nContours = 10,
144 const ContourParams &ps = ContourParams(), const ROMol *mol = nullptr) {
145 std::vector<double> levels;
146 contourAndDrawGrid(drawer, grid, xcoords, ycoords, nContours, levels, ps,
147 mol);
148};
149
150//! Generates and draws contours for a set of gaussians
151/*
152 \param drawer: the MolDraw2D object to use
153 \param locs: locations of the gaussians
154 \param heights: the heights (or weights) of the gaussians
155 \param widths: the standard deviations of the gaussians
156 \param nContours: the number of contours to draw
157 \param levels: the contours to use
158 \param ps: additional parameters controlling the contouring.
159 \param mol: molecule to be used to adjust the scale of the drawing.
160
161 The values are calculated on a grid with spacing \c ps.gridResolution.
162 If \c ps.setScale is set, the grid size will be calculated based on the
163 locations of the gaussians and \c ps.extraGridPadding. Otherwise the current
164 size of the viewport will be used.
165
166 If the \c levels argument is empty, the contour levels will be determined
167 automatically from the max and min values on the grid and \c levels will
168 be updated to include the contour levels.
169
170 If \c ps.fillGrid is set, the data on the grid will also be drawn using
171 the color scheme in \c ps.colourMap
172
173 if the \c mol argument is given, it will be used to adjust the scale of
174 drawing. This is because a common use is to draw the molecule onto
175 the contour, and it makes sense if it fits.
176
177*/
178 RDKIT_MOLDRAW2D_EXPORT void contourAndDrawGaussians(
179 MolDraw2D &drawer, const std::vector<Point2D> &locs,
180 const std::vector<double> &heights, const std::vector<double> &widths,
181 size_t nContours, std::vector<double> &levels,
182 const ContourParams &ps = ContourParams(), const ROMol *mol = nullptr);
183//! \overload
184 RDKIT_MOLDRAW2D_EXPORT inline void contourAndDrawGaussians(
185 MolDraw2D &drawer, const std::vector<Point2D> &locs,
186 const std::vector<double> &heights, const std::vector<double> &widths,
187 size_t nContours = 10, const ContourParams &ps = ContourParams(),
188 const ROMol *mol = nullptr) {
189 std::vector<double> levels;
190 contourAndDrawGaussians(drawer, locs, heights, widths, nContours, levels, ps,
191 mol);
192};
193
194//! Draw a molecule to a MolDraw2D object according to ACS 1996 guidelines
195/*
196 The ACS1996 guidelines, as described at
197 https://en.wikipedia.org/wiki/Wikipedia:Manual_of_Style/Chemistry/Structure_drawing
198 A number of values in drawer.drawOptions() are changed.
199 This is designed to be used with a flexiCanvas, i.e. a MolDraw2D object
200 created with width and height -1, because it works to a fixed scale.
201 It will issue a warning if the dimensions are otherwise and the picture may
202 look sub-optimal.
203 */
204 RDKIT_MOLDRAW2D_EXPORT void drawMolACS1996(
205 MolDraw2D &drawer, const ROMol &mol, const std::string &legend,
206 const std::vector<int> *highlight_atoms,
207 const std::vector<int> *highlight_bonds,
208 const std::map<int, DrawColour> *highlight_atom_map = nullptr,
209 const std::map<int, DrawColour> *highlight_bond_map = nullptr,
210 const std::map<int, double> *highlight_radii = nullptr, int confId = -1);
211
212//! Set the draw options to produce something as close as possible to
213//! the ACS 1996 guidelines as described at
214//! https://en.wikipedia.org/wiki/Wikipedia:Manual_of_Style/Chemistry/Structure_drawing
215/*
216 \param MolDrawOptions opt - the options what will be changed
217 \param float meanBondLength - mean bond length of the molecule
218
219 Works best if the MolDraw2D object is created with width and height -1 (a
220 flexiCanvas).
221 The mean bond length may be calculated with MolDraw2DUtils::meanBondLength.
222 It is used to calculate the offset for the lines in multiple bonds.
223
224 Options changed are:
225 bondLineWidth = 0.6
226 scaleBondWidth = false
227 scalingFactor = 14.4 / meanBondLen
228 multipleBondOffset = 0.18
229 highlightBondWidthMultiplier = 32
230 setMonochromeMode - black and white
231 fixedFontSize = 10
232 additionalAtomLabelPadding = 0.066
233 fontFile - if it isn't set already, then if RDBASE is set and the file
234 exists, uses $RDBASE/Fonts/Data/FreeSans.ttf. Otherwise uses
235 BuiltinRobotoRegular.
236 */
237 RDKIT_MOLDRAW2D_EXPORT void setACS1996Options(MolDrawOptions &opts,
238 double meanBondLen = 1.0);
239 RDKIT_MOLDRAW2D_EXPORT double meanBondLength(const ROMol &mol, int confId = -1);
240} // namespace MolDraw2DUtils
241
242} // namespace RDKit
243#endif // MOLDRAW2DUTILS_H
RWMol.h
Defines the editable molecule class RWMol.
RDKit::MolDraw2D
MolDraw2D is the base class for doing 2D renderings of molecules.
Definition MolDraw2D.h:47
RDKit::ROMol
Definition ROMol.h:199
RDKit::RWMol
RWMol is a molecule class that is intended to be edited.
Definition RWMol.h:32
export.h
RDKIT_MOLDRAW2D_EXPORT
#define RDKIT_MOLDRAW2D_EXPORT
Definition export.h:313
RDKit::MolDraw2DUtils
Definition MolDraw2DUtils.h:23
RDKit::MolDraw2DUtils::updateMolDrawOptionsFromJSON
RDKIT_MOLDRAW2D_EXPORT void updateMolDrawOptionsFromJSON(MolDrawOptions &opts, const char *json)
RDKit::MolDraw2DUtils::contourAndDrawGrid
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::MolDraw2DUtils::prepareAndDrawMolecule
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, bool addChiralHs=true, bool wedgeBonds=true, bool forceCoords=false, bool wavyBonds=false)
prepare a molecule for drawing and draw it
RDKit::MolDraw2DUtils::prepareMolForDrawing
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::MolDraw2DUtils::setACS1996Options
RDKIT_MOLDRAW2D_EXPORT void setACS1996Options(MolDrawOptions &opts, double meanBondLen=1.0)
RDKit::MolDraw2DUtils::updateDrawerParamsFromJSON
RDKIT_MOLDRAW2D_EXPORT void updateDrawerParamsFromJSON(MolDraw2D &drawer, const char *json)
RDKit::MolDraw2DUtils::meanBondLength
RDKIT_MOLDRAW2D_EXPORT double meanBondLength(const ROMol &mol, int confId=-1)
RDKit::MolDraw2DUtils::drawMolACS1996
RDKIT_MOLDRAW2D_EXPORT void drawMolACS1996(MolDraw2D &drawer, const ROMol &mol, const std::string &legend, const std::vector< int > *highlight_atoms, const std::vector< int > *highlight_bonds, 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)
Draw a molecule to a MolDraw2D object according to ACS 1996 guidelines.
RDKit::MolDraw2DUtils::contourAndDrawGaussians
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
Std stuff.
Definition Abbreviations.h:19
RDKit::DrawColour
Definition MolDraw2DHelpers.h:40
RDKit::MolDraw2DUtils::ContourParams
Definition MolDraw2DUtils.h:85
RDKit::MolDraw2DUtils::ContourParams::setScale
bool setScale
Definition MolDraw2DUtils.h:86
RDKit::MolDraw2DUtils::ContourParams::coordScaleForQuantization
double coordScaleForQuantization
Definition MolDraw2DUtils.h:100
RDKit::MolDraw2DUtils::ContourParams::fillThresholdIsFraction
bool fillThresholdIsFraction
Definition MolDraw2DUtils.h:109
RDKit::MolDraw2DUtils::ContourParams::drawAsLines
bool drawAsLines
Definition MolDraw2DUtils.h:98
RDKit::MolDraw2DUtils::ContourParams::fillThreshold
double fillThreshold
Definition MolDraw2DUtils.h:108
RDKit::MolDraw2DUtils::ContourParams::fillGrid
bool fillGrid
Definition MolDraw2DUtils.h:88
RDKit::MolDraw2DUtils::ContourParams::contourColour
DrawColour contourColour
Definition MolDraw2DUtils.h:92
RDKit::MolDraw2DUtils::ContourParams::dashNegative
bool dashNegative
Definition MolDraw2DUtils.h:87
RDKit::MolDraw2DUtils::ContourParams::useFillThreshold
bool useFillThreshold
Definition MolDraw2DUtils.h:106
RDKit::MolDraw2DUtils::ContourParams::gridResolution
double gridResolution
Definition MolDraw2DUtils.h:89
RDKit::MolDraw2DUtils::ContourParams::extraGridPadding
double extraGridPadding
Definition MolDraw2DUtils.h:91
RDKit::MolDraw2DUtils::ContourParams::colourMap
std::vector< DrawColour > colourMap
Definition MolDraw2DUtils.h:94
RDKit::MolDraw2DUtils::ContourParams::isovalScaleForQuantization
double isovalScaleForQuantization
Definition MolDraw2DUtils.h:103
RDKit::MolDraw2DUtils::ContourParams::contourWidth
double contourWidth
Definition MolDraw2DUtils.h:90
RDKit::MolDrawOptions
Definition MolDraw2DHelpers.h:174