=head1 NAME

Imager::ImageTypes - Internal image representation information

=head1 SYNOPSIS

  use Imager;

  $img = Imager->new(); #  Empty image (size is 0 by 0)
  $img->open(file=>'lena.png',type=>'png'); # Read image from file

  $img = Imager->new(xsize=>400, ysize=>300); # RGB data

  $img = Imager->new(xsize=>400, ysize=>300,  # Grayscale
                     channels=>1);            #

  $img = Imager->new(xsize=>400, ysize=>300,  # RGB with alpha
                     channels=>4);            #
					      
  $img = Imager->new(xsize=>200, ysize=>200,  
                     type=>'paletted');       # paletted image
					      
  $img = Imager->new(xsize=>200, ysize=>200,  
                     bits=>16);               # 16 bits/channel rgb
					      
  $img = Imager->new(xsize=>200, ysize=>200,  
                     bits=>'double');         # 'double' floating point
                                              #  per channel

  $img->img_set(xsize=>500, ysize=>500,       # reset the image object
                channels=>4);


  # Example getting information about an Imager object

  print "Image information:\n";
  print "Width:        ", $img->getwidth(),    "\n";
  print "Height:       ", $img->getheight(),   "\n";
  print "Channels:     ", $img->getchannels(), "\n";
  print "Bits/Channel: ", $img->bits(),        "\n";
  print "Virtual:      ", $img->virtual() ? "Yes" : "No", "\n";
  my $colorcount = $img->getcolorcount(maxcolors=>512);
        print "Actual number of colors in image: ";
  print defined($colorcount) ? $colorcount : ">512", "\n";
  print "Type:         ", $img->type(),        "\n";

  if ($img->type() eq 'direct') {
    print "Modifiable Channels: ";
    print join " ", map {
      ($img->getmask() & 1<<$_) ? $_ : ()
    } 0..$img->getchannels();
    print "\n";
  
  } else {
  
    @colors = $img->getcolors();
    print "Palette size: ".@colors."\n";
    my $mx = @colors > 4 ? 4 : 0+@colors;
    print "First $mx entries:\n";
    for (@colors[0..$mx-1]) {
      my @res = $_->rgba();
      print "(", join(", ", @res[0..$img->getchannels()-1]), ")\n";
    }
  }
  
  my @tags = $img->tags();
  if (@tags) {
    print "Tags:\n";
    for(@tags) {
      print shift @$_, ": ", join " ", @$_, "\n";
    }
  } else {
    print "No tags in image\n";
  }
  

=head1 DESCRIPTION

Imager supports various internal image representations of images.  The
two major classes are direct mode and paletted mode.  In paletted mode
an image has a numbered list of colors and the color of each pixel is
determined by an index into the table.  In direct mode there is no
color palette and each pixel has a seperate value for red green and
blue for RGB images.  To complicate matters it's possible to have
other color spaces than RGB, for example, gray, gray and alpha, or
red, green, blue and alpha.

In addition it's possible to have direct type images with 8 bits/channel
16 bits/channel or double/channel (64 bits on many systems).

To query an existing image about it's parameters see the C<bits()>,
C<type()>, C<getwidth()>, C<getheight()>, C<getchannels()> and
C<virtual()> methods.

The coordinate system in Imager has the origin in the upper left
corner, see L<Imager::Draw> for details.

=head2 Creating Imager Objects

=over

=item new

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

Here C<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

To create paletted images, set the 'type' parameter to 'paletted':

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

which creates an image with a maxiumum of 256 colors, which you can
change by supplying the C<maxcolors> parameter.

For improved color precision you can use the bits parameter to specify
16 bit per channel:

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

or for even more precision:

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

to get an image that uses a double for each channel.

Note that as of this writing all functions should work on images with
more than 8-bits/channel, but many will only work at only
8-bit/channel precision.

Currently only 8-bit, 16-bit, and double per channel image types are
available, this may change later.

=item img_set

If you have an existing image, use img_set() to change it's dimensions
- this will destroy any existing image data:

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

=back

=head2 Getting Information About an Imager Object

=over

=item getwidth

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

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

=item getheight

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

Same details apply as for L<getwidth>.

=item getchannels

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

To get the number of channels in an image C<getchannels()> is used.


=item getcolorcount

It is possible to have Imager find the number of colors in an image by
with the C<getcolorcount()> method. It requires memory proportionally
to the number of colors in the image so it is possible to have it stop
sooner if you only need to know if there are more than a certain
number of colors in the image.  If there are more colors than asked
for the function return undef.  Examples:

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


=item 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.

=item type

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

=item virtual

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

=back


=head2 Direct Type Images

