Creating Imager Objects

new()

  $img = Imager->new();
  $img->read(file=>"alligator.ppm") or die $img->errstr;
    

Here "new()" creates an empty image with width and height of zero. It's only useful for creating an Imager object to call the read() method on later.

  %opts = (xsize=>300, ysize=>200);
  $img = Imager->new(%opts); # create direct mode RGBA image
  $img = Imager->new(%opts, channels=>4); # create direct mode RGBA image
    

You can also read a file from new():

  $img = Imager->new(file => "someimage.png");
    

The parameters for new are:

  # 8 bit/sample, RGB image
  my $img = Imager->new(xsize => $width, ysize => $height);

  # 8 bits/sample, RGBA image
  my $img = Imager->new(xsize => $width, ysize => $height, channels=>4);

  $img = Imager->new(xsize=>200, ysize=>200, type=>'paletted');

  $img = Imager->new(xsize=>200, ysize=>200,
                     channels=>3, bits=>16);

  $img = Imager->new(xsize=>200, ysize=>200,
                     channels=>3, bits=>'double');

  my $img = Imager->new;
  $img->read(file=>$filename)
    or die $img->errstr;

  my $img = Imager->new(file => $filename)
    or die Imager->errstr;

img_set()

img_set destroys the image data in the object and creates a new one with the given dimensions and channels. For a way to convert image data between formats see the "convert()" method.

  $img->img_set(xsize=>500, ysize=>500, channels=>4);
    

This takes exactly the same parameters as the new() method, excluding those for reading from files.

Image Attribute functions

getwidth()

  print "Image width: ", $img->getwidth(), "\n";
    

The "getwidth()" method returns the width of the image. This value comes either from "new()" with "xsize", "ysize" parameters or from reading data from a file with "read()". If called on an image that has no valid data in it like "Imager->new()" returns, the return value of "getwidth()" is undef.

getheight()

  print "Image height: ", $img->getheight(), "\n";
    

Same details apply as for "getwidth()".

getchannels()

  print "Image has ",$img->getchannels(), " channels\n";
    

Returns the number of channels in an image.

Note: previously the number of channels in an image mapped directly to the color model of the image, ie a 4 channel image was always RGBA. This may change in a future release of Imager.

Returns an empty list if the image object is not initialized.

colorchannels()

Returns the number of color channels.

Currently this is always 1 or 3, but may be 0 for some rare images in a future version of Imager.

Returns an empty list if the image object is not initialized.

colormodel()

Returns the color model of the image, including whether there is an alpha channel.

By default this is returned as a string, one of "unknown", "gray", "graya", "rgb" or "rgba".

If you call "colormodel()" with a true numeric parameter:

  my $model = $img->colormodel(numeric => 1);
    

then the color model is returned as a number, mapped as follows:

  Numeric  String
  -------  ------
      0    unknown
      1    gray
      2    graya
      3    rgb
      4    rgba
    

alphachannel()

Returns the channel index of the alpha channel of the image.

This is 1 for grayscale images with alpha, 3 for RGB images with alpha and will return "undef" for all other images.

Returns an empty list if the image object is not initialized.

bits()

The bits() method retrieves the number of bits used to represent each channel in a pixel, 8 for a normal image, 16 for 16-bit image and 'double' for a double/channel image.

  if ($img->bits eq 8) {
    # fast but limited to 8-bits/sample
  }
  else {
    # slower but more precise
  }
    

Returns an empty list if the image object is not initialized.

type()

The type() method returns either 'direct' for direct color images or 'paletted' for paletted images.

  if ($img->type eq 'paletted') {
    # print the palette
    for my $color ($img->getcolors) {
      print join(",", $color->rgba), "\n";
    }
  }
    

Returns an empty list if the image object is not initialized.

virtual()

The virtual() method returns non-zero if the image contains no actual pixels, for example masked images.

This may also be used for non-native Imager images in the future, for example, for an Imager object that draws on an SDL surface.

is_bilevel()

Tests if the image will be written as a monochrome or bi-level image for formats that support that image organization.

In scalar context, returns true if the image is bi-level.

In list context returns a list:

  ($is_bilevel, $zero_is_white) = $img->is_bilevel;
    

An image is considered bi-level, if all of the following are true:

Direct Type Images

getmask()

  @rgbanames = qw( red green blue alpha );
  my $mask = $img->getmask();
  print "Modifiable channels:\n";
  for (0..$img->getchannels()-1) {
    print $rgbanames[$_],"\n" if $mask & 1<<$_;
  }
    

"getmask()" is used to fetch the current channel mask. The mask determines what channels are currently modifiable in the image. The channel mask is an integer value, if the "i-th" least significant bit is set the "i-th" channel is modifiable. eg. a channel mask of 0x5 means only channels 0 and 2 are writable.

setmask()

  $mask = $img->getmask();
  $img->setmask(mask=>8);     # modify alpha only

    ...

  $img->setmask(mask=>$mask); # restore previous mask
    

"setmask()" is used to set the channel mask of the image. See "getmask()" for details.

