Package org.robwork.sdurw_pathplanning

Class QEdgeConstraint

  • public class QEdgeConstraint
extends java.lang.Object
    Edge constraint interface.

    An edge constraint represents a path that connects a pair of
    configurations and checks if this path can be traversed.

    The edge constraint may assume that the start and end configurations are
    valid (e.g. not colliding).

    Each edge has a non-negative cost measuring the degree to which the path
    connecting the configurations has been verified. You can use the cost
    measure to for example always verify the edge for which the most of the
    path still remains to be verified. The exact meaning of the cost is
    defined by the specific subclass.

    Given an edge constraint you can construct a new edge constraint of the same
    type, but for a new pair of configurations, with
    QEdgeConstraint::instance().

    • Constructor Summary

      Constructors 
      Constructor Description
      QEdgeConstraint​(long cPtr, boolean cMemoryOwn)  

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void delete()  
      static long getCPtr​(QEdgeConstraint obj)  
      boolean inCollision​(Q start, Q end)
      True if the path from start to end can't be traversed.
      static QEdgeConstraintPtr make​(QConstraintPtr constraint, MetricQCPtr metric, double resolution)
      Discrete path verification for a linearly interpolated path.

      Performs a binary style checking of the edge with a resolution of resolution.
      The length of the edge is virtually extended to exactly match the specified
      resolution.
      static QEdgeConstraintPtr makeDefault​(QConstraintPtr constraint, DeviceCPtr device)
      Default edge constraint for a configuration constraint and a
      device.

      Start and end configurations are connected by a straight line in the
      configuration space and are checked by a default collision checking
      resolution.
      static QEdgeConstraintPtr makeMerged​(QEdgeConstraintPtr constraint1, QEdgeConstraintPtr constraint2)
      Makes an edge constraint by combining two edge constraints

      The constraints provided are called one by one in the order provided.
      It is assumed that all constraints matches the same device.
      static QEdgeConstraintPtr makeMerged​(VectorQEdgeConstraintPtr constraints)
      Makes an edge constraint by combining multiple edge constraints

      The constraints provided are called one by one in the order provided.
      It is assumed that all constraints matches the same device.

      • Methods inherited from class java.lang.Object

        equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Constructor Detail

      • QEdgeConstraint

        public QEdgeConstraint​(long cPtr,
                       boolean cMemoryOwn)

    • Method Detail

      • delete

        public void delete()

      • inCollision

        public boolean inCollision​(Q start,
                           Q end)
        True if the path from start to end can't be traversed.

        Parameters:
        start - [in] Start configuration.
        end - [in] End configuration.

      • make

        public static QEdgeConstraintPtr make​(QConstraintPtr constraint,
                                      MetricQCPtr metric,
                                      double resolution)
        Discrete path verification for a linearly interpolated path.

        Performs a binary style checking of the edge with a resolution of resolution.
        The length of the edge is virtually extended to exactly match the specified
        resolution. However, only configurations within the original length are tested.

        Each configuration tested is checked using constraint.

        The metric must be well-behaved, i.e. linear.

        Start and end configurations are assumed to be collision free.

        Parameters:
        constraint - [in] Constraint to check configurations with
        metric - [in] Metric with which the resolution it to be measured
        resolution - [in] The test resolution

      • makeDefault

        public static QEdgeConstraintPtr makeDefault​(QConstraintPtr constraint,
                                             DeviceCPtr device)
        Default edge constraint for a configuration constraint and a
        device.

        Start and end configurations are connected by a straight line in the
        configuration space and are checked by a default collision checking
        resolution.

      • makeMerged

        public static QEdgeConstraintPtr makeMerged​(VectorQEdgeConstraintPtr constraints)
        Makes an edge constraint by combining multiple edge constraints

        The constraints provided are called one by one in the order provided.
        It is assumed that all constraints matches the same device.

        Parameters:
        constraints - [in] List of constraints to check
        Returns:
        Pointer to the resulting QEdgeConstraint. Pointer has ownership.

      • makeMerged

        public static QEdgeConstraintPtr makeMerged​(QEdgeConstraintPtr constraint1,
                                            QEdgeConstraintPtr constraint2)
        Makes an edge constraint by combining two edge constraints

        The constraints provided are called one by one in the order provided.
        It is assumed that all constraints matches the same device.

        Parameters:
        constraint1 - [in] First constraint to check
        constraint2 - [in] Second constraint to check
        Returns:
        Pointer to the resulting QEdgeConstraint. Pointer has ownership.