Collision Constraints¶

Collision Constraints¶

class CollisionConstraints;¶

Public Functions¶

inline CollisionConstraints();¶

void build(const CollisionMesh& mesh,
    const Eigen::MatrixXd& vertices, const double dhat,
    const double dmin = 0,
    const BroadPhaseMethod broad_phase_method
    = DEFAULT_BROAD_PHASE_METHOD);¶

Initialize the set of constraints used to compute the barrier potential.

Parameters:¶

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

const double dhat¶

The activation distance of the barrier.

const double dmin = 0¶

Minimum distance.

const BroadPhaseMethod broad_phase_method = DEFAULT_BROAD_PHASE_METHOD¶

Broad-phase method to use.

void build(const Candidates& candidates, const CollisionMesh& mesh,
    const Eigen::MatrixXd& vertices, const double dhat,
    const double dmin = 0);¶

Initialize the set of constraints used to compute the barrier potential.

Parameters:¶

const Candidates &candidates¶

Distance candidates from which the constraint set is built.

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

const double dhat¶

The activation distance of the barrier.

const double dmin = 0¶

Minimum distance.

double compute_potential(const CollisionMesh& mesh,
    const Eigen::MatrixXd& vertices, const double dhat) const;¶

Compute the barrier potential for a given constraint set.

Parameters:¶

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

const double dhat¶

The activation distance of the barrier.

Returns:¶

The sum of all barrier potentials (not scaled by the barrier stiffness).

Eigen::VectorXd compute_potential_gradient(
    const CollisionMesh& mesh, const Eigen::MatrixXd& vertices,
    const double dhat) const;¶

Compute the gradient of the barrier potential.

Parameters:¶

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

const double dhat¶

The activation distance of the barrier.

Returns:¶

The gradient of all barrier potentials (not scaled by the barrier stiffness). This will have a size of |vertices|.

Eigen::SparseMatrix<double> compute_potential_hessian(
    const CollisionMesh& mesh, const Eigen::MatrixXd& vertices,
    const double dhat,
    const bool project_hessian_to_psd = false) const;¶

Compute the hessian of the barrier potential.

Parameters:¶

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

const double dhat¶

The activation distance of the barrier.

const bool project_hessian_to_psd = false¶

Make sure the hessian is positive semi-definite.

Returns:¶

The hessian of all barrier potentials (not scaled by the barrier stiffness). This will have a size of |vertices|x|vertices|.

Eigen::SparseMatrix<double> compute_shape_derivative(
    const CollisionMesh& mesh, const Eigen::MatrixXd& vertices,
    const double dhat) const;¶

Compute the barrier shape derivative.

Parameters:¶

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

const double dhat¶

The activation distance of the barrier.

Throws:¶

std::runtime_error – If the collision constraints were not built with shape derivatives enabled.

Returns:¶

The derivative of the force with respect to X, the rest vertices.

double compute_minimum_distance(const CollisionMesh& mesh,
    const Eigen::MatrixXd& vertices) const;¶

Computes the minimum distance between any non-adjacent elements.

Parameters:¶

const CollisionMesh &mesh¶

The collision mesh.

const Eigen::MatrixXd &vertices¶

Vertices of the collision mesh.

Returns:¶

The minimum distance between any non-adjacent elements.

size_t size() const;¶

Get the number of collision constraints.

bool empty() const;¶

Get if the collision constraints are empty.

void clear();¶

Clear the collision constraints.

CollisionConstraint& operator[](size_t idx);¶

Get a reference to constriant idx.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

A reference to the constraint.

const CollisionConstraint& operator[](size_t idx) const;¶

Get a const reference to constriant idx.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

A const reference to the constraint.

inline bool use_convergent_formulation() const;¶

Get if the collision constraints should use the convergent formulation.

Note

If not empty, this is the current value not necessarily the value used to build the constraints.

Returns:¶

If the collision constraints should use the convergent formulation.

void set_use_convergent_formulation(
    const bool use_convergent_formulation);¶

Set if the collision constraints should use the convergent formulation.

Warning

This must be set before the constraints are built.

Parameters:¶

const bool use_convergent_formulation¶

If the collision constraints should use the convergent formulation.

inline bool are_shape_derivatives_enabled() const;¶

Get if the collision constraints are using the convergent formulation.

Note

If not empty, this is the current value not necessarily the value used to build the constraints.

Returns:¶

If the collision constraints are using the convergent formulation.

void set_are_shape_derivatives_enabled(
    const bool are_shape_derivatives_enabled);¶

Set if the collision constraints should enable shape derivative computation.

Warning

This must be set before the constraints are built.

Parameters:¶

const bool are_shape_derivatives_enabled¶

If the collision constraints should enable shape derivative computation.

Public Members¶

std::vector<VertexVertexConstraint> vv_constraints;¶

std::vector<EdgeVertexConstraint> ev_constraints;¶

std::vector<EdgeEdgeConstraint> ee_constraints;¶

std::vector<FaceVertexConstraint> fv_constraints;¶

std::vector<PlaneVertexConstraint> pv_constraints;¶

Protected Attributes¶

bool m_use_convergent_formulation = false;¶

bool m_are_shape_derivatives_enabled = false;¶

Collision Constraint¶

class CollisionConstraint : public virtual ipc::CollisionStencil;¶

Inheritance diagram for ipc::CollisionConstraint:

Collaboration diagram for ipc::CollisionConstraint:

Subclassed by ipc::EdgeEdgeConstraint, ipc::EdgeVertexConstraint, ipc::FaceVertexConstraint, ipc::PlaneVertexConstraint, ipc::VertexVertexConstraint

