GD::Simple man page on Oracle

Man page or keyword search:  
man Server   33470 pages
apropos Keyword Search (all sections)
Output format
Oracle logo
[printable version]

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

NAME
       GD::Simple - Simplified interface to GD library

SYNOPSIS
	   use GD::Simple;

	   # create a new image
	   $img = GD::Simple->new(400,250);

	   # draw a red rectangle with blue borders
	   $img->bgcolor('red');
	   $img->fgcolor('blue');
	   $img->rectangle(10,10,50,50);

	   # draw an empty rectangle with green borders
	   $img->bgcolor(undef);
	   $img->fgcolor('green');
	   $img->rectangle(30,30,100,100);

	   # move to (80,80) and draw a green line to (100,190)
	   $img->moveTo(80,80);
	   $img->lineTo(100,190);

	   # draw a solid orange ellipse
	   $img->moveTo(110,100);
	   $img->bgcolor('orange');
	   $img->fgcolor('orange');
	   $img->ellipse(40,40);

	   # draw a black filled arc
	   $img->moveTo(150,150);
	   $img->fgcolor('black');
	   $img->arc(50,50,0,100,gdNoFill|gdEdged);

	   # draw a string at (10,180) using the default
	   # built-in font
	   $img->moveTo(10,180);
	   $img->string('This is very simple');

	   # draw a string at (280,210) using 20 point
	   # times italic, angled upward 90 degrees
	   $img->moveTo(280,210);
	   $img->font('Times:italic');
	   $img->fontsize(20);
	   $img->angle(-90);
	   $img->string('This is very fancy');

	   # some turtle graphics
	   $img->moveTo(300,100);
	   $img->penSize(3,3);
	   $img->angle(0);
	   $img->line(20);   # 20 pixels going to the right
	   $img->turn(30);   # set turning angle to 30 degrees
	   $img->line(20);   # 20 pixel line
	   $img->line(20);
	   $img->line(20);
	   $img->turn(-90); # set turning angle to -90 degrees
	   $img->line(50);  # 50 pixel line

	   # draw a cyan polygon edged in blue
	   my $poly = new GD::Polygon;
	   $poly->addPt(150,100);
	   $poly->addPt(199,199);
	   $poly->addPt(100,199);
	   $img->bgcolor('cyan');
	   $img->fgcolor('blue');
	   $img->penSize(1,1);
	   $img->polygon($poly);

	  # convert into png data
	  print $img->png;

