Provided by: libgraphviz-dev_2.40.1-7_amd64 bug

NAME

       libpathplan - finds and smooths shortest paths

SYNOPSIS

       #include <graphviz/pathplan.h>

       typedef struct Pxy_t {
           double x, y;
       } Pxy_t;

       typedef struct Pxy_t Ppoint_t;
       typedef struct Pxy_t Pvector_t;

       typedef struct Ppoly_t {
           Ppoint_t *ps;
           int pn;
       } Ppoly_t;

       typedef Ppoly_t Ppolyline_t;

       typedef struct Pedge_t {
           Ppoint_t a, b;
       } Pedge_t;

       typedef struct vconfig_s vconfig_t;

       #define POLYID_NONE
       #define POLYID_UNKNOWN

       int Pshortestpath(Ppoly_t *boundary, Ppoint_t endpoints[2], Ppolyline_t *output_route);

       vconfig_t *Pobsopen(Ppoly_t **obstacles, int n_obstacles);
       int Pobspath(vconfig_t *config, Ppoint_t p0, int poly0, Ppoint_t p1, int poly1, Ppolyline_t *output_route);
       void Pobsclose(vconfig_t *config);

       int Proutespline (Pedge_t *barriers, int n_barriers, Ppolyline_t input_route, Pvector_t endpoint_slopes[2],
              Ppolyline_t *output_route);

       int Ppolybarriers(Ppoly_t **polys, int n_polys, Pedge_t **barriers, int *n_barriers);

DESCRIPTION

       libpathplan provides functions for creating spline paths in the plane that are constrained
       by a polygonal boundary or obstacles to avoid.  All polygons must be simple, but need  not
       be convex.

      int Pshortestpath(Ppoly_t *boundary, Ppoint_t endpoints[2], Ppolyline_t *output_route);
       The  function  Pshortestpath finds a shortest path between two points in a simple polygon.
       The  polygon  is  specified  by  a  list  of  its  vertices,  in   either   clockwise   or
       counterclockwise  order.  You pass endpoints interior to the polygon boundary.  A shortest
       path connecting the points that remains in the polygon is returned  in  output_route.   If
       either  endpoint  does not lie in the polygon, -1 is returned; otherwise, 0 is returned on
       success.  The array of points in output_route is static to the library. It should  not  be
       freed, and should be used before another call to Pshortestpath.

       vconfig_t *Pobsopen(Ppoly_t **obstacles, int n_obstacles);
        Pobspath(vconfig_t  *config,  Ppoint_t p0, int poly0, Ppoint_t p1, int poly1, Ppolyline_t
       *output_route);
       void Pobsclose(vconfig_t *config);
       These functions find a shortest path  between  two  points  in  the  plane  that  contains
       polygonal  obstacles  (holes).  Pobsopen creates a configuration (an opaque struct of type
       vconfig_t) on a set of obstacles.  The  n_obstacles  obstacles  are  given  in  the  array
       obstacles;  the  points  of  each  polygon  should  be  in  clockwise order.  The function
       Pobsclose frees the data allocated in Pobsopen.

       Pobspath finds a shortest path between the endpoints that remains outside  the  obstacles.
       If  the  endpoints  are known to lie inside obstacles, poly0 or poly1 should be set to the
       index in the obstacles array.  If an endpoint is definitely not inside an  obstacle,  then
       POLYID_NONE  should  be passed.  If the caller has not checked, then POLYID_UNKNOWN should
       be passed, and the path library will perform the test.  The  resulting  shortest  path  is
       returned in output_route. Note that this function does not provide for a boundary polygon.
       The array of points stored in output_route are allocated by the  library,  but  should  be
       freed by the user.

       int  Proutespline  (Pedge_t  *barriers, int n_barriers, Ppolyline_t input_route, Pvector_t
       endpoint_slopes[2], Ppolyline_t *output_route);
       This function fits a cubic B-spline curve to a polyline path.  The curve is constructed to
       avoid  a  set  of n_barriers barrier line segments specified in the array barriers. If you
       start with polygonal obstacles, you can supply each polygon's edges as part of the barrier
       list.   The polyline input_route provides a template for the final path; it is usually the
       output_route of one of the shortest path finders, but it  can  be  any  simple  path  that
       doesn't  cross  any  barrier  segment.  The input also allows the specification of desired
       slopes at the endpoints via endpoint_slopes. These are specified as vectors.  For example,
       to have an angle of T at an endpoing, one could use (cos(T),sin(T)).  A vector (0,0) means
       unconstrained slope.  The output is returned in output_route and consists of  the  control
       points  of  the B-spline. The function return 0 on success; a return value of -1 indicates
       failure.  The array of points in output_route is static to the library. It should  not  be
       freed, and should be used before another call to Proutespline.

      int Ppolybarriers(Ppoly_t **polys, int n_polys, Pedge_t **barriers, int *n_barriers);
       This  is a utility function that converts an input list of polygons into an output list of
       barrier segments.  The array of points in barriers is static to the library. It should not
       be freed, and should be used before another call to Ppolybarriers.  The function returns 1
       on success.

BUGS

       The function Proutespline does not guarantee that it will preserve  the  topology  of  the
       input path as regards the boundaries. For example, if some of the segments correspond to a
       small polygon, it may be possible that the final path has flipped over the obstacle.

AUTHORS

       David Dobkin (dpd@cs.princeton.edu), Eleftherios Koutsofios  (ek@research.att.com),  Emden
       Gansner (erg@research.att.com).

                                          01 APRIL 1997                                LIBPATH(3)