pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-03 21:44:30 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
97bb4a7f378eafa6c3a1c58ffe313957ffd1f5a3
rdkit/Code/MinimalLib/jswrapper.cpp
Paolo Tosco 97bb4a7f37 Improvements to 2D depiction and alignment/RMSD calculation (#5598) 
* update AvalonTools to version 2.0.1

* Improvements to 2D depiction and alignment/RMSD calculation
- Refactored the straightenDepiction code which is now much simpler and more readable and supports a minimizeRotation parameter
- added C++, Python and JS tests for the new minimizeRotation parameter
- refactored tests to use CalcRMS rather than an internal implementation to compute RMS deviations
- Removed duplicated code in CalcRMS() and getBestRMS() and made their APIs consistent with respect to supported parameters
  IMPORTANT NOTE: for backwards compatibility I set the CalcRMS() default for the  new symmetrizeConjugatedTerminalGroups
  to false as this parameter was not originally supported. @greg: I would be very much in favor of setting this to true instead
  if you agree, even though it might change results for existing scripts, as I think it is a much more sensible default.
- Improved documentation to clarify the difference between CalcRMS() and getBestRMS()
- Added unit tests for CalcRMS() as there was none previously
- Added tests for the additional CalcRMS() and getBestRMS() parameters
- Added a new getBestAlignmentTransform() function
- The CFFI function set_2d_coords_aligned() now returns the matching atoms similarly to the C++, Python and JS counterparts
  IMPORTANT NOTE: this required an API change for the additional char ** parameter used to return the match.
  Existing code using set_2d_coords_aligned() will fail to compile and will require a last NULL parameter to be added to compile again
- Removed duplicated code between CFFI set_2d_coords_aligned() and JS generate_aligned_coords()
- Added has_2d_coords() to the CFFI library
- generate_aligned_coords() now supports JSON parameters and the previous versions are deprecated
- set_2d_coords_aligned() and generate_aligned_coords() both support an alignOnly parameter (which defaults to false).
  If set to true, rather than re-generating a fresh 2D layout around templateMol, the existing coordinates (if any) are simply aligned
  to the provided templateMol. If the molecule has no coordinates, a set of 2D coordinates is generated independently of templateMol
  and then aligned to the provided templateMol
- avoid that when acceptFailure is false set_2d_coords_aligned() and generate_aligned_coords() overwrite existing coordinates

* - explicitly link testDepictor to MolAlign library

* - add MolAlign dependency to testDepictor (rather than to the catch test as in the previous commit)
- add a couple of tweaks

* suppress compiler warnings (1st pass)

* warnings: 2nd pass

* warnings: 3rd pass

* - alignOnly mode should also support allowRGroups

* - fixed C++ build
- added tests for allowRGroups+alignOnly combination

* changes in response to review

* added an entry to backward incompatible changes regarding set_2d_coords_aligned()

Co-authored-by: Tosco, Paolo <paolo.tosco@novartis.com>
2022-10-02 06:24:01 +02:00

593 lines
24 KiB
C++
Raw Blame History

//
//
// Copyright (C) 2019-2021 Greg Landrum and other RDKit contributors
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#include <emscripten.h>
#include <emscripten/val.h>
#include <emscripten/bind.h>
#include "minilib.h"
#include <GraphMol/MolDraw2D/MolDraw2D.h>
#include <GraphMol/MolDraw2D/MolDraw2DUtils.h>
#include <GraphMol/MolDraw2D/MolDraw2DJS.h>
using namespace RDKit;
namespace RDKit {
namespace MinimalLib {
extern std::string process_details(const std::string &details, int &width,
int &height, int &offsetx, int &offsety,
std::string &legend,
std::vector<int> &atomIds,
std::vector<int> &bondIds, bool &kekulize);
extern std::string process_rxn_details(
const std::string &details, int &width, int &height, int &offsetx,
int &offsety, std::string &legend, std::vector<int> &atomIds,
std::vector<int> &bondIds, bool &kekulize, bool &highlightByReactant,
std::vector<DrawColour> &highlightColorsReactants);
} // namespace MinimalLib
} // namespace RDKit
namespace {
std::string draw_to_canvas_with_offset(JSMol &self, emscripten::val canvas,
int offsetx, int offsety, int width,
int height) {
if (!self.d_mol) {
return "no molecule";
}
auto ctx = canvas.call<emscripten::val>("getContext", std::string("2d"));
if (width < 0) {
width = canvas["width"].as<int>();
}
if (height < 0) {
height = canvas["height"].as<int>();
}
std::unique_ptr<MolDraw2DJS> d2d(new MolDraw2DJS(width, height, ctx));
d2d->setOffset(offsetx, offsety);
MolDraw2DUtils::prepareAndDrawMolecule(*d2d, *self.d_mol);
return "";
}
std::string draw_to_canvas(JSMol &self, emscripten::val canvas, int width,
int height) {
return draw_to_canvas_with_offset(self, canvas, 0, 0, width, height);
}
std::string draw_to_canvas_with_highlights(JSMol &self, emscripten::val canvas,
const std::string &details) {
if (!self.d_mol) {
return "no molecule";
}
auto ctx = canvas.call<emscripten::val>("getContext", std::string("2d"));
int w = canvas["width"].as<int>();
int h = canvas["height"].as<int>();
std::vector<int> atomIds;
std::vector<int> bondIds;
std::string legend = "";
int offsetx = 0;
int offsety = 0;
bool kekulize = true;
if (!details.empty()) {
auto problems = MinimalLib::process_details(
details, w, h, offsetx, offsety, legend, atomIds, bondIds, kekulize);
if (!problems.empty()) {
return problems;
}
}
std::unique_ptr<MolDraw2DJS> d2d(new MolDraw2DJS(w, h, ctx));
if (!details.empty()) {
MolDraw2DUtils::updateDrawerParamsFromJSON(*d2d, details);
}
d2d->setOffset(offsetx, offsety);
MolDraw2DUtils::prepareAndDrawMolecule(*d2d, *self.d_mol, legend, &atomIds,
&bondIds, nullptr, nullptr, nullptr,
-1, kekulize);
return "";
}
std::string draw_rxn_to_canvas_with_offset(JSReaction &self,
emscripten::val canvas, int offsetx,
int offsety, int width, int height) {
if (!self.d_rxn) {
return "no reaction";
}
auto ctx = canvas.call<emscripten::val>("getContext", std::string("2d"));
if (width < 0) {
width = canvas["width"].as<int>();
}
if (height < 0) {
height = canvas["height"].as<int>();
}
std::unique_ptr<MolDraw2DJS> d2d(new MolDraw2DJS(width, height, ctx));
d2d->setOffset(offsetx, offsety);
d2d->drawReaction(*self.d_rxn);
return "";
}
std::string draw_rxn_to_canvas(JSReaction &self, emscripten::val canvas,
int width, int height) {
return draw_rxn_to_canvas_with_offset(self, canvas, 0, 0, width, height);
}
std::string draw_rxn_to_canvas_with_highlights(JSReaction &self,
emscripten::val canvas,
const std::string &details) {
if (!self.d_rxn) {
return "no reaction";
}
auto ctx = canvas.call<emscripten::val>("getContext", std::string("2d"));
int w = canvas["width"].as<int>();
int h = canvas["height"].as<int>();
std::vector<int> atomIds;
std::vector<int> bondIds;
std::string legend = "";
int offsetx = 0;
int offsety = 0;
bool kekulize = true;
bool highlightByReactant = false;
std::vector<DrawColour> highlightColorsReactants;
if (!details.empty()) {
auto problems = MinimalLib::process_rxn_details(
details, w, h, offsetx, offsety, legend, atomIds, bondIds, kekulize,
highlightByReactant, highlightColorsReactants);
if (!problems.empty()) {
return problems;
}
}
std::unique_ptr<MolDraw2DJS> d2d(new MolDraw2DJS(w, h, ctx));
if (!details.empty()) {
MolDraw2DUtils::updateDrawerParamsFromJSON(*d2d, details);
}
d2d->setOffset(offsetx, offsety);
if (!kekulize) {
d2d->drawOptions().prepareMolsBeforeDrawing = false;
}
d2d->drawReaction(*self.d_rxn, highlightByReactant,
!highlightByReactant || highlightColorsReactants.empty()
? nullptr
: &highlightColorsReactants);
return "";
}
JSMol *get_mol_no_details(const std::string &input) {
return get_mol(input, std::string());
}
emscripten::val binary_string_to_uint8array(const std::string &pkl) {
emscripten::val view(emscripten::typed_memory_view(
pkl.size(), reinterpret_cast<const unsigned char *>(pkl.c_str())));
auto res = emscripten::val::global("Uint8Array").new_(pkl.size());
res.call<void>("set", view);
return res;
}
emscripten::val get_as_uint8array(const JSMol &self) {
return binary_string_to_uint8array(self.get_pickle());
}
JSMol *get_mol_from_uint8array(const emscripten::val &pklAsUInt8Array) {
return get_mol_from_pickle(pklAsUInt8Array.as<std::string>());
}
JSReaction *get_rxn_no_details(const std::string &input) {
return get_rxn(input, std::string());
}
std::string generate_aligned_coords_deprecated(JSMol &self,
const JSMol &templateMol,
bool useCoordGen,
bool allowOptionalAttachments,
bool acceptFailure) {
static bool deprecationMsgShown = false;
if (!deprecationMsgShown) {
deprecationMsgShown = true;
std::cerr
<< "generate_aligned_coords(templateMol, useCoordGen, allowOptionalAttachments, acceptFailure) is deprecated, use generate_aligned_coords(templateMol, details) instead"
<< std::endl;
}
std::stringstream ss;
ss << "{\"useCoordGen\":" << (useCoordGen ? "true" : "false")
<< ",\"allowRGroups\":" << (allowOptionalAttachments ? "true" : "false")
<< ",\"acceptFailure\":" << (acceptFailure ? "true" : "false") << "}";
return self.generate_aligned_coords(templateMol, ss.str());
}
std::string generate_aligned_coords_deprecated(JSMol &self,
const JSMol &templateMol,
bool useCoordGen,
bool allowOptionalAttachments) {
return generate_aligned_coords_deprecated(self, templateMol, useCoordGen,
allowOptionalAttachments, true);
}
std::string generate_aligned_coords_deprecated(JSMol &self,
const JSMol &templateMol,
bool useCoordGen) {
return generate_aligned_coords_deprecated(self, templateMol, useCoordGen,
false, true);
}
std::string generate_aligned_coords_helper(JSMol &self,
const JSMol &templateMol,
const emscripten::val &param) {
if (param.typeOf().as<std::string>() == "boolean") {
return generate_aligned_coords_deprecated(self, templateMol,
param.as<bool>());
} else if (param.typeOf().as<std::string>() != "string") {
throw std::runtime_error(
"generate_aligned_coords expects a JSON string or a bool as parameter");
}
return self.generate_aligned_coords(templateMol, param.as<std::string>());
}
std::string parse_morgan_fp_param(unsigned int radius, unsigned int fplen,
const std::string &funcName) {
static std::unordered_set<std::string> deprecationMsgShown;
if (deprecationMsgShown.find(funcName) == deprecationMsgShown.end()) {
deprecationMsgShown.insert(funcName);
std::cerr << funcName << "(radius, fplen) is deprecated, use " << funcName
<< "(details) instead" << std::endl;
}
std::stringstream ss;
ss << "{\"radius\":" << radius << ",\"nBits\":" << fplen << "}";
return ss.str();
}
// DEPRECATED
std::string get_morgan_fp_deprecated(const JSMol &self, unsigned int radius,
unsigned int fplen) {
return self.get_morgan_fp(
parse_morgan_fp_param(radius, fplen, "get_morgan_fp"));
}
emscripten::val get_morgan_fp_as_uint8array(const JSMol &self,
const std::string &details) {
auto fp = self.get_morgan_fp_as_binary_text(details);
return binary_string_to_uint8array(fp);
}
emscripten::val get_morgan_fp_as_uint8array(const JSMol &self) {
return get_morgan_fp_as_uint8array(self, "{}");
}
// DEPRECATED
emscripten::val get_morgan_fp_as_uint8array(const JSMol &self,
unsigned int radius,
unsigned int fplen) {
auto fp = self.get_morgan_fp_as_binary_text(
parse_morgan_fp_param(radius, fplen, "get_morgan_fp_as_uint8array"));
return binary_string_to_uint8array(fp);
}
std::string parse_pattern_fp_param(const emscripten::val &param,
const std::string &funcName) {
static std::unordered_set<std::string> deprecationMsgShown;
std::string details;
if (param.typeOf().as<std::string>() == "number") {
unsigned int fplen = param.as<unsigned int>();
if (deprecationMsgShown.find(funcName) == deprecationMsgShown.end()) {
deprecationMsgShown.insert(funcName);
std::cerr << funcName << "(fplen) is deprecated, use " << funcName
<< "(details) instead" << std::endl;
}
std::stringstream ss;
ss << "{\"nBits\":" << fplen << "}";
details = ss.str();
} else if (param.typeOf().as<std::string>() == "string") {
details = param.as<std::string>();
} else {
throw std::runtime_error(
(funcName +
"get_pattern_fp expects a JSON string or an unsigned int as parameter")
.c_str());
}
return details;
}
std::string get_pattern_fp_helper(const JSMol &self,
const emscripten::val &param) {
auto details = parse_pattern_fp_param(param, "get_pattern_fp");
return self.get_pattern_fp(details);
}
emscripten::val get_pattern_fp_as_uint8array_helper(
const JSMol &self, const emscripten::val &param) {
auto details = parse_pattern_fp_param(param, "get_pattern_fp_as_uint8array");
auto fp = self.get_pattern_fp_as_binary_text(details);
return binary_string_to_uint8array(fp);
}
emscripten::val get_pattern_fp_as_uint8array(const JSMol &self) {
auto fp = self.get_pattern_fp_as_binary_text("{}");
return binary_string_to_uint8array(fp);
}
emscripten::val get_topological_torsion_fp_as_uint8array(
const JSMol &self, const std::string &details) {
auto fp = self.get_topological_torsion_fp_as_binary_text(details);
return binary_string_to_uint8array(fp);
}
emscripten::val get_topological_torsion_fp_as_uint8array(const JSMol &self) {
return get_topological_torsion_fp_as_uint8array(self, "{}");
}
emscripten::val get_rdkit_fp_as_uint8array(const JSMol &self,
const std::string &details) {
auto fp = self.get_rdkit_fp_as_binary_text(details);
return binary_string_to_uint8array(fp);
}
emscripten::val get_rdkit_fp_as_uint8array(const JSMol &self) {
return get_rdkit_fp_as_uint8array(self, "{}");
}
emscripten::val get_atom_pair_fp_as_uint8array(const JSMol &self,
const std::string &details) {
auto fp = self.get_atom_pair_fp_as_binary_text(details);
return binary_string_to_uint8array(fp);
}
emscripten::val get_atom_pair_fp_as_uint8array(const JSMol &self) {
return get_atom_pair_fp_as_uint8array(self, "{}");
}
#ifdef RDK_BUILD_AVALON_SUPPORT
emscripten::val get_avalon_fp_as_uint8array(const JSMol &self,
const std::string &details) {
auto fp = self.get_avalon_fp_as_binary_text(details);
return binary_string_to_uint8array(fp);
}
emscripten::val get_avalon_fp_as_uint8array(const JSMol &self) {
return get_avalon_fp_as_uint8array(self, "{}");
}
#endif
} // namespace
using namespace emscripten;
EMSCRIPTEN_BINDINGS(RDKit_minimal) {
register_vector<std::string>("StringList");
class_<JSMol>("Mol")
.function("is_valid", &JSMol::is_valid)
.function("has_coords", &JSMol::has_coords)
.function("get_smiles", &JSMol::get_smiles)
.function("get_cxsmiles", &JSMol::get_cxsmiles)
.function("get_smarts", &JSMol::get_smarts)
.function("get_cxsmarts", &JSMol::get_cxsmarts)
.function("get_molblock", &JSMol::get_molblock)
.function("get_v3Kmolblock", &JSMol::get_v3Kmolblock)
.function("get_as_uint8array", &get_as_uint8array)
.function("get_inchi", &JSMol::get_inchi)
.function("get_json", &JSMol::get_json)
.function("get_svg",
select_overload<std::string() const>(&JSMol::get_svg))
.function("get_svg",
select_overload<std::string(int, int) const>(&JSMol::get_svg))
.function("get_svg_with_highlights", &JSMol::get_svg_with_highlights)
#ifdef __EMSCRIPTEN__
.function("draw_to_canvas_with_offset", &draw_to_canvas_with_offset)
.function("draw_to_canvas", &draw_to_canvas)
.function("draw_to_canvas_with_highlights",
&draw_to_canvas_with_highlights)
.function("generate_aligned_coords",
select_overload<std::string(JSMol &, const JSMol &,
const emscripten::val &)>(
generate_aligned_coords_helper))
.function("get_morgan_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &)>(
get_morgan_fp_as_uint8array))
.function(
"get_morgan_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &, const std::string &)>(
get_morgan_fp_as_uint8array))
// DEPRECATED
.function("get_morgan_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &, unsigned int,
unsigned int)>(
get_morgan_fp_as_uint8array))
.function(
"get_pattern_fp",
select_overload<std::string(const JSMol &, const emscripten::val &)>(
get_pattern_fp_helper))
.function("get_pattern_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &)>(
get_pattern_fp_as_uint8array))
.function("get_pattern_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &,
const emscripten::val &)>(
get_pattern_fp_as_uint8array_helper))
.function("get_topological_torsion_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &)>(
get_topological_torsion_fp_as_uint8array))
.function(
"get_topological_torsion_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &, const std::string &)>(
get_topological_torsion_fp_as_uint8array))
.function("get_rdkit_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &)>(
get_rdkit_fp_as_uint8array))
.function(
"get_rdkit_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &, const std::string &)>(
get_rdkit_fp_as_uint8array))
.function("get_atom_pair_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &)>(
get_atom_pair_fp_as_uint8array))
.function(
"get_atom_pair_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &, const std::string &)>(
get_atom_pair_fp_as_uint8array))
#ifdef RDK_BUILD_AVALON_SUPPORT
.function("get_avalon_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &)>(
get_avalon_fp_as_uint8array))
.function(
"get_avalon_fp_as_uint8array",
select_overload<emscripten::val(const JSMol &, const std::string &)>(
get_avalon_fp_as_uint8array))
#endif
#endif
.function("get_substruct_match", &JSMol::get_substruct_match)
.function("get_substruct_matches", &JSMol::get_substruct_matches)
.function("get_descriptors", &JSMol::get_descriptors)
.function("get_morgan_fp",
select_overload<std::string() const>(&JSMol::get_morgan_fp))
.function("get_morgan_fp",
select_overload<std::string(const std::string &) const>(
&JSMol::get_morgan_fp))
// DEPRECATED
.function("get_morgan_fp", get_morgan_fp_deprecated)
.function("get_pattern_fp",
select_overload<std::string() const>(&JSMol::get_pattern_fp))
.function("get_topological_torsion_fp",
select_overload<std::string() const>(
&JSMol::get_topological_torsion_fp))
.function("get_topological_torsion_fp",
select_overload<std::string(const std::string &) const>(
&JSMol::get_topological_torsion_fp))
.function("get_rdkit_fp",
select_overload<std::string() const>(&JSMol::get_rdkit_fp))
.function("get_rdkit_fp",
select_overload<std::string(const std::string &) const>(
&JSMol::get_rdkit_fp))
.function("get_atom_pair_fp",
select_overload<std::string() const>(&JSMol::get_atom_pair_fp))
.function("get_atom_pair_fp",
select_overload<std::string(const std::string &) const>(
&JSMol::get_atom_pair_fp))
#ifdef RDK_BUILD_AVALON_SUPPORT
.function("get_avalon_fp",
select_overload<std::string() const>(&JSMol::get_avalon_fp))
.function("get_avalon_fp",
select_overload<std::string(const std::string &) const>(
&JSMol::get_avalon_fp))
#endif
// functionality primarily useful in ketcher
.function("get_stereo_tags", &JSMol::get_stereo_tags)
.function("get_aromatic_form", &JSMol::get_aromatic_form)
.function("get_kekule_form", &JSMol::get_kekule_form)
.function("set_new_coords",
select_overload<bool()>(&JSMol::set_new_coords))
.function("get_new_coords",
select_overload<std::string() const>(&JSMol::get_new_coords))
.function("set_new_coords",
select_overload<bool(bool)>(&JSMol::set_new_coords))
.function("get_new_coords", select_overload<std::string(bool) const>(
&JSMol::get_new_coords))
.function("has_prop", &JSMol::has_prop)
.function("get_prop_list",
select_overload<std::vector<std::string>(
bool includePrivate, bool includeComputed) const>(
&JSMol::get_prop_list))
.function(
"get_prop_list",
select_overload<std::vector<std::string>(bool includePrivate) const>(
&JSMol::get_prop_list))
.function("get_prop_list",
select_overload<std::vector<std::string>() const>(
&JSMol::get_prop_list))
.function(
"set_prop",
select_overload<bool(const std::string &, const std::string &, bool)>(
&JSMol::set_prop))
.function("set_prop",
select_overload<bool(const std::string &, const std::string &)>(
&JSMol::set_prop))
.function("get_prop", &JSMol::get_prop)
.function("generate_aligned_coords",
select_overload<std::string(const JSMol &)>(
&JSMol::generate_aligned_coords))
// DEPRECATED
.function(
"generate_aligned_coords",
select_overload<std::string(JSMol &, const JSMol &, bool, bool)>(
generate_aligned_coords_deprecated))
// DEPRECATED
.function("generate_aligned_coords",
select_overload<std::string(JSMol &, const JSMol &, bool, bool,
bool)>(
generate_aligned_coords_deprecated))
.function("condense_abbreviations",
select_overload<std::string()>(&JSMol::condense_abbreviations))
.function("condense_abbreviations",
select_overload<std::string(double, bool)>(
&JSMol::condense_abbreviations))
.function("add_hs", &JSMol::add_hs)
.function("remove_hs", &JSMol::remove_hs)
.function("normalize_depiction",
select_overload<double()>(&JSMol::normalize_depiction))
.function("normalize_depiction",
select_overload<double(int)>(&JSMol::normalize_depiction))
.function("normalize_depiction", select_overload<double(int, double)>(
&JSMol::normalize_depiction))
.function("straighten_depiction", select_overload<void()>(&JSMol::straighten_depiction))
.function("straighten_depiction", select_overload<void(bool)>(&JSMol::straighten_depiction));
class_<JSReaction>("Reaction")
#ifdef __EMSCRIPTEN__
.function("draw_to_canvas_with_offset", &draw_rxn_to_canvas_with_offset)
.function("draw_to_canvas", &draw_rxn_to_canvas)
.function("draw_to_canvas_with_highlights",
&draw_rxn_to_canvas_with_highlights)
#endif
.function("get_svg",
select_overload<std::string() const>(&JSReaction::get_svg))
.function("get_svg", select_overload<std::string(int, int) const>(
&JSReaction::get_svg))
.function("get_svg_with_highlights",
&JSReaction::get_svg_with_highlights);
class_<JSSubstructLibrary>("SubstructLibrary")
.constructor<>()
.constructor<unsigned int>()
.function("add_mol", &JSSubstructLibrary::add_mol)
.function("add_smiles", &JSSubstructLibrary::add_smiles)
.function("add_trusted_smiles", &JSSubstructLibrary::add_trusted_smiles)
.function("get_mol", &JSSubstructLibrary::get_mol, allow_raw_pointers())
.function(
"get_matches",
select_overload<std::string(const JSMol &, bool, int, int) const>(
&JSSubstructLibrary::get_matches))
.function("get_matches",
select_overload<std::string(const JSMol &, int) const>(
&JSSubstructLibrary::get_matches))
.function("get_matches",
select_overload<std::string(const JSMol &) const>(
&JSSubstructLibrary::get_matches))
.function("count_matches",
select_overload<unsigned int(const JSMol &, bool, int) const>(
&JSSubstructLibrary::count_matches))
.function("count_matches",
select_overload<unsigned int(const JSMol &) const>(
&JSSubstructLibrary::count_matches));
function("version", &version);
function("prefer_coordgen", &prefer_coordgen);
function("use_legacy_stereo_perception", &use_legacy_stereo_perception);
function("get_inchikey_for_inchi", &get_inchikey_for_inchi);
function("get_mol", &get_mol, allow_raw_pointers());
function("get_mol", &get_mol_no_details, allow_raw_pointers());
function("get_mol_from_uint8array", &get_mol_from_uint8array,
allow_raw_pointers());
function("get_mol_copy", &get_mol_copy, allow_raw_pointers());
function("get_qmol", &get_qmol, allow_raw_pointers());
function("get_rxn", &get_rxn, allow_raw_pointers());
function("get_rxn", &get_rxn_no_details, allow_raw_pointers());
}
Reference in New Issue View Git Blame Copy Permalink