GD::Polyline(3)

Contents

GD::Polyline(3)User Contributed Perl 


NAME

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

SYNOPSIS

               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)
               $polyline->offset(200,100);

               # 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
               $image->polydraw($polyline,$black);

               # create a spline, which is also a polyine
               $spline = $polyline->addControlPoints->toSpline;
               $image->polydraw($spline,$red);

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

DESCRIPTION

       Polyline.pm extends the GD module by allowing you to cre-
       ate 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:

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

       Note that this module is very "young" and should be con-
       sidered subject to change in future releases, and/or pos-
       sibly 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 compati-
       bility, but if you can confirm that has not been achieved,
       please consider that a bug and let the the author of Poly-
       line.pm know.

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

       "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 mul-
            tiplied 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
            x-axis.  Segment n is the segment from vertex n to
            vertex n+1.  Polygons have as many segments as ver-
            tices; 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 ver-
            tex 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 num-
            ber of vertices of equal to 3n+1.  If it is a poly-
            gon, 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 (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 config-
            urable.

            For more info on Bezier splines, see [ref needed].

       "addControlPoints"
            "$polyline->addControlPoints()" object method & fac-
            tory 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: addControl-
            Points() 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 addCon-
                 trolPoints() 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 par-
            ticular 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);

New GD::Image Methods
       "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().

Examples

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

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 Lin-
       coln D. Stein at http://stein.cshl.org/WWW/software/GD.



perl v5.8.0                 2002-07-31            GD::Polyline(3)

[ Index ] [ Back ]