Public Functions¶

inline virtual ~CollisionConstraint();¶

virtual double compute_potential(const Eigen::MatrixXd& vertices,
    const Eigen::MatrixXi& edges, const Eigen::MatrixXi& faces,
    const double dhat) const;¶

virtual VectorMax12d compute_potential_gradient(
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat) const;¶

virtual MatrixMax12d compute_potential_hessian(
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat,
    const bool project_hessian_to_psd) const;¶

Public Members¶

double minimum_distance = 0;¶

double weight = 1;¶

Eigen::SparseVector<double> weight_gradient;¶

Vertex-Vertex Collision Constraint¶

class VertexVertexConstraint : public ipc::VertexVertexCandidate,
                               public ipc::CollisionConstraint;¶

Inheritance diagram for ipc::VertexVertexConstraint:

Collaboration diagram for ipc::VertexVertexConstraint:

Public Functions¶

inline VertexVertexConstraint(
    const VertexVertexCandidate& candidate);¶

VertexVertexCandidate(long vertex0_id, long vertex1_id);¶

Friends¶

template <typename H>
inline friend H AbslHashValue(
    H h, const VertexVertexConstraint& vv);¶

Edge-Vertex Collision Constraint¶

class EdgeVertexConstraint : public ipc::EdgeVertexCandidate,
                             public ipc::CollisionConstraint;¶

Inheritance diagram for ipc::EdgeVertexConstraint:

Collaboration diagram for ipc::EdgeVertexConstraint:

Public Functions¶

inline EdgeVertexConstraint(const EdgeVertexCandidate& candidate);¶

EdgeVertexCandidate(long edge_id, long vertex_id);¶

Protected Functions¶

inline virtual PointEdgeDistanceType known_dtype() const override;¶

Friends¶

template <typename H>
inline friend H AbslHashValue(H h, const EdgeVertexConstraint& ev);¶

Edge-Edge Collision Constraint¶

class EdgeEdgeConstraint : public ipc::EdgeEdgeCandidate,
                           public ipc::CollisionConstraint;¶

Inheritance diagram for ipc::EdgeEdgeConstraint:

Collaboration diagram for ipc::EdgeEdgeConstraint:

Public Functions¶

EdgeEdgeConstraint(long edge0_id, long edge1_id, double eps_x);¶

EdgeEdgeConstraint(
    const EdgeEdgeCandidate& candidate, double eps_x);¶

virtual double compute_potential(const Eigen::MatrixXd& vertices,
    const Eigen::MatrixXi& edges, const Eigen::MatrixXi& faces,
    const double dhat) const override;¶

virtual VectorMax12d compute_potential_gradient(
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat) const override;¶

virtual MatrixMax12d compute_potential_hessian(
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat,
    const bool project_hessian_to_psd) const override;¶

Public Members¶

double eps_x;¶

Friends¶

template <typename H>
inline friend H AbslHashValue(H h, const EdgeEdgeConstraint& ee);¶

Face-Vertex Collision Constraint¶

class FaceVertexConstraint : public ipc::FaceVertexCandidate,
                             public ipc::CollisionConstraint;¶

Inheritance diagram for ipc::FaceVertexConstraint:

Collaboration diagram for ipc::FaceVertexConstraint:

Public Functions¶

inline FaceVertexConstraint(const FaceVertexCandidate& candidate);¶

FaceVertexCandidate(long face_id, long vertex_id);¶

Protected Functions¶

inline virtual PointTriangleDistanceType
known_dtype() const override;¶

Friends¶

template <typename H>
inline friend H AbslHashValue(H h, const FaceVertexConstraint& fv);¶

Plane-Vertex Collision Constraint¶

class PlaneVertexConstraint : public ipc::CollisionConstraint;¶

Inheritance diagram for ipc::PlaneVertexConstraint:

Collaboration diagram for ipc::PlaneVertexConstraint:

Public Functions¶

PlaneVertexConstraint(const VectorMax3d& plane_origin,
    const VectorMax3d& plane_normal, const long vertex_id);¶

inline virtual int num_vertices() const override;¶

Get the number of vertices in the contact stencil.

inline virtual std::array<long, 4> vertex_ids(
    const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces) const override;¶

Get the vertex IDs of the contact stencil.

Parameters:¶

const Eigen::MatrixXi &edges¶

Collision mesh edges

const Eigen::MatrixXi &faces¶

Collision mesh faces

Returns:¶

The vertex IDs of the contact stencil. Size is always 4, but elements i > num_vertices() are -1.

Public Members¶

VectorMax3d plane_origin;¶

VectorMax3d plane_normal;¶

long vertex_id;¶

Protected Functions¶

virtual double compute_distance(
    const VectorMax12d& point) const override;¶

Compute the distance of the stencil.

Parameters:¶

vertices

Stencil’s vertex positions.

Returns:¶

Distance of the stencil.

virtual VectorMax12d compute_distance_gradient(
    const VectorMax12d& point) const override;¶

Compute the distance gradient of the stencil w.r.t.

the stencil’s vertex positions.

Parameters:¶

vertices

Stencil’s vertex positions.

Returns:¶

Distance gradient of the stencil w.r.t. the stencil’s vertex positions.

virtual MatrixMax12d compute_distance_hessian(
    const VectorMax12d& point) const override;¶

Compute the distance Hessian of the stencil w.r.t.

the stencil’s vertex positions.

Parameters:¶

vertices

Stencil’s vertex positions.

Returns:¶

Distance Hessian of the stencil w.r.t. the stencil’s vertex positions.