# doc-cache created by Octave 4.0.0
# name: cache
# type: cell
# rows: 3
# columns: 24
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
curvature


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1037
 -- Function File: KAPPA =  curvature (T, PX, PY,METHOD,DEGREE)
 -- Function File: KAPPA =  curvature (T, POLY,METHOD,DEGREE)
 -- Function File: KAPPA =  curvature (PX, PY,METHOD,DEGREE)
 -- Function File: KAPPA =  curvature (POINTS,METHOD,DEGREE)
 -- Function File: [KAPPA POLY T] =  curvature (...)
     Estimate curvature of a polyline defined by points.

     First compute an approximation of the curve given by PX and PY,
     with the parametrization T. Then compute the curvature of
     approximated curve for each point.  METHOD used for approximation
     can be only: 'polynom', with specified degree.  Further methods
     will be provided in a future version.  T, PX, and PY are N-by-1
     array of the same length. The points can be specified as a single
     N-by-2 array.

     If the argument T is not given, the parametrization is estimated
     using function `parametrize'.

     If requested, POLY contains the approximating polygon evlauted at
     the parametrization T.

     See also: parametrize, polygons2d.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Estimate curvature of a polyline defined by points.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
distancePointPolygon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 228
 -- Function File: DIST =  distancePointPolygon (POINT,POLY)
     Compute shortest distance between a point and a polygon

     See also: polygons2d, points2d, distancePointPolyline,
     distancePointEdge, projPointOnPolyline.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Compute shortest distance between a point and a polygon



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
distancePointPolyline


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 451
 -- Function File: DIST =  distancePointPolyline (POINT,POLY)
     Compute shortest distance between a point and a polyline   Example:
                pt1 = [30 20];
                pt2 = [30 5];
                poly = [10 10;50 10;50 50;10 50];
                distancePointPolyline([pt1;pt2], poly)
                ans =
                    10
                     5

     See also: polygons2d, points2d,distancePointEdge,
     projPointOnPolyline.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute shortest distance between a point and a polyline   Example:
           p



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
distancePolygons


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 112
 -- Function File: DIST =  distancePolygons (POLY1,POLY2)
     Compute the shortest distance between 2 polygons



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Compute the shortest distance between 2 polygons



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
drawPolygon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 588
 -- Function File: H =  drawPolygon (COORD)
 -- Function File: H =  drawPolygon (PX, PY)
 -- Function File: H =  drawPolygon (POLYS)
     Draw a polygon specified by a list of points.

     drawPolygon(COORD);   Packs coordinates in a single [N*2] array.

     drawPolygon(PX, PY);   Specifies coordinates in separate arrays.

     drawPolygon(POLYS)   Packs coordinate of several polygons in a
     cell array. Each element of   the array is a Ni*2 double array.

     H = drawPolygon(...);   Also return a handle to the list of line
     objects.

     See also: polygons2d, drawCurve.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Draw a polygon specified by a list of points.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
drawPolyline


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1082
 -- Function File:  = drawPolyline (, )
     DRAWPOLYLINE Draw a polyline specified by a list of points

     drawPolyline(COORD);   packs coordinates in a single [N*2] array.

     drawPolyline(PX, PY);   specifies coordinates in separate arrays.
     PX and PY must be column   vectors with the same length.

     drawPolyline(..., TYPE);   where TYPE is either 'closed' or
     'open', specifies if last point must   be connected to the first
     one ('closed') or not ('open').    Default is 'open'.

     drawPolyline(..., PARAM, VALUE);   specify plot options as
     described for plot command.

     H = drawPolyline(...) also return a handle to the list of line
     objects.

     Example:
            # Draw a curve representing an ellipse
            t = linspace(0, 2*pi, 100)';
            px = 10*cos(t); py = 5*sin(t);
            drawPolyline([px py], 'closed');
            axis equal;

            # The same, with different drawing options
            drawPolyline([px py], 'closed', 'lineWidth', 2, 'lineStyle', '--');

     See also: polygons2d, drawPolygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
DRAWPOLYLINE Draw a polyline specified by a list of points



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
expandPolygon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 929
 -- Function File: LOOPS =  expandPolygon (POLY, DIST)
     Expand a polygon by a given (signed) distance

     Associates to each edge of the polygon POLY the parallel line
     located   at distance DIST from the current edge, and compute
     intersections with   neighbor parallel lines. The resulting
     polygon is simplified to remove   inner "loops", and can be
     disconnected.    The result is a cell array, each cell containing
     a simple linear ring.

     This is a kind of dilation, but behaviour on corners is different.
      This function keeps angles of polygons, but there is no direct
     relation   between length of 2 polygons.

     It is also possible to specify negative distance, and get all
     points   inside the polygon. If the polygon is convex, the result
     equals   morphological erosion of polygon by a ball with radius
     equal to the   given distance.

     See also: polygons2d.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Expand a polygon by a given (signed) distance



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
medialAxisConvex


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 877
 -- Function File: [N E] =  medialAxisConvex (POLYGON)
     Compute medial axis of a convex polygon

     POLYGON is given as a set of points [x1 y1;x2 y2 ...], returns
     the medial axis of the polygon as a graph.    N is a set of nodes.
     The first elements of N are the vertices of the   original polygon.
      E is a set of edges, containing indices of source and target
     nodes.    Edges are sorted according to order of creation. Index
     of first vertex   is lower than index of last vertex, i.e. edges
     always point to newly   created nodes.

     Notes:   - Is not fully implemented, need more development
     (usually crashes for       polygons with more than 6-7 points...)
      - Works only for convex polygons.    - Complexity is not optimal:
     this algorithm is O(n*log n), but linear   algorithms exist.

     See also: polygons2d, bisector.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Compute medial axis of a convex polygon



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
parametrize


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1239
 -- Function File: PAR =  parametrize (POLY)
 -- Function File: PAR =  parametrize (PX,PY)
 -- Function File: PAR =  parametrize (...,NORMALIZE)
     Parametrization of a curve, based on edges length

     Returns a parametrization of the curve defined by the serie of
     points, based on euclidean distance between two consecutive points.
     POLY is a N-by-2 array, representing coordinates of vertices. The
     result PAR is N-by-1, and contains the cumulative length of edges
     until corresponding vertex. The function also accepts the polygon
     as two inputs PX and PY representinx coordinates x and y
     respectively.   When optional argument NORMALIZE is non-empty PAR
     is rescaled such that the last element equals 1, i.e.
     `PAR(end)==1'.

     Example
              # Parametrize a circle approximation
              poly = circleToPolygon([0 0 1], 200);
              p = parametrize(poly);
              p(end)
              ans =
                  6.2829
              p = parametrize(poly,'norm');
              p(end)
              ans =
                  1
              p = parametrize(poly,true);
              p(end)
              ans =
                  1

     See also: polygons2d, polylineLength.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Parametrization of a curve, based on edges length



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
polygon2shape


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 543
 -- Function File: SHAPE =  polygon2shape (POLYGON)
     Converts a polygon to a shape with edges defined by smooth
     polynomials.

     POLYGON is a N-by-2 matrix, each row representing a vertex.  SHAPE
     is a N-by-1 cell, where each element is a pair of polynomials
     compatible with polyval.

     In its current state, the shape is formed by polynomials of degree
     1. Therefore the shape representation costs more memory except for
     colinear points in the polygon.

     See also: shape2polygon, simplifypolygon, polyval.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Converts a polygon to a shape with edges defined by smooth polynomials.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