DESCRIPTION
       GD::Simple is a subclass of the GD library that shortens many of the
       long GD method calls by storing information about the pen color, size
       and position in the GD object itself.  It also adds a small number of
       "turtle graphics" style calls for those who prefer to work in polar
       coordinates.  In addition, the library allows you to use symbolic names
       for colors, such as "chartreuse", and will manage the colors for you.

   The Pen
       GD::Simple maintains a "pen" whose settings are used for line- and
       shape-drawing operations.  The pen has the following properties:

       fgcolor
	   The pen foreground color is the color of lines and the borders of
	   filled and unfilled shapes.

       bgcolor
	   The pen background color is the color of the contents of filled
	   shapes.

       pensize
	   The pen size is the width of the pen.  Larger sizes draw thicker
	   lines.

       position
	   The pen position is its current position on the canvas in (X,Y)
	   coordinates.

       angle
	   When drawing in turtle mode, the pen angle determines the current
	   direction of lines of relative length.

       turn
	   When drawing in turtle mode, the turn determines the clockwise or
	   counterclockwise angle that the pen will turn before drawing the
	   next line.

       font
	   The font to use when drawing text.  Both built-in bitmapped fonts
	   and TrueType fonts are supported.

       fontsize
	   The size of the font to use when drawing with TrueType fonts.

       One sets the position and properties of the pen and then draws.	As the
       drawing progresses, the position of the pen is updated.

   Methods
       GD::Simple introduces a number of new methods, a few of which have the
       same name as GD::Image methods, and hence change their behavior. In
       addition to these new methods, GD::Simple objects support all of the
       GD::Image methods. If you make a method call that isn't directly
       supported by GD::Simple, it refers the request to the underlying
       GD::Image object.  Hence one can load a JPEG image into GD::Simple and
       declare it to be TrueColor by using this call, which is effectively
       inherited from GD::Image:

	 my $img = GD::Simple->newFromJpeg('./myimage.jpg',1);

       The rest of this section describes GD::Simple-specific methods.

       $img = GD::Simple->new($x,$y [,$truecolor])
       $img = GD::Simple->new($gd)
	   Create a new GD::Simple object. There are two forms of new(). In
	   the first form, pass the width and height of the desired canvas,
	   and optionally a boolean flag to request a truecolor image. In the
	   second form, pass a previously-created GD::Image object.

       GD::Simple->class('GD');
       GD::Simple->class('GD::SVG');
	   Select whether new() should use GD or GD::SVG internally. Call
	   GD::Simple->class('GD::SVG') before calling new() if you wish to
	   generate SVG images.

	   If future GD subclasses are created, this method will subport them.

       $img->moveTo($x,$y)
	   This call changes the position of the pen without drawing. It moves
	   the pen to position ($x,$y) on the drawing canvas.

       $img->move($dx,$dy)
       $img->move($dr)
	   This call changes the position of the pen without drawing. When
	   called with two arguments it moves the pen $dx pixels to the right
	   and $dy pixels downward.  When called with one argument it moves
	   the pen $dr pixels along the vector described by the current pen
	   angle.

       $img->lineTo($x,$y)
	   The lineTo() call simultaneously draws and moves the pen.  It draws
	   a line from the current pen position to the position defined by
	   ($x,$y) using the current pen size and color.  After drawing, the
	   position of the pen is updated to the new position.

       $img->line($x1,$y1,$x2,$y2 [,$color])
       $img->line($dx,$dy)
       $img->line($dr)
	   The line() call simultaneously draws and moves the pen. When called
	   with two arguments it draws a line from the current position of the
	   pen to the position $dx pixels to the right and $dy pixels down.
	   When called with one argument, it draws a line $dr pixels long
	   along the angle defined by the current pen angle.

	   When called with four or five arguments, line() behaves like
	   GD::Image->line().

       $img->clear
	   This method clears the canvas by painting over it with the current
	   background color.

       $img->rectangle($x1,$y1,$x2,$y2)
	   This method draws the rectangle defined by corners ($x1,$y1),
	   ($x2,$y2). The rectangle's edges are drawn in the foreground color
	   and its contents are filled with the background color. To draw a
	   solid rectangle set bgcolor equal to fgcolor. To draw an unfilled
	   rectangle (transparent inside), set bgcolor to undef.

       $img->ellipse($width,$height)
	   This method draws the ellipse centered at the current location with
	   width $width and height $height.  The ellipse's border is drawn in
	   the foreground color and its contents are filled with the
	   background color. To draw a solid ellipse set bgcolor equal to
	   fgcolor. To draw an unfilled ellipse (transparent inside), set
	   bgcolor to undef.

       $img->arc($cx,$cy,$width,$height,$start,$end [,$style])
	   This method draws filled and unfilled arcs.	See GD for a
	   description of the arguments. To draw a solid arc (such as a pie
	   wedge) set bgcolor equal to fgcolor. To draw an unfilled arc, set
	   bgcolor to undef.

       $img->polygon($poly)
	   This method draws filled and unfilled polygon using the current
	   settings of fgcolor for the polygon border and bgcolor for the
	   polygon fill color.	See GD for a description of creating polygons.
	   To draw a solid polygon set bgcolor equal to fgcolor. To draw an
	   unfilled polygon, set bgcolor to undef.

       $img->polyline($poly)
	   This method draws polygons without closing the first and last
	   vertices (similar to GD::Image->unclosedPolygon()). It uses the
	   fgcolor to draw the line.

       $img->string($string)
	   This method draws the indicated string starting at the current
	   position of the pen. The pen is moved to the end of the drawn
	   string.  Depending on the font selected with the font() method,
	   this will use either a bitmapped GD font or a TrueType font.	 The
	   angle of the pen will be consulted when drawing the text. For
	   TrueType fonts, any angle is accepted.  For GD bitmapped fonts, the
	   angle can be either 0 (draw horizontal) or -90 (draw upwards).

	   For consistency between the TrueType and GD font behavior, the
	   string is always drawn so that the current position of the pen
	   corresponds to the bottom left of the first character of the text.
	   This is different from the GD behavior, in which the first
	   character of bitmapped fonts hangs down from the pen point.

	   This method returns a polygon indicating the bounding box of the
	   rendered text.  If an error occurred (such as invalid font
	   specification) it returns undef and an error message in $@.

       $metrics = $img->fontMetrics
       ($metrics,$width,$height) =
       GD::Simple->fontMetrics($font,$fontsize,$string)
	   This method returns information about the current font, most
	   commonly a TrueType font. It can be invoked as an instance method
	   (on a previously-created GD::Simple object) or as a class method
	   (on the 'GD::Simple' class).

	   When called as an instance method, fontMetrics() takes no arguments
	   and returns a single hash reference containing the metrics that
	   describe the currently selected font and size. The hash reference
	   contains the following information:

	     xheight	  the base height of the font from the bottom to the top of
			  a lowercase 'm'

	     ascent	  the length of the upper stem of the lowercase 'd'

	     descent	  the length of the lower step of the lowercase 'j'

	     lineheight	  the distance from the bottom of the 'j' to the top of
			  the 'd'

	     leading	  the distance between two adjacent lines

       ($delta_x,$delta_y)= $img->stringBounds($string)
	   This method indicates the X and Y offsets (which may be negative)
	   that will occur when the given string is drawn using the current
	   font, fontsize and angle. When the string is drawn horizontally, it
	   gives the width and height of the string's bounding box.

       $delta_x = $img->stringWidth($string)
	   This method indicates the width of the string given the current
	   font, fontsize and angle. It is the same as
	   ($img->stringBounds($string))[0]

       ($x,$y) = $img->curPos
	   Return the current position of the pen.  Set the current position
	   using moveTo().

       $font = $img->font([$newfont] [,$newsize])
	   Get or set the current font.	 Fonts can be GD::Font objects,
	   TrueType font file paths, or fontconfig font patterns like
	   "Times:italic" (see fontconfig). The latter feature requires that
	   you have the fontconfig library installed and are using libgd
	   version 2.0.33 or higher.

	   As a shortcut, you may pass two arguments to set the font and the
	   fontsize simultaneously. The fontsize is only valid when drawing
	   with TrueType fonts.

       $size = $img->fontsize([$newfontsize])
	   Get or set the current font size.  This is only valid for TrueType
	   fonts.

       $size = $img->penSize([$newpensize])
	   Get or set the current pen width for use during line drawing
	   operations.

       $angle = $img->angle([$newangle])
	   Set the current angle for use when calling line() or move() with a
	   single argument.

	   Here is an example of using turn() and angle() together to draw an
	   octagon.  The first line drawn is the downward-slanting top right
	   edge.  The last line drawn is the horizontal top of the octagon.

	     $img->moveTo(200,50);
	     $img->angle(0);
	     $img->turn(360/8);
	     for (1..8) { $img->line(50) }

       $angle = $img->turn([$newangle])
	   Get or set the current angle to turn prior to drawing lines.	 This
	   value is only used when calling line() or move() with a single
	   argument.  The turning angle will be applied to each call to line()
	   or move() just before the actual drawing occurs.

	   Angles are in degrees.  Positive values turn the angle clockwise.

       $color = $img->fgcolor([$newcolor])
	   Get or set the pen's foreground color.  The current pen color can
	   be set by (1) using an (r,g,b) triple; (2) using a previously-
	   allocated color from the GD palette; or (3) by using a symbolic
	   color name such as "chartreuse."  The list of color names can be
	   obtained using color_names(). The special color name 'transparent'
	   will create a completely transparent color.

       $color = $img->bgcolor([$newcolor])
	   Get or set the pen's background color.  The current pen color can
	   be set by (1) using an (r,g,b) triple; (2) using a previously-
	   allocated color from the GD palette; or (3) by using a symbolic
	   color name such as "chartreuse."  The list of color names can be
	   obtained using color_names(). The special color name 'transparent'
	   will create a completely transparent color.

       $index = $img->translate_color(@args)
	   Translates a color into a GD palette or TrueColor index.  You may
	   pass either an (r,g,b) triple or a symbolic color name. If you pass
	   a previously-allocated index, the method will return it unchanged.

       $index = $img->alphaColor(@args,$alpha)
	   Creates an alpha color.  You may pass either an (r,g,b) triple or a
	   symbolic color name, followed by an integer indicating its opacity.
	   The opacity value ranges from 0 (fully opaque) to 127 (fully
	   transparent).

       @names = GD::Simple->color_names
       $translate_table = GD::Simple->color_names
	   Called in a list context, color_names() returns the list of
	   symbolic color names recognized by this module.  Called in a scalar
	   context, the method returns a hash reference in which the keys are
	   the color names and the values are array references containing
	   [r,g,b] triples.

       $gd = $img->gd
	   Return the internal GD::Image object.  Usually you will not need to
	   call this since all GD methods are automatically referred to this
	   object.

       ($red,$green,$blue) = GD::Simple->HSVtoRGB($hue,$saturation,$value)
	   Convert a Hue/Saturation/Value (HSV) color into an RGB triple. The
	   hue, saturation and value are integers from 0 to 255.

       ($hue,$saturation,$value) =
       GD::Simple->RGBtoHSV($hue,$saturation,$value)
	   Convert a Red/Green/Blue (RGB) value into a Hue/Saturation/Value
	   (HSV) triple. The hue, saturation and value are integers from 0 to
	   255.

