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.

bool is_vertex_vertex(size_t idx) const¶

Get if the constraint at idx is a vertex-vertex constraint.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

If the constraint at idx is a vertex-vertex constraint.

bool is_edge_vertex(size_t idx) const¶

Get if the constraint at idx is an edge-vertex constraint.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

If the constraint at idx is an edge-vertex constraint.

bool is_edge_edge(size_t idx) const¶

Get if the constraint at idx is an edge-edge constraint.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

If the constraint at idx is an edge-edge constraint.

bool is_face_vertex(size_t idx) const¶

Get if the constraint at idx is an face-vertex constraint.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

If the constraint at idx is an face-vertex constraint.

bool is_plane_vertex(size_t idx) const¶

Get if the constraint at idx is an plane-vertex constraint.

Parameters:¶

size_t idx¶

The index of the constraint.

Returns:¶

If the constraint at idx is an plane-vertex 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.

std::string to_string(const CollisionMesh& mesh,
    const Eigen::MatrixXd& vertices) const¶

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¶

Inheritence diagram for ipc::CollisionConstraint:

Collaboration diagram for ipc::CollisionConstraint:

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

Public Functions

CollisionConstraint() = default¶

CollisionConstraint(const double weight,
    const Eigen::SparseVector<double>& weight_gradient)¶

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¶

virtual void compute_shape_derivative(
    const Eigen::MatrixXd& rest_positions,
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat,
    std::vector<Eigen::Triplet<double>>& triplets) const¶

Compute the derivative of the potential gradient wrt the shape.

Public Members

double dmin = 0¶

double weight = 1¶

Eigen::SparseVector<double> weight_gradient¶

Protected Functions

virtual void compute_shape_derivative_first_term(
    const Eigen::MatrixXd& rest_positions,
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat,
    std::vector<Eigen::Triplet<double>>& triplets) const¶

Compute (∇ₓw)(∇ᵤb)ᵀ

virtual MatrixMax12d compute_shape_derivative_second_term(
    const Eigen::MatrixXd& rest_positions,
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat) const¶

Compute w ∇ₓ∇ᵤb.

Vertex-Vertex Collision Constraint¶

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

Inheritence diagram for ipc::VertexVertexConstraint:

Collaboration diagram for ipc::VertexVertexConstraint:

Public Functions

inline VertexVertexConstraint(
    const VertexVertexCandidate& candidate)¶

inline VertexVertexConstraint(const long _vertex0_id,
    const long _vertex1_id, const double _weight,
    const Eigen::SparseVector<double>& _weight_gradient)¶

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¶

Inheritence diagram for ipc::EdgeVertexConstraint:

Collaboration diagram for ipc::EdgeVertexConstraint:

Public Functions

inline EdgeVertexConstraint(const EdgeVertexCandidate& candidate)¶

inline EdgeVertexConstraint(const long _edge_id,
    const long _vertex_id, const double _weight,
    const Eigen::SparseVector<double>& _weight_gradient)¶

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¶

Inheritence diagram for ipc::EdgeEdgeConstraint:

Collaboration diagram for ipc::EdgeEdgeConstraint:

Public Functions

EdgeEdgeConstraint(const long edge0_id, const long edge1_id,
    const double eps_x,
    const EdgeEdgeDistanceType dtype = EdgeEdgeDistanceType::AUTO)¶

EdgeEdgeConstraint(const EdgeEdgeCandidate& candidate,
    const double eps_x,
    const EdgeEdgeDistanceType dtype = EdgeEdgeDistanceType::AUTO)¶

EdgeEdgeConstraint(const long edge0_id, const long edge1_id,
    const double eps_x, const double weight,
    const Eigen::SparseVector<double>& weight_gradient,
    const EdgeEdgeDistanceType dtype = EdgeEdgeDistanceType::AUTO)¶

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¶

bool operator==(const EdgeEdgeConstraint& other) const¶

bool operator!=(const EdgeEdgeConstraint& other) const¶

bool operator<(const EdgeEdgeConstraint& other) const¶

Public Members

double eps_x¶

Mollifier activation threshold.

See also

edge_edge_mollifier

EdgeEdgeDistanceType dtype¶

Cached distance type.

Some EE constraints are mollified EV or VV constraints.

Protected Functions

inline virtual EdgeEdgeDistanceType known_dtype() const override¶

virtual MatrixMax12d compute_shape_derivative_second_term(
    const Eigen::MatrixXd& rest_positions,
    const Eigen::MatrixXd& vertices, const Eigen::MatrixXi& edges,
    const Eigen::MatrixXi& faces, const double dhat) const override¶

Compute w ∇ₓ∇ᵤb.

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¶

Inheritence diagram for ipc::FaceVertexConstraint:

Collaboration diagram for ipc::FaceVertexConstraint:

Public Functions

inline FaceVertexConstraint(const FaceVertexCandidate& candidate)¶

inline FaceVertexConstraint(const long _face_id,
    const long _vertex_id, const double _weight,
    const Eigen::SparseVector<double>& _weight_gradient)¶

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¶

Inheritence 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 between the point and plane.

Parameters:¶

const VectorMax12d &point¶

Point’s position.

Returns:¶

Distance of the stencil.

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

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

the point’s positions.

Parameters:¶

const VectorMax12d &point¶

Point’s position.

Returns:¶

Distance gradient w.r.t. the point’s 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:¶

const VectorMax12d &point¶

Point’s position.

Returns:¶

Distance Hessian w.r.t. the point’s positions.