polygonArea


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 881
 -- Function File: AREA =  polygonArea (POINTS)
 -- Function File: AREA =  polygonArea (PX,PY)
     Compute the signed area of a polygon.

     Compute area of a polygon defined by POINTS. POINTS is a N-by-2
     matrix containing coordinates of vertices.

     Vertices of the polygon are supposed to be oriented
     Counter-Clockwise (CCW). In this case, the signed area is positive.
     If vertices are oriented Clockwise (CW), the signed area is
     negative.

     If polygon is self-crossing, the result is undefined.

     If POINTS is a cell, each element is considered a polygon and the
     area of each one is returned in the matrix AREA. The matrix has
     the same shape as the cell.

     References: Algorithm adapted from P. Bourke web page
     http://local.wasp.uwa.edu.au/~pbourke/geometry/polyarea/

     See also: polygons2d, polygonCentroid, drawPolygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Compute the signed area of a polygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
polygonCentroid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 583
 -- Function File: [ PT, AREA ] =  polygonCentroid (POINTS)
 -- Function File: [ ... ]=  polygonCentroid (PTX,PTY)
     Compute the centroid (center of mass) of a polygon.

     Computes the center of mass of a polygon defined by POINTS. POINTS
     is a N-by-2 matrix. The two columns can be given separately using
     PTX and PTY for the x and y component respectively.

     The area of the polygon is returned in the second output argument.

     Adapted from
     `http://local.wasp.uwa.edu.au/~pbourke/geometry/polyarea/'

     See also: polygons2d, polygonArea, drawPolygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Compute the centroid (center of mass) of a polygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
polygonLoops


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 646
 -- Function File: LOOPS =  polygonLoops (POLY)
     Divide a possibly self-intersecting polygon into a set of simple
     loops

     POLY is a polygone defined by a series of vertices,   LOOPS is a
     cell array of polygons, containing the same vertices of the
     original polygon, but no loop self-intersect, and no couple of
     loops   intersect each other.

     Example:
                poly = [0 0;0 10;20 10;20 20;10 20;10 0];
                loops = polygonLoops(poly);
                figure(1); hold on;
                drawPolygon(loops);
                polygonArea(loops)

     See also: polygons2d, polygonSelfIntersections.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Divide a possibly self-intersecting polygon into a set of simple loops



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
polygonPoint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 131
 -- Function File: POINT = polygonPoint (POLY, POS)
     Extract a point from a polygon

     See also: polygons2d, polylinePoint.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Extract a point from a polygon



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
polygonSelfIntersections


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 674
 -- Function File: PTS =  polygonSelfIntersections (POLY)
 -- Function File: [PTS POS1 POS2] =  polygonSelfIntersections (POLY)
     Find-self intersection points of a polygon

     Return the position of self intersection points

     Also return the 2 positions of each intersection point (the
     position   when meeting point for first time, then position when
     meeting point   for the second time).

     Example
                # use a '8'-shaped polygon
                poly = [10 0;0 0;0 10;20 10;20 20;10 20];
                polygonSelfIntersections(poly)
                ans =
                    10 10

     See also: polygons2d, polylineSelfIntersections.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Find-self intersection points of a polygon



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
polygonSubcurve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 515
 -- Function File: POLY2 = polygonSubcurve (POLYGON, POS0,POS1)
     Extract a portion of a polygon

     Create a new polyline, by keeping vertices located between
     positions   POS0 and POS1, and adding points corresponding to
     positions POS0 and   POS1 if they are not already vertices.

     Example:
          Nv    = 100;
          poly  = circleAsPolygon ([10 20 30], Nv);
          poly2 = polygonSubcurve (poly, 15, 65);
          drawPolyline (poly2);

     See also: polygons2d, polylineSubcurve.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Extract a portion of a polygon



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
polygons2d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7635
 -- Function File:  polygons2d ()
     Description of functions operating on 2D polygons

     The 'polygons' module contains functions operating on shapes
     composed   of a vertex list, like polygons or polylines.

     We call 'polyline' the curve defined by a series of vertices.    A
     polyline can be either closed or open, depending on whether the
     last   vertex is connected to the first one or not. This can be
     given as an   option is some functions in the module.    A
     'polygon' is the planar domain delimited by a closed polyline. We
     sometimes want to consider 'complex polygons', whose boundary is
     composed of several disjoint domains. The domain defined by a
     single   closed polyline is called 'simple polygon'.    We call
     'curve' a polyline with many vertices, such that the polyline
     can be considered as a discrete approximation of a "real" curve.

     A simple polygon or polyline is represented by a N-by-2 array,
     each row   of the array representing the coordinates of a vertex.
      Simple polygons are assumed to be closed, so there is no need to
     repeat   the first vertex at the end.    As both polygons and
     polylines can be represented by a list of vertex   coordinates,
     some functions also consider the vertex list itself. Such
     functions are prefixed by 'pointSet'. Also, many functions
     prefixed by   'polygon' or 'polyline' works also on the other type
     of shape.

     For multiple-connected polygons, the different connected
     boundaries are   separated by a row [NaN NaN].

     For some functions, the orientation of the polygon can be
     relevant: CCW   stands for 'Conter-Clockwise' (positive
     orientation), CW stands for   'Clockwise'.

     Polylines are parametrized in the following way:   * the i-th
     vertex is located at position i-1   * points of the i-th edge have
     positions ranging linearly from i-1 to i   The parametrization
     domain for an open polyline is from 0 to Nv-1, and   from 0 to Nv
     for a closed polyline (positions 0 and Nv correspond to   the same
     point).

     Example:   # Simple polygon:   P1 = [1 1;2 1;2 2;1 2];
     drawPolygon(P1);   axis([0 5 0 5]);   # Multiple polygon:   P2 =
     [10 10;40 10;40 40;10 40;NaN NaN;20 20;20 30;30 30;30 20];
     figure;drawPolygon(P2); axis([0 50 0 50]);

     Point Sets   pointSetBounds            - Bounding box of a set of
     points   pointSetsAverage          - Compute the average of
     several point sets   minimumCaliperDiameter    - Minimum caliper
     diameter of a set of points   findPoint                 - Find
     index of a point in an set from its coordinates

     Polylines   polylinePoint             - Extract a point from a
     polyline   polylineLength            - Return length of a polyline
     given as a list of points   polylineCentroid          - Compute
     centroid of a curve defined by a series of points
     polylineSubcurve          - Extract a portion of a polyline
     reversePolyline           - Reverse a polyline, by iterating
     vertices from the end   isPointOnPolyline         - Test if a
     point belongs to a polyline   projPointOnPolyline       - Compute
     position of a point projected on a polyline
     distancePointPolyline     - Compute shortest distance between a
     point and a polyline   distancePolylines         - Compute the
     shortest distance between 2 polylines   intersectPolylines
     - Find the common points between 2 polylines
     polylineSelfIntersections - Find self-intersections points of a
     polyline

     Curves (polylines with lot of vertices)   parametrize
     - Parametrization of a curve, based on edges length   curvature
                 - Estimate curvature of a polyline defined by points
     cart2geod                 - Convert cartesian coordinates to
     geodesic coord.    geod2cart                 - Convert geodesic
     coordinates to cartesian coord.    curveMoment               -
     Compute inertia moment of a 2D curve   curveCMoment              -
     Compute centered inertia moment of a 2D curve   curveCSMoment
           - Compute centered scaled moment of a 2D curve

     Polygons   polygonPoint              - Extract a point from a
     polygon   polygonSubcurve           - Extract a portion of a
     polygon   reversePolygon            - Reverse a polygon, by
     iterating vertices from the end   projPointOnPolygon        -
     Compute position of a point projected on a polygon   splitPolygons
                - Convert a NaN separated polygon list to a cell array
     of polygons   clipPolygon               - Clip a polygon with a
     rectangular box   clipPolygonHP             - Clip a polygon with
     a Half-plane defined by a directed line   intersectLinePolygon
     - Intersection points between a line and a polygon
     intersectRayPolygon       - Intersection points between a ray and
     a polygon   polygonSelfIntersections  - Find-self intersection
     points of a polygon   convexHull                - Convex hull of a
     set of points   polygonLoops              - Divide a possibly
     self-intersecting polygon into a set of simple loops
     expandPolygon             - Expand a polygon by a given (signed)
     distance   medialAxisConvex          - Compute medial axis of a
     convex polygon

     Measures on Polygons   isPointInPolygon          - Test if a point
     is located inside a polygon   polygonContains           - Test if
     a point is contained in a multiply connected polygon
     polygonCentroid           - Compute the centroid (center of mass)
     of a polygon   polygonArea               - Compute the signed area
     of a polygon   polygonLength             - Perimeter of a polygon
     polygonNormalAngle        - Compute the normal angle at a vertex
     of the polygon   polygonBounds             - Compute the bounding
     box of a polygon   distancePointPolygon      - Compute shortest
     distance between a point and a polygon   distancePolygons
     - Compute the shortest distance between 2 polygons

     Triangles   isPointInTriangle         - Test if a point is located
     inside a triangle   triangleArea              - Area of a triangle

     Functions from stochastic geometry   steinerPoint              -
     Compute steiner point (weighted centroid) of a polygon
     steinerPolygon            - Create a Steiner polygon from a set of
     vectors   supportFunction           - Compute support function of
     a polygon   convexification           - Compute the
     convexification of a polygon

     Input, Output and conversions   readPolygon               - Read a
     polygon stored in a file   polygonToRow              - Convert
     polygon coordinates to a row vector   rowToPolygon              -
     Create a polygon from a row vector   rectAsPolygon             -
     Convert a (centered) rectangle into a series of points

     Drawing functions   drawPolyline              - Draw a polyline
     specified by a list of points   drawPolygon               - Draw a
     polygon specified by a list of points   fillPolygon
     - Fill a polygon specified by a list of points

     Credits:   * function intersectPolylines uses the 'interX'
     contribution from "NS"       (file exchange 22441, called
     'curve-intersections')

     ---- Author: David Legland e-mail: david.legland@grignon.inra.fr
     created the  07/11/2005.  Homepage:
     `http://matgeom.sourceforge.net/'
     `http://www.pfl-cepia.inra.fr/index.php?page=geom2d' Copyright
     INRA - Cepia Software Platform.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Description of functions operating on 2D polygons



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
polylineSelfIntersections


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 829
 -- Function File: PTS =  polylineSelfIntersections (POLY)
     Find self-intersections points of a polyline

     Return the position of self intersection points

     Also return the 2 positions of each intersection point (the
     position   when meeting point for first time, then position when
     meeting point   for the second time).

     Example
                # use a gamma-shaped polyline
                poly = [0 0;0 10;20 10;20 20;10 20;10 0];
                polylineSelfIntersections(poly)
                ans =
                    10 10

                # use a 'S'-shaped polyline
                poly = [10 0;0 0;0 10;20 10;20 20;10 20];
                polylineSelfIntersections(poly)
                ans =
                    10 10

     See also: polygons2d, intersectPolylines, polygonSelfIntersections.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Find self-intersections points of a polyline



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
reversePolygon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 299
 -- Function File: POLY2 =  reversePolygon (POLY)
     Reverse a polygon, by iterating vertices from the end

     POLY2 = reversePolygon(POLY)   POLY2 has same vertices as POLY,
     but in different order. The first   vertex of the polygon is still
     the same.

     See also: reversePolyline.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Reverse a polygon, by iterating vertices from the end



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
reversePolyline


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 268
 -- Function File: POLY2 =  reversePolyline (POLY)
     Reverse a polyline, by iterating vertices from the end

     POLY2 = reversePolyline(POLY)   POLY2 has same vertices as POLY,
     but POLY2(i,:) is the same as   POLY(END-i+1,:).

     See also: reversePolygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Reverse a polyline, by iterating vertices from the end



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
simplifypolygon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 230
 -- Function File: SPOLY =  simplifypolygon (POLY)
     Simplify a polygon using the Ramer-Douglas-Peucker algorithm.

     POLY is a N-by-2 matrix, each row representing a vertex.

     See also: simplifypolyline, shape2polygon.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Simplify a polygon using the Ramer-Douglas-Peucker algorithm.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
simplifypolyline


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 908
 -- Function File: [PLINE2 IDX] =  simplifypolyline (PLINE)
 -- Function File: ... =  simplifypolyline (...,PROPERTY,VALUE,...)
     Simplify or subsample a polyline using the Ramer-Douglas-Peucker
     algorithm, a.k.a. the iterative end-point fit algorithm or the
     split-and-merge algorithm.

     The PLINE as a N-by-2 matrix. Rows correspond to the verices
     (compatible with `polygons2d'). The vector IDX constains the
     indexes on vetices in PLINE that generates PLINE2, i.e.  `pline2 =
     pline(idx,:)'.

     *Parameters*
    `'Nmax''
          Maximum number of vertices. Default value `1e3'.

    `'Tol''
          Tolerance for the error criteria. Default value `1e-4'.

    `'MaxIter''
          Maximum number of iterations. Default value `10'.

    `'Method''
          Not implemented.

     Run `demo simplifypolyline' to see an example.

     See also: curve2polyline, curveval.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Simplify or subsample a polyline using the Ramer-Douglas-Peucker
algorithm, a.k.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
splitPolygons


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 347
 -- Function File: POLYGONS =  splitPolygons (POLYGON)
     Convert a NaN separated polygon list to a cell array of polygons.

     POLYGON is a N-by-2 array of points, with possibly couples of NaN
     values.  The functions separates each component separated by NaN
     values, and returns a cell array of polygons.

     See also: polygons2d.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Convert a NaN separated polygon list to a cell array of polygons.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
supportFunction


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 521
 -- Function File: H =  suppportFunction (POLYGON)
 -- Function File: H =  suppportFunction (POLYGON, N)
 -- Function File: H =  suppportFunction (POLYGON, V)
     Compute support function of a polygon

     H = supportFunction(POLYGON, N)   uses N points for suport
     function approximation

     H = supportFunction(POLYGON)   assume 24 points for approximation

     H = supportFunction(POLYGON, V)   where V is a vector, uses vector
     V of angles to compute support   function.

     See also: convexification.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Compute support function of a polygon