COLORS
       This script will create an image showing all the symbolic colors.

	#!/usr/bin/perl

	use strict;
	use GD::Simple;

	my @color_names = GD::Simple->color_names;
	my $cols = int(sqrt(@color_names));
	my $rows = int(@color_names/$cols)+1;

	my $cell_width	  = 100;
	my $cell_height	  = 50;
	my $legend_height = 16;
	my $width	= $cols * $cell_width;
	my $height	= $rows * $cell_height;

	my $img = GD::Simple->new($width,$height);
	$img->font(gdSmallFont);

	for (my $c=0; $c<$cols; $c++) {
	  for (my $r=0; $r<$rows; $r++) {
	    my $color = $color_names[$c*$rows + $r] or next;
	    my @topleft	 = ($c*$cell_width,$r*$cell_height);
	    my @botright = ($topleft[0]+$cell_width,$topleft[1]+$cell_height-$legend_height);
	    $img->bgcolor($color);
	    $img->fgcolor($color);
	    $img->rectangle(@topleft,@botright);
	    $img->moveTo($topleft[0]+2,$botright[1]+$legend_height-2);
	    $img->fgcolor('black');
	    $img->string($color);
	  }
	}

	print $img->png;

AUTHOR
       The GD::Simple module is copyright 2004, Lincoln D. Stein.  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 versions of GD.pm are available at

	 http://stein.cshl.org/WWW/software/GD

SEE ALSO
       GD, GD::Polyline, GD::SVG, Image::Magick

perl v5.16.3			  2013-02-26			 GD::Simple(3)
[top]

List of man pages available for Oracle

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net