Palette Type Images

In general you can work with paletted images in the same way as RGB images, except that if you attempt to draw to a paletted image with a color that is not in the image's palette, the image will be converted to an RGB image. This means that drawing on a paletted image with anti-aliasing enabled will almost certainly convert the image to RGB.

Palette management takes place through "addcolors()", "setcolors()", "getcolors()" and "findcolor()":

addcolors()

You can add colors to a paletted image with the addcolors() method:

   my @colors = ( Imager::Color->new(255, 0, 0), 
                  Imager::Color->new(0, 255, 0) );
   my $index = $img->addcolors(colors=>\@colors);
    

The return value is the index of the first color added, or undef if adding the colors would overflow the palette.

The only parameter is "colors" which must be a reference to an array of Imager::Color objects.

setcolors()

  $img->setcolors(start=>$start, colors=>\@colors);
    

Once you have colors in the palette you can overwrite them with the "setcolors()" method: "setcolors()" returns true on success.

Parameters:

getcolors()

To retrieve existing colors from the palette use the getcolors() method:

  # get the whole palette
  my @colors = $img->getcolors();
  # get a single color
  my $color = $img->getcolors(start=>$index);
  # get a range of colors
  my @colors = $img->getcolors(start=>$index, count=>$count);
    

findcolor()

To quickly find a color in the palette use findcolor():

  my $index = $img->findcolor(color=>$color);
    

which returns undef on failure, or the index of the color.

Parameter:

colorcount()

Returns the number of colors in the image's palette:

  my $count = $img->colorcount;
    

maxcolors()

Returns the maximum size of the image's palette.

  my $maxcount = $img->maxcolors;
    

Color Distribution

getcolorcount()

Calculates the number of colors in an image.

The amount of memory used by this is proportional to the number of colors present in the image, so to avoid using too much memory you can supply a maxcolors() parameter to limit the memory used.

