Package org.robwork.sdurw_pathplanning

Class QEdgeConstraintIncrementalPtr

  • public class QEdgeConstraintIncrementalPtr
extends java.lang.Object
    Ptr stores a pointer and optionally takes ownership of the value.

    • Constructor Detail

      • QEdgeConstraintIncrementalPtr

        public QEdgeConstraintIncrementalPtr​(long cPtr,
                                     boolean cMemoryOwn)

      • QEdgeConstraintIncrementalPtr

        public QEdgeConstraintIncrementalPtr()
        Default constructor yielding a NULL-pointer.

      • QEdgeConstraintIncrementalPtr

        public QEdgeConstraintIncrementalPtr​(QEdgeConstraintIncremental ptr)
        Do not take ownership of ptr.

        ptr can be null.

        The constructor is implicit on purpose.

    • Method Detail

      • delete

        public void delete()

      • isShared

        public boolean isShared()
        check if this Ptr has shared ownership or none
        ownership
        Returns:
        true if Ptr has shared ownership, false if it has no ownership.

      • isNull

        public boolean isNull()
        checks if the pointer is null
        Returns:
        Returns true if the pointer is null

      • 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.

      • inCollision

        public boolean inCollision()
        True if the path connecting the start and end configuration
        can't be traversed.

      • inCollisionCost

        public double inCollisionCost()
        Non-negative measure of the amount of the path that still
        remains to be verified.

        The exact definition of the cost is decided by the subclass.

        The cost of an edge should strictly decrease for every call of
        verifyIncrement().

        The cost of a fully verified edge can be 0, but does not have to be.

      • inCollisionPartialCheck

        public boolean inCollisionPartialCheck()
        Perform a partial check of the path and return true if a
        collision was found.

        Full check of the path can be implemented in terms of a sequence of
        partial checks. The isFullyChecked() method returns true when there
        are no more partial checks to be done.

      • isFullyChecked

        public boolean isFullyChecked()
        True if the path has been fully checked.

        To check a path, either call inCollision() or repeatedly call
        inCollisionPartialCheck() until inCollisionPartialCheck() returns
        false or isFullyChecked() returns true.

      • instance

        public QEdgeConstraintIncrementalPtr instance​(Q start,
                                              Q end)
        An edge constraint for a pair of configurations.

        Parameters:
        start - [in] Start configuration of path
        end - [in] End configuration of path

      • getStart

        public Q getStart()
        The start configuration of the path.

      • getEnd

        public Q getEnd()
        The end configuration of the path.

      • reset

        public void reset​(Q start,
                  Q end)
        Reset the object to use a different pair of start and end
        configurations.

      • make

        public QEdgeConstraintIncrementalPtr make​(QConstraintPtr constraint,
                                          MetricQPtr metric,
                                          double resolution)
        Discrete path verification for a linearly interpolated path.

        Linearly interpolate from start to end configuration until the
        distance between pairs of configurations is resolution when
        measured by metric. Verify each configuration by constraint.

        The cost is defined as the distance (measured by metric) between
        pairs of configurations currently verified by constraint.

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

        You can pass empty configurations as start and end to construct
        an initial edge planner that you can instance() with better
        configurations later.

        Start and end configurations for this initial planner are set to the
        empty configuration.

      • make

        public QEdgeConstraintIncrementalPtr make​(QConstraintPtr constraint,
                                          MetricQPtr metric)
        Discrete path verification for a linearly interpolated path.

        Linearly interpolate from start to end configuration until the
        distance between pairs of configurations is resolution when
        measured by metric. Verify each configuration by constraint.

        The cost is defined as the distance (measured by metric) between
        pairs of configurations currently verified by constraint.

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

        You can pass empty configurations as start and end to construct
        an initial edge planner that you can instance() with better
        configurations later.

        Start and end configurations for this initial planner are set to the
        empty configuration.

      • makeDefault

        public QEdgeConstraintIncrementalPtr makeDefault​(QConstraintPtr constraint,
                                                 DevicePtr 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.

      • makeFixed

        public QEdgeConstraintIncrementalPtr makeFixed​(boolean value)
        A fixed edge constraint.

        The fixed edge constraint always returns value from inCollision().