RDKit: RDDepictor.h Source File

| RDKit Open-source cheminformatics and machine learning.

Loading...
Searching...
No Matches
RDDepictor.h
Go to the documentation of this file.
1//
2// Copyright (C) 2003-2022 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 RDDEPICTOR_H
13#define RDDEPICTOR_H
14
15#include <GraphMol/Substruct/SubstructMatch.h>
16#include <RDGeneral/types.h>
17#include <Geometry/point.h>
18#include <boost/smart_ptr.hpp>
19
20namespace RDKit {
21class ROMol;
22}
23
24namespace RDDepict {
25
26 RDKIT_DEPICTOR_EXPORT extern bool
27 preferCoordGen; // Ignored if coordgen support isn't active
28
29typedef boost::shared_array<double> DOUBLE_SMART_PTR;
30
31 class RDKIT_DEPICTOR_EXPORT DepictException : public std::exception {
32 public:
33 DepictException(const char *msg) : _msg(msg) {}
34 DepictException(const std::string msg) : _msg(msg) {}
35 const char *what() const noexcept override { return _msg.c_str(); }
36 ~DepictException() noexcept override = default;
37
38 private:
39 std::string _msg;
40};
41
42//! \brief Set the path to the file containing the ring system templates
43/*!
44
45 \param templatePath the file path to a file containing the ring system
46 templates. Each template must be a single line in the file represented using
47 CXSMILES, and the structure should be a single ring system.
48
49 \throws DepictException if any of the templates are invalid
50*/
51void RDKIT_DEPICTOR_EXPORT
52setRingSystemTemplates(const std::string templatePath);
53
54//! \brief Add ring system templates to be used in 2D coordinate generation.
55/// If there are duplicates, the most recently added template will be used.
56/*!
57
58 \param templatePath the file path to a file containing the ring system
59 templates. Each template must be a single line in the file represented using
60 CXSMILES, and the structure should be a single ring system.
61
62 \throws DepictException if any of the templates are invalid
63*/
64void RDKIT_DEPICTOR_EXPORT
65addRingSystemTemplates(const std::string templatePath);
66
67//! \brief Load default ring system templates to be used in 2D coordinate
68//! generation
69 void RDKIT_DEPICTOR_EXPORT loadDefaultRingSystemTemplates();
70
71struct RDKIT_DEPICTOR_EXPORT Compute2DCoordParameters {
72 const RDGeom::INT_POINT2D_MAP *coordMap =
73 nullptr; //!< a map of int to Point2D, between atom IDs and their
74 //!< locations. This is the container the user needs to
75 //!< fill if he/she wants to specify coordinates for a portion
76 //!< of the molecule, defaults to 0
77 bool canonOrient = false; //!< canonicalize the orientation so that the long
78 //!< axes align with the x-axis etc.
79 bool clearConfs = true; //!< clear all existing conformations on the molecule
80 //!< before adding the 2D coordinates instead of
81 //!< simply adding to the list
82 unsigned int nFlipsPerSample = 0; //!< the number of rotatable bonds that are
83 //!< flipped at random for each sample
84 unsigned int nSamples = 0; //!< the number of samples
85 int sampleSeed = 0; //!< seed for the random sampling process
86 bool permuteDeg4Nodes = false; //!< try permuting the drawing order of bonds
87 //!< around atoms with four neighbors in order
88 //!< to improve the depiction
89 bool forceRDKit = false; //!< use RDKit to generate coordinates even if
90 //!< preferCoordGen is set to true
91 bool useRingTemplates = false; //!< whether to use ring system templates for
92 //!< generating initial coordinates
93};
94
95//! \brief Generate 2D coordinates (a depiction) for a molecule
96/*!
97
98 \param mol the molecule were are interested in
99
100 \param params parameters used for 2D coordinate generation
101
102 \return ID of the conformation added to the molecule containing the
103 2D coordinates
104
105*/
106 RDKIT_DEPICTOR_EXPORT unsigned int compute2DCoords(
107 RDKit::ROMol &mol, const Compute2DCoordParameters &params);
108
109//! \brief Generate 2D coordinates (a depiction) for a molecule
110/*!
111
112 \param mol the molecule were are interested in
113
114 \param coordMap a map of int to Point2D, between atom IDs and
115 their locations. This is the container the user needs to fill if
116 he/she wants to specify coordinates for a portion of the molecule,
117 defaults to 0
118
119 \param canonOrient canonicalize the orientation so that the long
120 axes align with the x-axis etc.
121
122 \param clearConfs clear all existing conformations on the molecule
123 before adding the 2D coordinates instead of simply adding to the
124 list
125
126 \param nFlipsPerSample - the number of rotatable bonds that are
127 flipped at random for each sample
128
129 \param nSamples - the number of samples
130
131 \param sampleSeed - seed for the random sampling process
132
133 \param permuteDeg4Nodes - try permuting the drawing order of bonds around
134 atoms with four neighbors in order to improve the depiction
135
136 \param forceRDKit - use RDKit to generate coordinates even if
137 preferCoordGen is set to true
138
139 \param useRingTemplates whether to use ring system templates for generating
140 initial coordinates
141
142 \return ID of the conformation added to the molecule containing the
143 2D coordinates
144
145*/
146 RDKIT_DEPICTOR_EXPORT unsigned int compute2DCoords(
147 RDKit::ROMol &mol, const RDGeom::INT_POINT2D_MAP *coordMap = nullptr,
148 bool canonOrient = false, bool clearConfs = true,
149 unsigned int nFlipsPerSample = 0, unsigned int nSamples = 0,
150 int sampleSeed = 0, bool permuteDeg4Nodes = false, bool forceRDKit = false,
151 bool useRingTemplates = false);
152
153//! \brief Compute the 2D coordinates such the interatom distances
154/// mimic those in a distance matrix
155/*!
156
157 This function generates 2D coordinates such that the inter-atom
158 distances mimic those specified via dmat. This is done by randomly
159 sampling(flipping) the rotatable bonds in the molecule and
160 evaluating a cost function which contains two components. The
161 first component is the sum of inverse of the squared inter-atom
162 distances, this helps in spreading the atoms far from each
163 other. The second component is the sum of squares of the
164 difference in distance between those in dmat and the generated
165 structure. The user can adjust the relative importance of the two
166 components via a adjustable parameter (see below)
167
168 ARGUMENTS:
169
170 \param mol - molecule to generate coordinates for
171
172 \param dmat - the distance matrix we want to mimic, this is a
173 symmetric N by N matrix where N is the number of atoms in mol. All
174 negative entries in dmat are ignored.
175
176 \param canonOrient - canonicalize the orientation after the 2D
177 embedding is done
178
179 \param clearConfs - clear any previously existing conformations on
180 mol before adding a conformation
181
182 \param weightDistMat - A value between 0.0 and 1.0, this
183 determines the importance of mimicking the inter atoms
184 distances in dmat. (1.0 - weightDistMat) is the weight associated
185 to spreading out the structure (density) in the cost function
186
187 \param nFlipsPerSample - the number of rotatable bonds that are
188 flipped at random for each sample
189
190 \param nSamples - the number of samples
191
192 \param sampleSeed - seed for the random sampling process
193
194 \param permuteDeg4Nodes - try permuting the drawing order of bonds around
195 atoms with four neighbors in order to improve the depiction
196
197 \param forceRDKit - use RDKit to generate coordinates even if
198 preferCoordGen is set to true
199
200 \return ID of the conformation added to the molecule containing the
201 2D coordinates
202
203
204*/
205 RDKIT_DEPICTOR_EXPORT unsigned int compute2DCoordsMimicDistMat(
206 RDKit::ROMol &mol, const DOUBLE_SMART_PTR *dmat = nullptr,
207 bool canonOrient = true, bool clearConfs = true, double weightDistMat = 0.5,
208 unsigned int nFlipsPerSample = 3, unsigned int nSamples = 100,
209 int sampleSeed = 25, bool permuteDeg4Nodes = true, bool forceRDKit = false);
210
211 struct RDKIT_DEPICTOR_EXPORT ConstrainedDepictionParams {
212 //! if false (default), a DepictException is thrown if the molecule
213 /// does not have a substructure match to the reference;
214 /// if true, an unconstrained depiction will be generated
215 bool acceptFailure = false;
216 //! if true, use RDKit to generate coordinates even if preferCoordGen
217 /// is set to true; defaults to false
218 bool forceRDKit = false;
219 //! if true, terminal dummy atoms in the reference are ignored
220 /// if they match an implicit hydrogen in the molecule or if they are
221 /// attached to a query atom; defaults to false
222 bool allowRGroups = false;
223 //! if false (default), a part of the molecule is hard-constrained
224 /// to have the same coordinates as the reference, and the rest of
225 // the molecule is built around it; if true, coordinates
226 /// from conformation existingConfId are preserved (if they exist)
227 /// or generated without constraints (if they do not exist), then
228 /// the conformation is rigid-body aligned to the reference
229 bool alignOnly = false;
230 //! if true (default), existing wedging information will be updated
231 /// or cleared as required; if false (default), existing molblock
232 /// wedging information will always be preserved
233 bool adjustMolBlockWedging = true;
234 //! conformation id whose 2D coordinates should be
235 /// * rigid-body aligned to the reference (if alignOnly is true)
236 /// * used to determine whether existing molblock wedging information
237 /// can be preserved following the constrained depiction (if
238 /// adjustMolBlockWedging is true)
239 int existingConfId = -1;
240 bool useRingTemplates = false; //!< whether to use ring system templates for
241 //!< generating initial coordinates
242};
243
244//! \brief Compute 2D coordinates where a piece of the molecule is
245/// constrained to have the same coordinates as a reference.
246/// Correspondences between reference and molecule atom indices
247/// are determined by refMatchVect.
248/*!
249 This function generates a depiction for a molecule where a piece of the
250 molecule is constrained to have the same coordinates as a reference.
251
252 This is useful for, for example, generating depictions of SAR data
253 sets so that the cores of the molecules are all oriented the same way.
254 This overload allow to specify the (referenceAtom, molAtom) index pairs
255 which should be matched as MatchVectType. Please note that the
256 vector can be shorter than the number of atoms in the reference.
257
258 ARGUMENTS:
259
260 \param mol - the molecule to be aligned, this will come back
261 with a single conformer.
262 \param reference - a molecule with the reference atoms to align to;
263 this should have a depiction.
264 \param refMatchVect - a MatchVectType that will be used to
265 generate the atom mapping between the molecule
266 and the reference.
267 \param confId - (optional) the id of the reference conformation to use
268 \param params - (optional) an instance of ConstrainedDepictionParams
269*/
270 RDKIT_DEPICTOR_EXPORT void generateDepictionMatching2DStructure(
271 RDKit::ROMol &mol, const RDKit::ROMol &reference,
272 const RDKit::MatchVectType &refMatchVect, int confId = -1,
273 const ConstrainedDepictionParams &params = ConstrainedDepictionParams());
274
275//! \brief Overload
276/*!
277 ARGUMENTS:
278
279 \param mol - the molecule to be aligned, this will come back
280 with a single conformer.
281 \param reference - a molecule with the reference atoms to align to;
282 this should have a depiction.
283 \param refMatchVect - a MatchVectType that will be used to
284 generate the atom mapping between the molecule
285 and the reference.
286 \param confId - the id of the reference conformation to use
287 \param forceRDKit - use RDKit to generate coordinates even if
288 preferCoordGen is set to true
289*/
290 RDKIT_DEPICTOR_EXPORT void generateDepictionMatching2DStructure(
291 RDKit::ROMol &mol, const RDKit::ROMol &reference,
292 const RDKit::MatchVectType &refMatchVect, int confId, bool forceRDKit);
293
294//! \brief Compute 2D coordinates constrained to a reference;
295/// the constraint can be hard (default) or soft.
296/*!
297 Hard (default, ConstrainedDepictionParams::alignOnly = false):
298 Existing molecule coordinates, if present, are discarded;
299 new coordinates are generated constraining a piece of the molecule
300 to have the same coordinates as the reference, while the rest of
301 the molecule is built around it.
302 If ConstrainedDepictionParams::adjustMolBlockWedging is false
303 (default), existing molblock wedging information is always preserved.
304 If ConstrainedDepictionParams::adjustMolBlockWedging is true,
305 existing molblock wedging information is preserved in case it
306 only involves the invariant core and the core conformation has not
307 changed, while it is cleared in case the wedging is also outside
308 the invariant core, or core coordinates were changed.
309 If ConstrainedDepictionParams::acceptFailure is set to true and no
310 substructure match is found, coordinates will be recomputed from
311 scratch, hence molblock wedging information will be cleared.
312
313 Soft (ConstrainedDepictionParams::alignOnly = true):
314 Existing coordinates in the conformation identified by
315 ConstrainedDepictionParams::existingConfId are preserved if present,
316 otherwise unconstrained new coordinates are generated.
317 Subsequently, coordinates undergo a rigid-body alignment to the reference.
318 If ConstrainedDepictionParams::adjustMolBlockWedging is false
319 (default), existing molblock wedging information is always preserved.
320 If ConstrainedDepictionParams::adjustMolBlockWedging is true,
321 existing molblock wedging information is inverted in case the rigid-body
322 alignment involved a flip around the Z axis.
323
324 This is useful, for example, for generating depictions
325 of SAR data sets such that the cores of the molecules are all oriented
326 the same way.
327
328 ARGUMENTS:
329
330 \param mol - the molecule to be aligned, this will come back
331 with a single conformer.
332 \param reference - a molecule with the reference atoms to align to;
333 this should have a depiction.
334 \param confId - (optional) the id of the reference conformation to use
335 \param referencePattern - (optional) a query molecule to be used to
336 generate the atom mapping between the molecule
337 and the reference.
338 \param params - (optional) a ConstrainedDepictionParams instance
339 RETURNS:
340
341 \return MatchVectType with (queryAtomIdx, molAtomIdx) pairs used for
342 the constrained depiction
343*/
344 RDKIT_DEPICTOR_EXPORT RDKit::MatchVectType generateDepictionMatching2DStructure(
345 RDKit::ROMol &mol, const RDKit::ROMol &reference, int confId = -1,
346 const RDKit::ROMol *referencePattern =
347 static_cast<const RDKit::ROMol *>(nullptr),
348 const ConstrainedDepictionParams &params = ConstrainedDepictionParams());
349
350//! \brief Compute 2D coordinates where a piece of the molecule is
351/// constrained to have the same coordinates as a reference.
352/*!
353 This function generates a depiction for a molecule where a piece of the
354 molecule is constrained to have the same coordinates as a reference.
355
356 This is useful, for example, for generating depictions
357 of SAR data sets such that the cores of the molecules are all oriented
358 the same way.
359
360 ARGUMENTS:
361
362 \param mol - the molecule to be aligned, this will come back
363 with a single conformer.
364 \param reference - a molecule with the reference atoms to align to;
365 this should have a depiction.
366 \param confId - the id of the reference conformation to use
367 \param referencePattern - a query molecule to be used to
368 generate the atom mapping between the molecule
369 and the reference.
370 \param acceptFailure - if true, standard depictions will be
371 generated for molecules that don't have a substructure
372 match to the reference; if false, throws a
373 DepictException.
374 \param forceRDKit - (optional) use RDKit to generate coordinates even if
375 preferCoordGen is set to true
376 \param allowOptionalAttachments - (optional) if true, terminal dummy atoms in
377 the reference are ignored if they match an implicit
378 hydrogen in the molecule, and a constrained
379 depiction is still attempted
380 RETURNS:
381
382 \return MatchVectType with (queryAtomIdx, molAtomIdx) pairs used for
383 the constrained depiction
384*/
385 RDKIT_DEPICTOR_EXPORT RDKit::MatchVectType generateDepictionMatching2DStructure(
386 RDKit::ROMol &mol, const RDKit::ROMol &reference, int confId,
387 const RDKit::ROMol *referencePattern, bool acceptFailure,
388 bool forceRDKit = false, bool allowOptionalAttachments = false);
389
390//! \brief Generate a 2D depiction for a molecule where all or part of
391/// it mimics the coordinates of a 3D reference structure.
392/*!
393 Generates a depiction for a molecule where a piece of the molecule
394 is constrained to have coordinates similar to those of a 3D reference
395 structure.
396
397 ARGUMENTS:
398 \param mol - the molecule to be aligned, this will come back
399 with a single conformer containing 2D coordinates
400 \param reference - a molecule with the reference atoms to align to.
401 By default this should be the same as mol, but with
402 3D coordinates
403 \param confId - (optional) the id of the reference conformation to use
404 \param refPattern - (optional) a query molecule to map a subset of
405 the reference onto the mol, so that only some of the
406 atoms are aligned.
407 \param acceptFailure - (optional) if true, standard depictions will be
408 generated
409 for molecules that don't match the reference or the
410 referencePattern; if false, throws a DepictException.
411 \param forceRDKit - (optional) use RDKit to generate coordinates even if
412 preferCoordGen is set to true
413*/
414 RDKIT_DEPICTOR_EXPORT void generateDepictionMatching3DStructure(
415 RDKit::ROMol &mol, const RDKit::ROMol &reference, int confId = -1,
416 RDKit::ROMol *referencePattern = nullptr, bool acceptFailure = false,
417 bool forceRDKit = false);
418
419//! \brief Rotate the 2D depiction such that the majority of bonds have an
420//! angle with the X axis which is a multiple of 30 degrees.
421/*!
422
423 ARGUMENTS:
424 \param mol - the molecule to be rotated
425 \param confId - (optional) the id of the reference conformation to use
426 \param minimizeRotation - (optional) if false (the default), the molecule
427 is rotated such that the majority of bonds have an angle with the
428 X axis of 30 or 90 degrees. If true, the minimum rotation is applied
429 such that the majority of bonds have an angle with the X axis of
430 0, 30, 60, or 90 degrees, with the goal of altering the initial
431 orientation as little as possible .
432*/
433
434 RDKIT_DEPICTOR_EXPORT void straightenDepiction(RDKit::ROMol &mol,
435 int confId = -1,
436 bool minimizeRotation = false);
437
438//! \brief Normalizes the 2D depiction.
439/*!
440 If canonicalize is != 0, the depiction is subjected to a canonical
441 transformation such that its main axis is aligned along the X axis
442 (canonicalize >0, the default) or the Y axis (canonicalize <0).
443 If canonicalize is 0, no canonicalization takes place.
444 If scaleFactor is <0.0 (the default) the depiction is scaled such
445 that bond lengths conform to RDKit standards. The applied scaling
446 factor is returned.
447
448 ARGUMENTS:
449 \param mol - the molecule to be normalized
450 \param confId - (optional) the id of the reference conformation to use
451 \param canonicalize - (optional) if != 0, a canonical transformation is
452 applied: if >0 (the default), the main molecule axis is
453 aligned to the X axis, if <0 to the Y axis.
454 If 0, no canonical transformation is applied.
455 \param scaleFactor - (optional) if >0.0, the scaling factor to apply. The
456 default (-1.0) means that the depiction is automatically
457 scaled such that bond lengths are the standard RDKit
458 ones.
459 RETURNS:
460
461 \return the applied scaling factor.
462*/
463
464 RDKIT_DEPICTOR_EXPORT double normalizeDepiction(RDKit::ROMol &mol,
465 int confId = -1,
466 int canonicalize = 1,
467 double scaleFactor = -1.0);
468}; // namespace RDDepict
469
470#endif
SubstructMatch.h
RDDepict::DepictException::DepictException
DepictException(const char *msg)
Definition RDDepictor.h:33
RDDepict::DepictException::~DepictException
~DepictException() noexcept override=default
RDDepict::DepictException::DepictException
DepictException(const std::string msg)
Definition RDDepictor.h:34
RDDepict::DepictException::what
const char * what() const noexcept override
Definition RDDepictor.h:35
RDKit::ROMol
Definition ROMol.h:199
export.h
RDKIT_DEPICTOR_EXPORT
#define RDKIT_DEPICTOR_EXPORT
Definition export.h:97
RDDepict
Definition Reaction.h:477
RDDepict::DOUBLE_SMART_PTR
boost::shared_array< double > DOUBLE_SMART_PTR
Definition EmbeddedFrag.h:26
RDDepict::generateDepictionMatching2DStructure
RDKIT_DEPICTOR_EXPORT void generateDepictionMatching2DStructure(RDKit::ROMol &mol, const RDKit::ROMol &reference, const RDKit::MatchVectType &refMatchVect, int confId=-1, const ConstrainedDepictionParams &params=ConstrainedDepictionParams())
Compute 2D coordinates where a piece of the molecule is constrained to have the same coordinates as a...
RDDepict::generateDepictionMatching3DStructure
RDKIT_DEPICTOR_EXPORT void generateDepictionMatching3DStructure(RDKit::ROMol &mol, const RDKit::ROMol &reference, int confId=-1, RDKit::ROMol *referencePattern=nullptr, bool acceptFailure=false, bool forceRDKit=false)
Generate a 2D depiction for a molecule where all or part of it mimics the coordinates of a 3D referen...
RDDepict::loadDefaultRingSystemTemplates
void RDKIT_DEPICTOR_EXPORT loadDefaultRingSystemTemplates()
Load default ring system templates to be used in 2D coordinate generation.
RDDepict::normalizeDepiction
RDKIT_DEPICTOR_EXPORT double normalizeDepiction(RDKit::ROMol &mol, int confId=-1, int canonicalize=1, double scaleFactor=-1.0)
Normalizes the 2D depiction.
RDDepict::addRingSystemTemplates
void RDKIT_DEPICTOR_EXPORT addRingSystemTemplates(const std::string templatePath)
Add ring system templates to be used in 2D coordinate generation. If there are duplicates,...
RDDepict::compute2DCoords
RDKIT_DEPICTOR_EXPORT unsigned int compute2DCoords(RDKit::ROMol &mol, const Compute2DCoordParameters &params)
Generate 2D coordinates (a depiction) for a molecule.
RDDepict::straightenDepiction
RDKIT_DEPICTOR_EXPORT void straightenDepiction(RDKit::ROMol &mol, int confId=-1, bool minimizeRotation=false)
Rotate the 2D depiction such that the majority of bonds have an angle with the X axis which is a mult...
RDDepict::setRingSystemTemplates
void RDKIT_DEPICTOR_EXPORT setRingSystemTemplates(const std::string templatePath)
Set the path to the file containing the ring system templates.
RDDepict::compute2DCoordsMimicDistMat
RDKIT_DEPICTOR_EXPORT unsigned int compute2DCoordsMimicDistMat(RDKit::ROMol &mol, const DOUBLE_SMART_PTR *dmat=nullptr, bool canonOrient=true, bool clearConfs=true, double weightDistMat=0.5, unsigned int nFlipsPerSample=3, unsigned int nSamples=100, int sampleSeed=25, bool permuteDeg4Nodes=true, bool forceRDKit=false)
Compute the 2D coordinates such the interatom distances mimic those in a distance matrix.
RDDepict::preferCoordGen
RDKIT_DEPICTOR_EXPORT bool preferCoordGen
RDGeom::INT_POINT2D_MAP
std::map< int, Point2D > INT_POINT2D_MAP
Definition point.h:556
RDKit
Std stuff.
Definition Abbreviations.h:19
RDKit::MatchVectType
std::vector< std::pair< int, int > > MatchVectType
used to return matches from substructure searching, The format is (queryAtomIdx, molAtomIdx)
Definition FragFPGenerator.h:24
point.h
RDDepict::Compute2DCoordParameters
Definition RDDepictor.h:71
RDDepict::Compute2DCoordParameters::canonOrient
bool canonOrient
Definition RDDepictor.h:77
RDDepict::Compute2DCoordParameters::nSamples
unsigned int nSamples
the number of samples
Definition RDDepictor.h:84
RDDepict::Compute2DCoordParameters::forceRDKit
bool forceRDKit
Definition RDDepictor.h:89
RDDepict::Compute2DCoordParameters::permuteDeg4Nodes
bool permuteDeg4Nodes
Definition RDDepictor.h:86
RDDepict::Compute2DCoordParameters::coordMap
const RDGeom::INT_POINT2D_MAP * coordMap
Definition RDDepictor.h:72
RDDepict::Compute2DCoordParameters::sampleSeed
int sampleSeed
seed for the random sampling process
Definition RDDepictor.h:85
RDDepict::Compute2DCoordParameters::clearConfs
bool clearConfs
Definition RDDepictor.h:79
RDDepict::Compute2DCoordParameters::useRingTemplates
bool useRingTemplates
Definition RDDepictor.h:91
RDDepict::Compute2DCoordParameters::nFlipsPerSample
unsigned int nFlipsPerSample
Definition RDDepictor.h:82
RDDepict::ConstrainedDepictionParams
Definition RDDepictor.h:211
RDDepict::ConstrainedDepictionParams::acceptFailure
bool acceptFailure
Definition RDDepictor.h:215
RDDepict::ConstrainedDepictionParams::allowRGroups
bool allowRGroups
Definition RDDepictor.h:222
RDDepict::ConstrainedDepictionParams::useRingTemplates
bool useRingTemplates
Definition RDDepictor.h:240
RDDepict::ConstrainedDepictionParams::forceRDKit
bool forceRDKit
Definition RDDepictor.h:218
RDDepict::ConstrainedDepictionParams::existingConfId
int existingConfId
Definition RDDepictor.h:239
RDDepict::ConstrainedDepictionParams::alignOnly
bool alignOnly
Definition RDDepictor.h:229
RDDepict::ConstrainedDepictionParams::adjustMolBlockWedging
bool adjustMolBlockWedging
Definition RDDepictor.h:233
types.h