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
20namespace RDKit {
21class MolDraw2D;
22class MolDraw2DColour;
23
24namespace MolDraw2DUtils {
25
26//! Does some cleanup operations on the molecule to prepare it to draw nicely
27/*
28The operations include: kekulization, addition of chiral Hs (so that we can draw
29wedges to them), wedging of bonds at chiral centers, and generation of a 2D
30conformation 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
40NOTE: the kekulization step can fail, throwing a MolSanitizeExecption. If this
41happens the molecule will be in an inconsistent, partially kekulized, state.
42This isn't normally a problem for molecules that have been sanitized, but can be
43problematic 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
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