

GD::Polyline  A polyline object, used for storing lists of vertices prior to rendering a polyline into an image. 
new 
GD::Polyline>new class method
Create an empty polyline with no vertices.
$polyline = new GD::Polyline; $polyline>addPt( 0, 0); $polyline>addPt( 0,100); $polyline>addPt( 50,100); $polyline>addPt(100, 0); $image>polydraw($polyline,$black); In fact GD::Polyline is a subclass of GD::Polygon, so all polygon methods (such as <B>offsetB> and <B>transformB>) may be used on polylines. Some new methods have thus been added to GD::Polygon (such as <B>rotateB>) and a few updated/modified/enhanced (such as <B>scaleB>) in this module. See section New or Updated GD::Polygon Methods for more info. 
The following methods (defined in GD.pm) are OVERRIDDEN if you use this module.All effort has been made to provide 100% backward compatibility, but if you can confirm that has not been achieved, please consider that a bug and let the the author of Polyline.pm know.
scale $poly>scale($sx, $sy, $cx, $cy) object method — UPDATE to GD::Polygon::scale Scale a polything in along xaxis by $sx and along the yaxis by $sy, about centery point ($cx, $cy).
Center point ($cx, $cy) is optional — if these are omitted, the function will scale about the origin.
To flip a polything, use a scale factor of 1. For example, to flip the polything top to bottom about line y = 100, use:
$poly>scale(1, 1, 0, 100);
The following methods are added to GD::Polygon, and thus can be used by polygons and polylines.Don’t forget: a polyline is a GD::Polygon, so GD::Polygon methods like offset() can be used, and they can be used in GD::Image methods like filledPolygon().
rotate $poly>rotate($angle, $cx, $cy) object method Rotate a polything through $angle (clockwise, in radians) about center point ($cx, $cy).
Center point ($cx, $cy) is optional — if these are omitted, the function will rotate about the origin
In this function and other angleoriented functions in GD::Polyline, positive $angle corrensponds to clockwise rotation. This is opposite of the usual Cartesian sense, but that is because the raster is opposite of the usual Cartesian sense in that the yaxis goes down.
centroid ($cx, $cy) = $poly>centroid($scale) object method Calculate and return ($cx, $cy), the centroid of the vertices of the polything. For example, to rotate something 180 degrees about it’s centroid:
$poly>rotate(3.14159, $poly>centroid());$scale is optional; if supplied, $cx and $cy are multiplied by $scale before returning. The main use of this is to shift an polything to the origin like this:
$poly>offset($poly>centroid(1));segLength @segLengths = $poly>segLength() object method In array context, returns an array the lengths of the segments in the polything. Segment n is the segment from vertex n to vertex n+1. Polygons have as many segments as vertices; polylines have one fewer.
In a scalar context, returns the sum of the array that would have been returned in the array context.
segAngle @segAngles = $poly>segAngle() object method Returns an array the angles of each segment from the xaxis. Segment n is the segment from vertex n to vertex n+1. Polygons have as many segments as vertices; polylines have one fewer.
Returned angles will be on the interval 0 <= $angle < 2 * pi and angles increase in a clockwise direction.
vertexAngle @vertexAngles = $poly>vertexAngle() object method Returns an array of the angles between the segment into and out of each vertex. For polylines, the vertex angle at vertex 0 and the last vertex are not defined; however $vertexAngle[0] will be undef so that $vertexAngle[1] will correspond to vertex 1.
Returned angles will be on the interval 0 <= $angle < 2 * pi and angles increase in a clockwise direction.
Note that this calculation does not attempt to figure out the interior angle with respect to inside or outside the polygon, but rather, just the angle between the adjacent segments in a clockwise sense. Thus a polygon with all right angles will have vertex angles of either pi/2 or 3*pi/2, depending on the way the polygon was wound.
toSpline $poly>toSpline() object method & factory method Create a new polything which is a reasonably smooth curve using cubic spline algorithms, often referred to as Bezier curves. The source polything is called the control polything. If it is a polyline, the control polyline must have 4, 7, 10, or some number of vertices of equal to 3n+1. If it is a polygon, the control polygon must have 3, 6, 9, or some number of vertices of equal to 3n.
$spline = $poly>toSpline(); $image>polydraw($spline,$red);In brief, groups of four points from the control polyline are considered control points for a given portion of the spline: the first and fourth are anchor points, and the spline passes through them; the second and third are director points. The spline does not pass through director points, however the spline is tangent to the line segment from anchor point to adjacent director point.
The next portion of the spline reuses the previous portion’s last anchor point. The spline will have a cusp (noncontinuous slope) at an anchor point, unless the anchor points and its adjacent director point are colinear.
In the current implementation, toSpline() return a fixed number of segments in the returned polyline per setoffour control points. In the future, this and other parameters of the algorithm may be configurable.
addControlPoints $polyline>addControlPoints() object method & factory method So you say: OK. Splines sound cool. But how can I get my anchor points and its adjacent director point to be colinear so that I have a nice smooth curves from my polyline? Relax! For The Lazy: addControlPoints() to the rescue.
addControlPoints() returns a polyline that can serve as the control polyline for toSpline(), which returns another polyline which is the spline. Is your head spinning yet? Think of it this way:
+ If you have a polyline, and you have already put your control points where you want them, call toSpline() directly. Remember, only every third vertex will be on the spline. You get something that looks like the spline inscribed inside the control polyline.
+ If you have a polyline, and you want all of its vertices on the resulting spline, call addControlPoints() and then toSpline():
$control = $polyline>addControlPoints(); $spline = $control>toSpline(); $image>polyline($spline,$red);You get something that looks like the control polyline inscribed inside the spline.
Adding good control points is subjective; this particular algorithm reveals its author’s tastes. In the future, you may be able to alter the taste slightly via parameters to the algorithm. For The Hubristic: please build a better one!
And for The Impatient: note that addControlPoints() returns a polyline, so you can pile up the the call like this, if you’d like:
$image>polyline($polyline>addControlPoints()>toSpline(),$mauve);
polyline $image>polyline(polyline,color) object method
$image>polyline($polyline,$black)This draws a polyline with the specified color. Both real color indexes and the special colors gdBrushed, gdStyled and gdStyledBrushed can be specified.
Neither the polyline() method or the polygon() method are very picky: you can call either method with either a GD::Polygon or a GD::Polyline. The method determines if the shape is closed or open as drawn, not the object type.
polydraw $image>polydraw(polything,color) object method
$image>polydraw($poly,$black)This method draws the polything as expected (polygons are closed, polylines are open) by simply checking the object type and calling either $image>polygon() or $image>polyline().
Please see file polylineexamples.pl that is included with the distribution.
For more info on Bezier splines, see http://www.webreference.com/dlab/9902/bezier.html.
On the drawing board are additional features such as:
 polygon winding algorithms (to determine if a point is "inside" or "outside" the polygon)  new polygon from bounding box  find bounding polygon (tightest fitting simple convex polygon for a given set of vertices)  addPts() method to add many points at once  clone() method for polygon  functions to interwork GD with SVGPlease provide input on other possible features you’d like to see.
This module has been written by Daniel J. Harasty. Please send questions, comments, complaints, and kudos to him at harasty@cpan.org.Thanks to Lincoln Stein for input and patience with me and this, my first CPAN contribution.
The Polyline.pm module is copyright 2002, Daniel J. Harasty. It is distributed under the same terms as Perl itself. See the Artistic License in the Perl source code distribution for licensing terms.The latest version of Polyline.pm is available at your favorite CPAN repository and/or along with GD.pm by Lincoln D. Stein at http://stein.cshl.org/WWW/software/GD.
perl v5.20.3  GD::POLYLINE (3)  20160403 
Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.