Loading...
Searching...
No Matches
point.h
Go to the documentation of this file.
//
// Copyright (C) 2003-2025 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 <RDGeneral/export.h>
#ifndef RD_POINT_H
#define RD_POINT_H
#include <cmath>
#include <vector>
#include <map>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#include <RDGeneral/Invariant.h>
#include <Numerics/Vector.h>
#include <boost/smart_ptr.hpp>
namespace RDGeom {
class RDKIT_RDGEOMETRYLIB_EXPORT Point {
// this is the virtual base class, mandating certain functions
public:
constexpr virtual ~Point() {}
virtual double operator[](unsigned int i) const = 0;
virtual double &operator[](unsigned int i) = 0;
virtual void normalize() = 0;
virtual double length() const = 0;
virtual double lengthSq() const = 0;
virtual unsigned int dimension() const = 0;
[[nodiscard]] virtual Point *copy() const = 0;
};
#ifndef _MSC_VER
// g++ (at least as of v9.3.0) generates some spurious warnings from here.
// disable them
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#endif
// typedef class Point3D Point;
class RDKIT_RDGEOMETRYLIB_EXPORT Point3D : public Point {
public:
double x{0.0};
double y{0.0};
double z{0.0};
constexpr Point3D() {}
constexpr Point3D(double xv, double yv, double zv) : x(xv), y(yv), z(zv) {}
constexpr ~Point3D() override {};
constexpr Point3D(const Point3D &other)
: Point(other), x(other.x), y(other.y), z(other.z) {}
[[nodiscard]] constexpr Point *copy() const override {
return new Point3D(*this);
}
constexpr unsigned int dimension() const override { return 3; }
constexpr double operator[](unsigned int i) const override {
switch (i) {
case 0:
return x;
case 1:
return y;
case 2:
return z;
default:
throw ValueErrorException("Invalid index on Point3D");
break;
}
}
constexpr double &operator[](unsigned int i) override {
switch (i) {
case 0:
return x;
case 1:
return y;
case 2:
return z;
default:
throw ValueErrorException("Invalid index on Point3D");
break;
}
}
constexpr Point3D &operator=(const Point3D &other) {
if (&other == this) {
return *this;
}
x = other.x;
y = other.y;
z = other.z;
return *this;
}
constexpr Point3D &operator+=(const Point3D &other) {
x += other.x;
y += other.y;
z += other.z;
return *this;
}
constexpr Point3D &operator-=(const Point3D &other) {
x -= other.x;
y -= other.y;
z -= other.z;
return *this;
}
constexpr Point3D &operator*=(double scale) {
x *= scale;
y *= scale;
z *= scale;
return *this;
}
constexpr Point3D &operator/=(double scale) {
x /= scale;
y /= scale;
z /= scale;
return *this;
}
constexpr Point3D operator-() const {
Point3D res(x, y, z);
res.x *= -1.0;
res.y *= -1.0;
res.z *= -1.0;
return res;
}
constexpr void normalize() override {
double l = this->length();
if (l < zero_tolerance) {
throw std::runtime_error("Cannot normalize a zero length vector");
}
x /= l;
y /= l;
z /= l;
}
double length() const override {
double res = x * x + y * y + z * z;
return sqrt(res);
}
constexpr double lengthSq() const override {
// double res = pow(x,2) + pow(y,2) + pow(z,2);
double res = x * x + y * y + z * z;
return res;
}
constexpr double dotProduct(const Point3D &other) const {
double res = x * (other.x) + y * (other.y) + z * (other.z);
return res;
}
/*! \brief determines the angle between a vector to this point
* from the origin and a vector to the other point.
*
* The angle is unsigned: the results of this call will always
* be between 0 and M_PI
*/
double angleTo(const Point3D &other) const {
double lsq = lengthSq() * other.lengthSq();
double dotProd = dotProduct(other);
dotProd /= sqrt(lsq);
// watch for roundoff error:
if (dotProd <= -1.0) {
return M_PI;
}
if (dotProd >= 1.0) {
return 0.0;
}
return acos(dotProd);
}
/*! \brief determines the signed angle between a vector to this point
* from the origin and a vector to the other point.
*
* The results of this call will be between 0 and M_2_PI
*/
double signedAngleTo(const Point3D &other) const {
double res = this->angleTo(other);
// check the sign of the z component of the cross product:
if ((this->x * other.y - this->y * other.x) < -zero_tolerance) {
res = 2.0 * M_PI - res;
}
return res;
}
/*! \brief Returns a normalized direction vector from this
* point to another.
*
*/
Point3D directionVector(const Point3D &other) const {
Point3D res;
res.x = other.x - x;
res.y = other.y - y;
res.z = other.z - z;
res.normalize();
return res;
}
/*! \brief Cross product of this point with the another point
*
* The order is important here
* The result is "this" cross with "other" not (other x this)
*/
constexpr Point3D crossProduct(const Point3D &other) const {
Point3D res;
res.x = y * (other.z) - z * (other.y);
res.y = -x * (other.z) + z * (other.x);
res.z = x * (other.y) - y * (other.x);
return res;
}
/*! \brief Get a unit perpendicular from this point (treating it as a vector):
*
*/
Point3D getPerpendicular() const {
Point3D res(0.0, 0.0, 0.0);
if (x) {
if (y) {
res.y = -1 * x;
res.x = y;
} else if (z) {
res.z = -1 * x;
res.x = z;
} else {
res.y = 1;
}
} else if (y) {
if (z) {
res.z = -1 * y;
res.y = z;
} else {
res.x = 1;
}
} else if (z) {
res.x = 1;
}
double l = res.length();
res /= l;
return res;
}
};
// given a set of four pts in 3D compute the dihedral angle between the
// plane of the first three points (pt1, pt2, pt3) and the plane of the
// last three points (pt2, pt3, pt4)
// the computed angle is between 0 and PI
RDKIT_RDGEOMETRYLIB_EXPORT double computeDihedralAngle(const Point3D &pt1,
const Point3D &pt2,
const Point3D &pt3,
const Point3D &pt4);
// given a set of four pts in 3D compute the signed dihedral angle between the
// plane of the first three points (pt1, pt2, pt3) and the plane of the
// last three points (pt2, pt3, pt4)
// the computed angle is between -PI and PI
RDKIT_RDGEOMETRYLIB_EXPORT double computeSignedDihedralAngle(
const Point3D &pt1, const Point3D &pt2, const Point3D &pt3,
const Point3D &pt4);
class RDKIT_RDGEOMETRYLIB_EXPORT Point2D : public Point {
public:
double x{0.0};
double y{0.0};
constexpr Point2D() {}
constexpr Point2D(double xv, double yv) : x(xv), y(yv) {}
constexpr ~Point2D() override {};
constexpr Point2D(const Point2D &other)
: Point(other), x(other.x), y(other.y) {}
//! construct from a Point3D (ignoring the z coordinate)
constexpr Point2D(const Point3D &p3d) : Point(p3d), x(p3d.x), y(p3d.y) {}
[[nodiscard]] constexpr Point *copy() const override {
return new Point2D(*this);
}
constexpr unsigned int dimension() const override { return 2; }
constexpr double operator[](unsigned int i) const override {
switch (i) {
case 0:
return x;
case 1:
return y;
default:
throw ValueErrorException("Invalid index on Point2D");
break;
}
}
constexpr double &operator[](unsigned int i) override {
switch (i) {
case 0:
return x;
case 1:
return y;
default:
throw ValueErrorException("Invalid index on Point2D");
break;
}
}
constexpr Point2D &operator=(const Point2D &other) {
x = other.x;
y = other.y;
return *this;
}
constexpr Point2D &operator+=(const Point2D &other) {
x += other.x;
y += other.y;
return *this;
}
constexpr Point2D &operator-=(const Point2D &other) {
x -= other.x;
y -= other.y;
return *this;
}
constexpr Point2D &operator*=(double scale) {
x *= scale;
y *= scale;
return *this;
}
constexpr Point2D &operator/=(double scale) {
x /= scale;
y /= scale;
return *this;
}
constexpr Point2D operator-() const {
Point2D res(x, y);
res.x *= -1.0;
res.y *= -1.0;
return res;
}
void normalize() override {
double ln = this->length();
if (ln < zero_tolerance) {
throw std::runtime_error("Cannot normalize a zero length vector");
}
x /= ln;
y /= ln;
}
constexpr void rotate90() {
double temp = x;
x = -y;
y = temp;
}
double length() const override {
// double res = pow(x,2) + pow(y,2);
double res = x * x + y * y;
return sqrt(res);
}
constexpr double lengthSq() const override {
double res = x * x + y * y;
return res;
}
constexpr double dotProduct(const Point2D &other) const {
double res = x * (other.x) + y * (other.y);
return res;
}
double angleTo(const Point2D &other) const {
auto t1 = *this;
auto t2 = other;
t1.normalize();
t2.normalize();
double dotProd = t1.dotProduct(t2);
// watch for roundoff error:
if (dotProd < -1.0) {
dotProd = -1.0;
} else if (dotProd > 1.0) {
dotProd = 1.0;
}
return acos(dotProd);
}
double signedAngleTo(const Point2D &other) const {
double res = this->angleTo(other);
if ((this->x * other.y - this->y * other.x) < -zero_tolerance) {
res = 2.0 * M_PI - res;
}
return res;
}
Point2D directionVector(const Point2D &other) const {
Point2D res;
res.x = other.x - x;
res.y = other.y - y;
res.normalize();
return res;
}
};
class RDKIT_RDGEOMETRYLIB_EXPORT PointND : public Point {
public:
typedef boost::shared_ptr<RDNumeric::Vector<double>> VECT_SH_PTR;
PointND(unsigned int dim) {
RDNumeric::Vector<double> *nvec = new RDNumeric::Vector<double>(dim, 0.0);
dp_storage.reset(nvec);
}
PointND(const PointND &other) : Point(other) {
RDNumeric::Vector<double> *nvec =
new RDNumeric::Vector<double>(*other.getStorage());
dp_storage.reset(nvec);
}
Point *copy() const override { return new PointND(*this); }
~PointND() override = default;
inline double operator[](unsigned int i) const override {
return dp_storage.get()->getVal(i);
}
inline double &operator[](unsigned int i) override {
return (*dp_storage.get())[i];
}
inline void normalize() override { dp_storage.get()->normalize(); }
inline double length() const override { return dp_storage.get()->normL2(); }
inline double lengthSq() const override {
return dp_storage.get()->normL2Sq();
}
unsigned int dimension() const override { return dp_storage.get()->size(); }
PointND &operator=(const PointND &other) {
if (this == &other) {
return *this;
}
RDNumeric::Vector<double> *nvec =
new RDNumeric::Vector<double>(*other.getStorage());
dp_storage.reset(nvec);
return *this;
}
PointND &operator+=(const PointND &other) {
(*dp_storage.get()) += (*other.getStorage());
return *this;
}
PointND &operator-=(const PointND &other) {
(*dp_storage.get()) -= (*other.getStorage());
return *this;
}
PointND &operator*=(double scale) {
(*dp_storage.get()) *= scale;
return *this;
}
PointND &operator/=(double scale) {
(*dp_storage.get()) /= scale;
return *this;
}
PointND directionVector(const PointND &other) {
PRECONDITION(this->dimension() == other.dimension(),
"Point dimensions do not match");
PointND np(other);
np -= (*this);
np.normalize();
return np;
}
double dotProduct(const PointND &other) const {
return dp_storage.get()->dotProduct(*other.getStorage());
}
double angleTo(const PointND &other) const {
double dp = this->dotProduct(other);
double n1 = this->length();
double n2 = other.length();
if ((n1 > 1.e-8) && (n2 > 1.e-8)) {
dp /= (n1 * n2);
}
if (dp < -1.0) {
dp = -1.0;
} else if (dp > 1.0) {
dp = 1.0;
}
return acos(dp);
}
private:
VECT_SH_PTR dp_storage;
inline const RDNumeric::Vector<double> *getStorage() const {
return dp_storage.get();
}
};
#ifndef _MSC_VER
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif
typedef std::vector<RDGeom::Point *> PointPtrVect;
typedef PointPtrVect::iterator PointPtrVect_I;
typedef PointPtrVect::const_iterator PointPtrVect_CI;
typedef std::vector<RDGeom::Point3D *> Point3DPtrVect;
typedef std::vector<RDGeom::Point2D *> Point2DPtrVect;
typedef Point3DPtrVect::iterator Point3DPtrVect_I;
typedef Point3DPtrVect::const_iterator Point3DPtrVect_CI;
typedef Point2DPtrVect::iterator Point2DPtrVect_I;
typedef Point2DPtrVect::const_iterator Point2DPtrVect_CI;
typedef std::vector<const RDGeom::Point3D *> Point3DConstPtrVect;
typedef Point3DConstPtrVect::iterator Point3DConstPtrVect_I;
typedef Point3DConstPtrVect::const_iterator Point3DConstPtrVect_CI;
typedef std::vector<Point3D> POINT3D_VECT;
typedef std::vector<Point3D>::iterator POINT3D_VECT_I;
typedef std::vector<Point3D>::const_iterator POINT3D_VECT_CI;
typedef std::map<int, Point2D> INT_POINT2D_MAP;
typedef INT_POINT2D_MAP::iterator INT_POINT2D_MAP_I;
typedef INT_POINT2D_MAP::const_iterator INT_POINT2D_MAP_CI;
RDKIT_RDGEOMETRYLIB_EXPORT std::ostream &operator<<(std::ostream &target,
const RDGeom::Point &pt);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator+(const RDGeom::Point3D &p1,
const RDGeom::Point3D &p2);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator-(const RDGeom::Point3D &p1,
const RDGeom::Point3D &p2);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator*(const RDGeom::Point3D &p1,
double v);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator/(const RDGeom::Point3D &p1,
double v);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point2D operator+(const RDGeom::Point2D &p1,
const RDGeom::Point2D &p2);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point2D operator-(const RDGeom::Point2D &p1,
const RDGeom::Point2D &p2);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point2D operator*(const RDGeom::Point2D &p1,
double v);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point2D operator/(const RDGeom::Point2D &p1,
double v);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::PointND operator+(const RDGeom::PointND &p1,
const RDGeom::PointND &p2);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::PointND operator-(const RDGeom::PointND &p1,
const RDGeom::PointND &p2);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::PointND operator*(const RDGeom::PointND &p1,
double v);
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::PointND operator/(const RDGeom::PointND &p1,
double v);
} // namespace RDGeom
#endif
Invariant.h
PRECONDITION
#define PRECONDITION(expr, mess)
Definition Invariant.h:108
M_PI
#define M_PI
Definition MMFF/Params.h:25
Vector.h
zero_tolerance
static constexpr double zero_tolerance
Definition Vector.h:24
Point2D::Point2D
constexpr Point2D()
Definition point.h:289
RDGeom::Point2D
Definition point.h:284
RDGeom::Point2D::operator-
constexpr Point2D operator-() const
Definition point.h:358
RDGeom::Point2D::dotProduct
constexpr double dotProduct(const Point2D &other) const
Definition point.h:392
RDGeom::Point2D::directionVector
Point2D directionVector(const Point2D &other) const
Definition point.h:420
RDGeom::Point2D::copy
constexpr Point * copy() const override
Definition point.h:298
RDGeom::Point2D::Point2D
constexpr Point2D(const Point3D &p3d)
construct from a Point3D (ignoring the z coordinate)
Definition point.h:296
RDGeom::Point2D::Point2D
constexpr Point2D()
Definition point.h:289
RDGeom::Point2D::operator=
constexpr Point2D & operator=(const Point2D &other)
Definition point.h:328
RDGeom::Point2D::~Point2D
constexpr ~Point2D() override
Definition point.h:291
RDGeom::Point2D::Point2D
constexpr Point2D(const Point2D &other)
Definition point.h:293
RDGeom::Point2D::operator-=
constexpr Point2D & operator-=(const Point2D &other)
Definition point.h:340
RDGeom::Point2D::operator*=
constexpr Point2D & operator*=(double scale)
Definition point.h:346
RDGeom::Point2D::operator/=
constexpr Point2D & operator/=(double scale)
Definition point.h:352
RDGeom::Point2D::Point2D
constexpr Point2D(double xv, double yv)
Definition point.h:290
RDGeom::Point2D::operator+=
constexpr Point2D & operator+=(const Point2D &other)
Definition point.h:334
RDGeom::Point2D::lengthSq
constexpr double lengthSq() const override
Definition point.h:387
RDGeom::Point2D::y
double y
Definition point.h:287
RDGeom::Point2D::operator[]
constexpr double & operator[](unsigned int i) override
Definition point.h:316
RDGeom::Point2D::normalize
void normalize() override
Definition point.h:365
RDGeom::Point2D::operator[]
constexpr double operator[](unsigned int i) const override
Definition point.h:304
RDGeom::Point2D::dimension
constexpr unsigned int dimension() const override
Definition point.h:302
RDGeom::Point2D::length
double length() const override
Definition point.h:381
RDGeom::Point2D::rotate90
constexpr void rotate90()
Definition point.h:375
RDGeom::Point2D::signedAngleTo
double signedAngleTo(const Point2D &other) const
Definition point.h:412
RDGeom::Point2D::x
double x
Definition point.h:286
RDGeom::Point2D::angleTo
double angleTo(const Point2D &other) const
Definition point.h:397
RDGeom::Point3D
Definition point.h:53
RDGeom::Point3D::operator+=
constexpr Point3D & operator+=(const Point3D &other)
Definition point.h:111
RDGeom::Point3D::operator-=
constexpr Point3D & operator-=(const Point3D &other)
Definition point.h:118
RDGeom::Point3D::operator/=
constexpr Point3D & operator/=(double scale)
Definition point.h:132
RDGeom::Point3D::Point3D
constexpr Point3D(double xv, double yv, double zv)
Definition point.h:60
RDGeom::Point3D::signedAngleTo
double signedAngleTo(const Point3D &other) const
determines the signed angle between a vector to this point from the origin and a vector to the other ...
Definition point.h:201
RDGeom::Point3D::angleTo
double angleTo(const Point3D &other) const
determines the angle between a vector to this point from the origin and a vector to the other point.
Definition point.h:180
RDGeom::Point3D::~Point3D
constexpr ~Point3D() override
Definition point.h:62
RDGeom::Point3D::operator[]
constexpr double & operator[](unsigned int i) override
Definition point.h:87
RDGeom::Point3D::copy
constexpr Point * copy() const override
Definition point.h:67
RDGeom::Point3D::length
double length() const override
Definition point.h:158
RDGeom::Point3D::Point3D
constexpr Point3D(const Point3D &other)
Definition point.h:64
RDGeom::Point3D::lengthSq
constexpr double lengthSq() const override
Definition point.h:163
RDGeom::Point3D::y
double y
Definition point.h:56
RDGeom::Point3D::x
double x
Definition point.h:55
RDGeom::Point3D::z
double z
Definition point.h:57
RDGeom::Point3D::operator=
constexpr Point3D & operator=(const Point3D &other)
Definition point.h:101
RDGeom::Point3D::operator-
constexpr Point3D operator-() const
Definition point.h:139
RDGeom::Point3D::dimension
constexpr unsigned int dimension() const override
Definition point.h:71
RDGeom::Point3D::operator*=
constexpr Point3D & operator*=(double scale)
Definition point.h:125
RDGeom::Point3D::crossProduct
constexpr Point3D crossProduct(const Point3D &other) const
Cross product of this point with the another point.
Definition point.h:228
RDGeom::Point3D::dotProduct
constexpr double dotProduct(const Point3D &other) const
Definition point.h:169
RDGeom::Point3D::directionVector
Point3D directionVector(const Point3D &other) const
Returns a normalized direction vector from this point to another.
Definition point.h:214
RDGeom::Point3D::Point3D
constexpr Point3D()
Definition point.h:59
RDGeom::Point3D::operator[]
constexpr double operator[](unsigned int i) const override
Definition point.h:73
RDGeom::Point3D::normalize
constexpr void normalize() override
Definition point.h:147
RDGeom::Point3D::getPerpendicular
Point3D getPerpendicular() const
Get a unit perpendicular from this point (treating it as a vector):
Definition point.h:239
RDGeom::PointND
Definition point.h:429
RDGeom::PointND::operator+=
PointND & operator+=(const PointND &other)
Definition point.h:477
RDGeom::PointND::operator/=
PointND & operator/=(double scale)
Definition point.h:492
RDGeom::PointND::operator[]
double & operator[](unsigned int i) override
Definition point.h:452
RDGeom::PointND::length
double length() const override
Definition point.h:458
RDGeom::PointND::dimension
unsigned int dimension() const override
Definition point.h:464
RDGeom::PointND::VECT_SH_PTR
boost::shared_ptr< RDNumeric::Vector< double > > VECT_SH_PTR
Definition point.h:431
RDGeom::PointND::dotProduct
double dotProduct(const PointND &other) const
Definition point.h:506
RDGeom::PointND::~PointND
~PointND() override=default
RDGeom::PointND::operator=
PointND & operator=(const PointND &other)
Definition point.h:466
RDGeom::PointND::lengthSq
double lengthSq() const override
Definition point.h:460
RDGeom::PointND::PointND
PointND(const PointND &other)
Definition point.h:438
RDGeom::PointND::normalize
void normalize() override
Definition point.h:456
RDGeom::PointND::angleTo
double angleTo(const PointND &other) const
Definition point.h:510
RDGeom::PointND::operator*=
PointND & operator*=(double scale)
Definition point.h:487
RDGeom::PointND::operator-=
PointND & operator-=(const PointND &other)
Definition point.h:482
RDGeom::PointND::operator[]
double operator[](unsigned int i) const override
Definition point.h:448
RDGeom::PointND::copy
Point * copy() const override
Definition point.h:444
RDGeom::PointND::PointND
PointND(unsigned int dim)
Definition point.h:433
RDGeom::PointND::directionVector
PointND directionVector(const PointND &other)
Definition point.h:497
RDGeom::Point
Definition point.h:28
RDGeom::Point::lengthSq
virtual double lengthSq() const =0
RDGeom::Point::copy
virtual Point * copy() const =0
RDGeom::Point::length
virtual double length() const =0
RDGeom::Point::normalize
virtual void normalize()=0
RDGeom::Point::dimension
virtual unsigned int dimension() const =0
RDGeom::Point::~Point
virtual constexpr ~Point()
Definition point.h:31
RDGeom::Point::operator[]
virtual double operator[](unsigned int i) const =0
RDGeom::Point::operator[]
virtual double & operator[](unsigned int i)=0
RDNumeric::Vector
A class to represent vectors of numbers.
Definition Vector.h:30
ValueErrorException
Class to allow us to throw a ValueError from C++ and have it make it back to Python.
Definition Exceptions.h:41
export.h
RDKIT_RDGEOMETRYLIB_EXPORT
#define RDKIT_RDGEOMETRYLIB_EXPORT
Definition export.h:457
RDGeom
Definition TorsionAngleContribs.h:17
RDGeom::Point3DPtrVect_I
Point3DPtrVect::iterator Point3DPtrVect_I
Definition point.h:543
RDGeom::PointPtrVect
std::vector< RDGeom::Point * > PointPtrVect
Definition point.h:537
RDGeom::operator/
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator/(const RDGeom::Point3D &p1, double v)
RDGeom::PointPtrVect_CI
PointPtrVect::const_iterator PointPtrVect_CI
Definition point.h:539
RDGeom::Point3DConstPtrVect
std::vector< const RDGeom::Point3D * > Point3DConstPtrVect
Definition point.h:548
RDGeom::INT_POINT2D_MAP
std::map< int, Point2D > INT_POINT2D_MAP
Definition point.h:556
RDGeom::operator*
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator*(const RDGeom::Point3D &p1, double v)
RDGeom::Point3DConstPtrVect_I
Point3DConstPtrVect::iterator Point3DConstPtrVect_I
Definition point.h:549
RDGeom::POINT3D_VECT_I
std::vector< Point3D >::iterator POINT3D_VECT_I
Definition point.h:553
RDGeom::Point3DPtrVect_CI
Point3DPtrVect::const_iterator Point3DPtrVect_CI
Definition point.h:544
RDGeom::Point3DPtrVect
std::vector< RDGeom::Point3D * > Point3DPtrVect
Definition point.h:541
RDGeom::operator-
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator-(const RDGeom::Point3D &p1, const RDGeom::Point3D &p2)
RDGeom::Point3DConstPtrVect_CI
Point3DConstPtrVect::const_iterator Point3DConstPtrVect_CI
Definition point.h:550
RDGeom::Point2DPtrVect_I
Point2DPtrVect::iterator Point2DPtrVect_I
Definition point.h:545
RDGeom::operator<<
RDKIT_RDGEOMETRYLIB_EXPORT std::ostream & operator<<(std::ostream &target, const RDGeom::Point &pt)
RDGeom::INT_POINT2D_MAP_CI
INT_POINT2D_MAP::const_iterator INT_POINT2D_MAP_CI
Definition point.h:558
RDGeom::computeDihedralAngle
RDKIT_RDGEOMETRYLIB_EXPORT double computeDihedralAngle(const Point3D &pt1, const Point3D &pt2, const Point3D &pt3, const Point3D &pt4)
RDGeom::POINT3D_VECT_CI
std::vector< Point3D >::const_iterator POINT3D_VECT_CI
Definition point.h:554
RDGeom::INT_POINT2D_MAP_I
INT_POINT2D_MAP::iterator INT_POINT2D_MAP_I
Definition point.h:557
RDGeom::Point2DPtrVect
std::vector< RDGeom::Point2D * > Point2DPtrVect
Definition point.h:542
RDGeom::Point2DPtrVect_CI
Point2DPtrVect::const_iterator Point2DPtrVect_CI
Definition point.h:546
RDGeom::POINT3D_VECT
std::vector< Point3D > POINT3D_VECT
Definition point.h:552
RDGeom::computeSignedDihedralAngle
RDKIT_RDGEOMETRYLIB_EXPORT double computeSignedDihedralAngle(const Point3D &pt1, const Point3D &pt2, const Point3D &pt3, const Point3D &pt4)
RDGeom::operator+
RDKIT_RDGEOMETRYLIB_EXPORT RDGeom::Point3D operator+(const RDGeom::Point3D &p1, const RDGeom::Point3D &p2)
RDGeom::PointPtrVect_I
PointPtrVect::iterator PointPtrVect_I
Definition point.h:538