Home Man
Today's Posts

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

CentOS 7.0 - man page for gd::polyline (centos section 3)

GD::Polyline(3) 	       User Contributed Perl Documentation		  GD::Polyline(3)

       GD::Polyline - Polyline object and Polygon utilities (including splines) for use with GD

	       use GD;
	       use GD::Polyline;

	       # create an image
	       $image = new GD::Image (500,300);
	       $white  = $image->colorAllocate(255,255,255);
	       $black  = $image->colorAllocate(  0,  0,  0);
	       $red    = $image->colorAllocate(255,  0,  0);

	       # create a new polyline
	       $polyline = new GD::Polyline;

	       # add some points
	       $polyline->addPt(  0,  0);
	       $polyline->addPt(  0,100);
	       $polyline->addPt( 50,125);
	       $polyline->addPt(100,  0);

	       # polylines can use polygon methods (and vice versa)

	       # rotate 60 degrees, about the centroid
	       $polyline->rotate(3.14159/3, $polyline->centroid());

	       # scale about the centroid
	       $polyline->scale(1.5, 2, $polyline->centroid());

	       # draw the polyline

	       # create a spline, which is also a polyine
	       $spline = $polyline->addControlPoints->toSpline;

	       # output the png
	       binmode STDOUT;
	       print $image->png;

       Polyline.pm extends the GD module by allowing you to create polylines.  Think of a
       polyline as "an open polygon", that is, the last vertex is not connected to the first
       vertex (unless you expressly add the same value as both points).

       For the remainder of this doc, "polyline" will refer to a GD::Polyline, "polygon" will
       refer to a GD::Polygon that is not a polyline, and "polything" and "$poly" may be either.

       The big feature added to GD by this module is the means to create splines, which are
       approximations to curves.

The Polyline Object
       GD::Polyline defines the following class:

	    A polyline object, used for storing lists of vertices prior to rendering a polyline
	    into an image.

	    "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);


	    In fact GD::Polyline is a subclass of GD::Polygon, so all polygon methods (such as
	    offset and transform) may be used on polylines.  Some new methods have thus been
	    added to GD::Polygon (such as rotate) and a few updated/modified/enhanced (such as
	    scale) in this module.  See section "New or Updated GD::Polygon Methods" for more

       Note that this module is very "young" and should be considered subject to change in future
       releases, and/or possibly folded in to the existing polygon object and/or GD module.

Updated Polygon Methods
       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.

	    "$poly->scale($sx, $sy, $cx, $cy)" object method -- UPDATE to GD::Polygon::scale

	    Scale a polything in along x-axis by $sx and along the y-axis 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);

New Polygon Methods
       The following methods are added to GD::Polygon, and thus can be used by polygons and

       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().

	    "$poly->rotate($angle, $cx, $cy)" object method

	    Rotate a polything through $angle (clockwise, in radians) about center point ($cx,

	    Center point ($cx, $cy) is optional -- if these are omitted, the function will rotate
	    about the origin

	    In this function and other angle-oriented 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
	    y-axis goes "down".

	    "($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:


	    "@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.

	    "@segAngles = $poly->segAngle()" object method

	    Returns an array the angles of each segment from the x-axis.  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.

	    "@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

	    "$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();

	    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 (non-continuous 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 set-of-four control points.  In the future, this and other
	    parameters of the algorithm may be configurable.

	    "$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

	    +	 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();

		 You get something that looks like the control polyline "inscribed" inside the

	    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:


New GD::Image Methods
	    "$image->polyline(polyline,color)" object method


	    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.

	    "$image->polydraw(polything,color)" object method


	    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

       Please see file "polyline-examples.pl" that is included with the distribution.

See Also
       For more info on Bezier splines, see http://www.webreference.com/dlab/9902/bezier.html.

Future Features
       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 SVG

       Please 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

Copyright Information
       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.16.3				    2013-02-26				  GD::Polyline(3)

All times are GMT -4. The time now is 07:55 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
Show Password