=over

=item 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<<$_;
  }

C<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 lsb is set the i-th
channel is modifiable.

=item setmask

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

    ...

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

C<setmask()> is used to set the channel mask of the image.  See
L<getmask> for details.

=back

=head2 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 C<addcolors()>, C<setcolors()>,
C<getcolors()> and C<findcolor()>:

=over

=item 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.

=item setcolors

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

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

=item 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);

=item 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.

You can get the current palette size with $img->colorcount, and the
maximum size of the palette with $img->maxcolors.

=back

=head2 Conversion Between Image Types

Warning: if you draw on a paletted image with colors that aren't in
the palette, the image will be internally converted to a normal image.

=over

=item 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 L<Quantization options>.

=item to_rgb8

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

  $rgbimg = $img->to_rgb8;


=head2 Masked Images

Masked images let you control which pixels are modified in an
underlying image.  Where the first channel is completely black in the
mask image, writes to the underlying image are ignored.

For example, given a base image called $img:

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

You can specifiy the region of the underlying image that is masked
using the left, top, right and bottom options.

If you just want a subset of the image, without masking, just specify
the region without specifying a mask.







=head2 Tags

Image tags contain meta-data about the image, ie. information not
stored as pixels of the image.

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.

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:

  my @alltags = $img->tags;

or you can get all tags that have a given name:

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

or a given code:

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

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

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.


=head2 Common Tags

Many tags are only meaningful for one format.  GIF looping information
is pretty useless for JPEG for example.  Thus, many tags are set by
only a single reader or used by a single writer.  For a complete list
of format specific tags see L<Imager::Files>.

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.

=over

=item i_xres

=item 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.

=item 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 72dpi.

=item i_incomplete

If this tag is present then the whole image could not be read.  This
isn't implemented for all images yet.

=back





=head2 Quantization options

These options can be specified when calling write_multi() for gif
files, when writing a single image with the gifquant option set to
'gen', or for direct calls to i_writegif_gen and i_writegif_callback.

=over

=item colors

A arrayref of colors that are fixed.  Note that some color generators
will ignore this.

=item 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:

=over

=item none

No transparency processing is done. (default)

=item threshold

Pixels more transparent that tr_threshold are rendered as transparent.

=item errdiff

An error diffusion dither is done on the alpha channel.  Note that
this is independent of the translation performed on the colour
channels, so some combinations may cause undesired artifacts.

=item ordered

The ordered dither specified by tr_orddith is performed on the alpha
channel.

=back

This will only be used if the image has an alpha channel, and if there
is space in the palette for a transparency colour.

=item tr_threshold

The highest alpha value at which a pixel will be made transparent when
transp is 'threshold'. (0-255, default 127)

=item 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).

=item tr_orddith

The type of ordered dither to perform on the alpha channel when transp
is 'ordered'.  Possible values are:

=over

=item random

A semi-random map is used.  The map is the same each time.

=item dot8

8x8 dot dither.

=item dot4

4x4 dot dither

=item hline

horizontal line dither.

=item vline

vertical line dither.

=item "/line"

=item slashline

diagonal line dither

=item '\line'

=item backline

diagonal line dither

=item tiny

dot matrix dither (currently the default).  This is probably the best
for displays (like web pages).

=item custom

A custom dither matrix is used - see tr_map

=back

=item 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
betweern 0 and 255.

=item 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:

=over

=item none

Only colors supplied in 'colors' are used.

=item webmap

The web color map is used (need url here.)

=item addi

The original code for generating the color map (Addi's code) is used.

=item mediancut

Uses a mediancut algorithm, faster than 'addi', but not as good a
result.

=back

Other methods may be added in the future.

=item colors

A arrayref containing Imager::Color objects, which represents the
starting set of colors to use in translating the images.  webmap will
ignore this.  The final colors used are copied back into this array
(which is expanded if necessary.)

=item max_colors

The maximum number of colors to use in the image.

=item 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
whene translate is 'giflib'.

Possible values are:

=over

=item giflib

The giflib native quantization function is used.

=item closest

The closest color available is used.

=item perturb

The pixel color is modified by perturb, and the closest color is chosen.

=item errdiff

An error diffusion dither is performed.

=back

It's possible other transate values will be added.

=item errdiff

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

=over

=item floyd

Floyd-Steinberg dither

=item jarvis

Jarvis, Judice and Ninke dither

=item stucki

Stucki dither

=item custom

Custom.  If you use this you must also set errdiff_width,
errdiff_height and errdiff_map.

=back

=item errdiff_width

=item errdiff_height

=item errdiff_orig

=item 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.

=item 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.

=back


=cut
