Class ComputeContactPatchDerivative

include/simple/core/contact-frame.hpp:90–140

\brief Functor to compute the derivatives of a contact patch.

#ifndef SIMPLE_SKIP_COLLISION_DERIVATIVES_CONTRIBUTIONS
  /// \brief Functor to compute the derivatives of a contact patch.
  struct ComputeContactPatchDerivative : ::diffcoal::ComputeContactPatchDerivative
  {
    using Base = ::diffcoal::ComputeContactPatchDerivative;
    using GeometryObject = ::pinocchio::GeometryObject;

    ComputeContactPatchDerivative(const GeometryObject & go1, const GeometryObject & go2)
    : Base(go1.geometry.get(), go2.geometry.get())
    , go1_ptr(&go1)
    , go2_ptr(&go2)
    {
    }

    virtual ~ComputeContactPatchDerivative() {};

    virtual void run(
      const ::hpp::fcl::Transform3f & M1,
      const ::hpp::fcl::Transform3f & M2,
      const ::hpp::fcl::ContactPatch & patch,
      const ::diffcoal::ContactPatchDerivativeRequest & drequest,
      ::diffcoal::ContactPatchDerivative & dpatch) const override
    {
      typedef ::hpp::fcl::CollisionGeometry const * Pointer;
      const_cast<Pointer &>(Base::geom1) = go1_ptr->geometry.get();
      const_cast<Pointer &>(Base::geom2) = go2_ptr->geometry.get();
      return Base::run(M1, M2, patch, drequest, dpatch);
    }

    bool operator==(const ComputeContactPatchDerivative & other) const
    {
      return Base::operator==(other) && go1_ptr == other.go1_ptr && go2_ptr == other.go2_ptr; // Maybe, it would be better to just check
                                                                                              // *go2_ptr == *other.go2_ptr
    }

    bool operator!=(const ComputeContactPatchDerivative & other) const
    {
      return !(*this == other);
    }

    const GeometryObject & getGeometryObject1() const
    {
      return *go1_ptr;
    }
    const GeometryObject & getGeometryObject2() const
    {
      return *go2_ptr;
    }

  protected:
    const GeometryObject * go1_ptr;
    const GeometryObject * go2_ptr;
  };
#endif

} // namespace simple