Note: getcolorcount() treats the image as an 8-bit per sample image.

  if (defined($img->getcolorcount(maxcolors=>512)) {
    print "Less than 512 colors in image\n";
  }

getcolorusagehash()

Calculates a histogram of colors used by the image.

  my $colors = $img->getcolorusagehash;
  my $blue_count = $colors->{pack("CCC", 0, 0, 255)} || 0;
  print "#0000FF used $blue_count times\n";

getcolorusage()

Calculates color usage counts and returns just the counts.

  my @counts = $img->getcolorusage;
  print "The most common color is used $counts[0] times\n";

Conversion Between Image Types

to_paletted()

You can create a new paletted image from an existing image using the to_paletted() method:

 $palimg = $img->to_paletted(\%opts)
    

where %opts contains the options specified under "Quantization options".

  # convert to a paletted image using the web palette
  # use the closest color to each pixel
  my $webimg = $img->to_paletted({ make_colors => 'webmap' });

  # convert to a paletted image using a fairly optimal palette
  # use an error diffusion dither to try to reduce the average error
  my $optimag = $img->to_paletted({ make_colors => 'mediancut',
                                    translate => 'errdiff' });
    

to_rgb8()

You can convert a paletted image (or any image) to an 8-bit/channel RGB image with:

  $rgbimg = $img->to_rgb8;
    

No parameters.

to_rgb16()

Convert a paletted image (or any image) to a 16-bit/channel RGB image.

  $rgbimg = $img->to_rgb16;
    

No parameters.

to_rgb_double()

Convert a paletted image (or any image) to an double/channel direct color image.

  $rgbimg = $img->to_rgb_double;
    

No parameters.

masked()

Creates a masked image. A masked image lets you create an image proxy object that protects parts of the underlying target image.

In the discussion below there are 3 image objects involved:

  my $mask = Imager->new(xsize=>$img->getwidth, ysize=>$img->getheight,
                         channels=>1);
  # ... draw something on the mask
  my $maskedimg = $img->masked(mask=>$mask);

  # now draw on $maskedimg and it will only draw on areas of $img 
  # where $mask is non-zero in channel 0.

  # just work with a 100x100 region of $img
  my $maskedimg = $img->masked(left => 100, top=>100,
                               right=>200, bottom=>200);

make_palette()

This doesn't perform an image conversion, but it can be used to construct a common palette for use in several images:

  my @colors = Imager->make_palette(\%opts, @images);
    

You must supply at least one image, even if the "make_colors" parameter produces a fixed palette.

On failure returns no colors and you can check "Imager->errstr".

Tags

At the perl level each tag has a name or code and a value, which is an integer or an arbitrary string. An image can contain more than one tag with the same name or code, but having more than one tag with the same name is discouraged.

You can retrieve tags from an image using the tags() method, you can get all of the tags in an image, as a list of array references, with the code or name of the tag followed by the value of the tag.

Imager's support for fairly limited, for access to pretty much all image metadata you may want to try Image::ExifTool.

tags()

Retrieve tags from the image.

With no parameters, retrieves a list array references, each containing a name and value: all tags in the image:

  # get a list of ( [ name1 => value1 ], [ name2 => value2 ] ... )
  my @alltags = $img->tags;
  print $_->[0], ":", $_->[1], "\n" for @all_tags;

  # or put it in a hash, but this will lose duplicates
  my %alltags = map @$_, $img->tags;
    

in scalar context this returns the number of tags:

  my $num_tags = $img->tags;
    

or you can get all tags values for the given name:

  my @namedtags = $img->tags(name => $name);
    

in scalar context this returns the first tag of that name:

  my $firstnamed = $img->tags(name => $name);
    

or a given code:

  my @tags = $img->tags(code=>$code);
    

addtag()

You can add tags using the addtag() method, either by name:

  my $index = $img->addtag(name=>$name, value=>$value);
    

or by code:

  my $index = $img->addtag(code=>$code, value=>$value);
    

deltag()

You can remove tags with the deltag() method, either by index:

  $img->deltag(index=>$index);
    

or by name:

  $img->deltag(name=>$name);
    

or by code:

  $img->deltag(code=>$code);
    

In each case deltag() returns the number of tags deleted.

settag()

settag() replaces any existing tags with a new tag. This is equivalent to calling deltag() then addtag().

Common Tags

Since tags are a relatively new addition their use is not wide spread but eventually we hope to have all the readers for various formats set some standard information.

• "i_xres", "i_yres" - The spatial resolution of the image in pixels per inch. If the image format uses a different scale, eg. pixels per meter, then this value is converted. A floating point number stored as a string.

    # our image was generated as a 300 dpi image
    $img->settag(name => 'i_xres', value => 300);
    $img->settag(name => 'i_yres', value => 300);
  
    # 100 pixel/cm for a TIFF image
    $img->settag(name => 'tiff_resolutionunit', value => 3); # RESUNIT_CENTIMETER
    # convert to pixels per inch, Imager will convert it back
    $img->settag(name => 'i_xres', value => 100 * 2.54);
    $img->settag(name => 'i_yres', value => 100 * 2.54);
      

• "i_aspect_only" - If this is non-zero then the values in i_xres and i_yres are treated as a ratio only. If the image format does not support aspect ratios then this is scaled so the smaller value is 72 DPI.
• "i_incomplete" - If this tag is present then the whole image could not be read. This isn't implemented for all images yet, and may not be.
• "i_lines_read" - If "i_incomplete" is set then this tag may be set to the number of scan lines successfully read from the file. This can be used to decide whether an image is worth processing.
• i_format - The file format this file was read from.
• i_background - used when writing an image with an alpha channel to a file format that doesn't support alpha channels. The "write" method will convert a normal color specification like "#FF0000" into a color object for you, but if you set this as a tag you will need to format it like "color("red","green","blue")", eg color(255,0,0).
• "i_comment" - used when reading or writing several image formats. If the format has only one text field it will be read into the "i_comment" tag or written to the file.

Quantization options

• "colors" - An arrayref of colors that are fixed. Note that some color generators will ignore this. If this is supplied it will be filled with the color table generated for the image.
• "transp" - The type of transparency processing to perform for images with an alpha channel where the output format does not have a proper alpha channel (eg. GIF). This can be any of:

• "tr_threshold" - the highest alpha value at which a pixel will be made transparent when "transp" is 'threshold'. (0-255, default 127)
• "tr_errdiff" - The type of error diffusion to perform on the alpha channel when "transp" is "errdiff". This can be any defined error diffusion type except for custom (see "errdiff" below).
• "tr_orddith" - The type of ordered dither to perform on the alpha channel when "transp" is 'ordered'. Possible values are:

• "tr_map" - When tr_orddith is custom this defines an 8 x 8 matrix of integers representing the transparency threshold for pixels corresponding to each position. This should be a 64 element array where the first 8 entries correspond to the first row of the matrix. Values should be between 0 and 255.
• "make_colors" - Defines how the quantization engine will build the palette(s). Currently this is ignored if "translate" is "giflib", but that may change. Possible values are:

• "colors" - an arrayref containing Imager::Color objects, which represents the starting set of colors to use in translating the images. "webmap" will ignore this. On return the final colors used are copied back into this array (which is expanded if necessary.)
• "max_colors" - the maximum number of colors to use in the image.
• "translate" - The method used to translate the RGB values in the source image into the colors selected by make_colors. Note that make_colors is ignored when "translate" is "giflib".

  Possible values are:

•

"errdiff" - The type of error diffusion dither to perform. These values (except for custom) can also be used in tr_errdif.

• "errdiff_width", "errdiff_height", "errdiff_orig", "errdiff_map" - When "translate" is "errdiff" and "errdiff" is "custom" these define a custom error diffusion map. "errdiff_width" and "errdiff_height" define the size of the map in the arrayref in "errdiff_map". "errdiff_orig" is an integer which indicates the current pixel position in the top row of the map.
• "perturb" - When translate is "perturb" this is the magnitude of the random bias applied to each channel of the pixel before it is looked up in the color table.