diff options
author | Siep Kroonenberg <siepo@cybercomm.nl> | 2011-02-17 12:20:49 +0000 |
---|---|---|
committer | Siep Kroonenberg <siepo@cybercomm.nl> | 2011-02-17 12:20:49 +0000 |
commit | 316ee97c621496b0fe3267f57cce81bee44ca1e6 (patch) | |
tree | cb2cab1192b4f58a7971af19b213e980bceda4b4 /Master/tlpkg/tlperl0/lib/Imager/Fill.pm | |
parent | cd0f87b5d39480d85ad9bd4ee37f520f75bed560 (diff) |
Moving old tlperl prior to committing new one
git-svn-id: svn://tug.org/texlive/trunk@21422 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/tlpkg/tlperl0/lib/Imager/Fill.pm')
-rwxr-xr-x | Master/tlpkg/tlperl0/lib/Imager/Fill.pm | 447 |
1 files changed, 447 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl0/lib/Imager/Fill.pm b/Master/tlpkg/tlperl0/lib/Imager/Fill.pm new file mode 100755 index 00000000000..34786eade76 --- /dev/null +++ b/Master/tlpkg/tlperl0/lib/Imager/Fill.pm @@ -0,0 +1,447 @@ +package Imager::Fill; +use strict; +use vars qw($VERSION); + +$VERSION = "1.010"; + +# this needs to be kept in sync with the array of hatches in fills.c +my @hatch_types = + qw/check1x1 check2x2 check4x4 vline1 vline2 vline4 + hline1 hline2 hline4 slash1 slosh1 slash2 slosh2 + grid1 grid2 grid4 dots1 dots4 dots16 stipple weave cross1 cross2 + vlozenge hlozenge scalesdown scalesup scalesleft scalesright stipple2 + tile_L stipple3/; +my %hatch_types; +@hatch_types{@hatch_types} = 0..$#hatch_types; + +*_color = \&Imager::_color; + +sub new { + my ($class, %hsh) = @_; + + my $self = bless { }, $class; + $hsh{combine} = Imager->_combine($hsh{combine}, 0); + if ($hsh{solid}) { + my $solid = _color($hsh{solid}); + if (UNIVERSAL::isa($solid, 'Imager::Color')) { + $self->{fill} = + Imager::i_new_fill_solid($solid, $hsh{combine}); + } + elsif (UNIVERSAL::isa($solid, 'Imager::Color::Float')) { + $self->{fill} = + Imager::i_new_fill_solidf($solid, $hsh{combine}); + } + else { + $Imager::ERRSTR = "solid isn't a color"; + return undef; + } + } + elsif (defined $hsh{hatch}) { + $hsh{dx} ||= 0; + $hsh{dy} ||= 0; + $hsh{fg} ||= Imager::Color->new(0, 0, 0); + if (ref $hsh{hatch}) { + $hsh{cust_hatch} = pack("C8", @{$hsh{hatch}}); + $hsh{hatch} = 0; + } + elsif ($hsh{hatch} =~ /\D/) { + unless (exists($hatch_types{$hsh{hatch}})) { + $Imager::ERRSTR = "Unknown hatch type $hsh{hatch}"; + return undef; + } + $hsh{hatch} = $hatch_types{$hsh{hatch}}; + } + my $fg = _color($hsh{fg}); + if (UNIVERSAL::isa($fg, 'Imager::Color')) { + my $bg = _color($hsh{bg} || Imager::Color->new(255, 255, 255)); + $self->{fill} = + Imager::i_new_fill_hatch($fg, $bg, $hsh{combine}, + $hsh{hatch}, $hsh{cust_hatch}, + $hsh{dx}, $hsh{dy}); + } + elsif (UNIVERSAL::isa($fg, 'Imager::Color::Float')) { + my $bg = _color($hsh{bg} || Imager::Color::Float->new(1, 1, 1)); + $self->{fill} = + Imager::i_new_fill_hatchf($fg, $bg, $hsh{combine}, + $hsh{hatch}, $hsh{cust_hatch}, + $hsh{dx}, $hsh{dy}); + } + else { + $Imager::ERRSTR = "fg isn't a color"; + return undef; + } + } + elsif (defined $hsh{fountain}) { + # make sure we track the filter's defaults + my $fount = $Imager::filters{fountain}; + my $def = $fount->{defaults}; + my $names = $fount->{names}; + + $hsh{ftype} = $hsh{fountain}; + # process names of values + for my $name (keys %$names) { + if (defined $hsh{$name} && exists $names->{$name}{$hsh{$name}}) { + $hsh{$name} = $names->{$name}{$hsh{$name}}; + } + } + # process defaults + %hsh = (%$def, %hsh); + my @parms = @{$fount->{callseq}}; + shift @parms; + for my $name (@parms) { + unless (defined $hsh{$name}) { + $Imager::ERRSTR = + "required parameter '$name' not set for fountain fill"; + return undef; + } + } + + # check that the segments supplied is an array ref + unless (ref $hsh{segments} && $hsh{segments} =~ /ARRAY/) { + $Imager::ERRSTR = + "segments must be an array reference or Imager::Fountain object"; + return; + } + + # make sure the segments are specified with colors + my @segments; + for my $segment (@{$hsh{segments}}) { + my @new_segment = @$segment; + + $_ = _color($_) or return for @new_segment[3,4]; + push @segments, \@new_segment; + } + + $self->{fill} = + Imager::i_new_fill_fount($hsh{xa}, $hsh{ya}, $hsh{xb}, $hsh{yb}, + $hsh{ftype}, $hsh{repeat}, $hsh{combine}, $hsh{super_sample}, + $hsh{ssample_param}, \@segments); + } + elsif (defined $hsh{image}) { + $hsh{xoff} ||= 0; + $hsh{yoff} ||= 0; + $self->{fill} = + Imager::i_new_fill_image($hsh{image}{IMG}, $hsh{matrix}, $hsh{xoff}, + $hsh{yoff}, $hsh{combine}); + $self->{DEPS} = [ $hsh{image}{IMG} ]; + } + elsif (defined $hsh{type} && $hsh{type} eq "opacity") { + my $other_fill = delete $hsh{other}; + unless (defined $other_fill) { + Imager->_set_error("'other' parameter required to create opacity fill"); + return; + } + unless (ref $other_fill && + eval { $other_fill->isa("Imager::Fill") }) { + # try to auto convert to a fill object + if (ref $other_fill && $other_fill =~ /HASH/) { + $other_fill = Imager::Fill->new(%$other_fill) + or return; + } + else { + undef $other_fill; + } + unless ($other_fill) { + Imager->_set_error("'other' parameter must be an Imager::Fill object to create an opacity fill"); + return; + } + } + + my $raw_fill = $other_fill->{fill}; + my $opacity = delete $hsh{opacity}; + defined $opacity or $opacity = 0.5; # some sort of default + $self->{fill} = + Imager::i_new_fill_opacity($raw_fill, $opacity); + $self->{DEPS} = [ $other_fill ]; # keep reference to old fill and its deps + } + else { + $Imager::ERRSTR = "No fill type specified"; + warn "No fill type!"; + return undef; + } + + $self; +} + +sub hatches { + return @hatch_types; +} + +sub combines { + return Imager->combines; +} + +1; + +=head1 NAME + + Imager::Fill - general fill types + +=head1 SYNOPSIS + + use Imager; + use Imager::Fill; + + my $fill1 = Imager::Fill->new(solid=>$color, combine=>$combine); + my $fill2 = Imager::Fill->new(hatch=>'vline2', fg=>$color1, bg=>$color2, + dx=>$dx, dy=>$dy); + my $fill3 = Imager::Fill->new(fountain=>$type, ...); + my $fill4 = Imager::Fill->new(image=>$img, ...); + my $fill5 = Imager::Fill->new(type => "opacity", other => $fill, + opacity => ...); + +=head1 DESCRIPTION + +Creates fill objects for use by most filled area drawing functions. + +All fills are created with the new method. + +=over + +=item new + + my $fill = Imager::Fill->new(...); + +The parameters depend on the type of fill being created. See below +for details. + +=back + +The currently available fills are: + +=over + +=item * + +solid + +=item * + +hatch + +=item * + +fountain (similar to gradients in paint software) + +=back + +=head1 Common options + +=over + +=item combine + +The way in which the fill data is combined with the underlying image. +See L<Imager::Draw/"Combine Types">. + +=back + +In general colors can be specified as Imager::Color or +Imager::Color::Float objects. The fill object will typically store +both types and convert from one to the other. If a fill takes 2 color +objects they should have the same type. + +=head2 Solid fills + + my $fill = Imager::Fill->new(solid=>$color, $combine =>$combine) + +Creates a solid fill, the only required parameter is C<solid> which +should be the color to fill with. + +=head2 Hatched fills + + my $fill = Imager::Fill->new(hatch=>$type, fg=>$fgcolor, bg=>$bgcolor, + dx=>$dx, $dy=>$dy); + +Creates a hatched fill. You can specify the following keywords: + +=over + +=item hatch + +The type of hatch to perform, this can either be the numeric index of +the hatch (not recommended), the symbolic name of the hatch, or an +array of 8 integers which specify the pattern of the hatch. + +Hatches are represented as cells 8x8 arrays of bits, which limits their +complexity. + +Current hatch names are: + +=over + +=item check1x1, check2x2, check4x4 + +checkerboards at varios sizes + +=item vline1, vline2, vline4 + +1, 2, or 4 vertical lines per cell + +=item hline1, hline2, hline4 + +1, 2, or 4 horizontal lines per cell + +=item slash1, slash2 + +1 or 2 / lines per cell. + +=item slosh1, slosh2 + +1 or 2 \ lines per cell + +=item grid1, grid2, grid4 + +1, 2, or 4 vertical and horizontal lines per cell + +=item dots1, dots4, dots16 + +1, 4 or 16 dots per cell + +=item stipple, stipple2 + +see the samples + +=item weave + +I hope this one is obvious. + +=item cross1, cross2 + +2 densities of crosshatch + +=item vlozenge, hlozenge + +something like lozenge tiles + +=item scalesdown, scalesup, scalesleft, scalesright + +Vaguely like fish scales in each direction. + +=item tile_L + +L-shaped tiles + +=back + +=item fg + +=item bg + +The fg color is rendered where bits are set in the hatch, and the bg +where they are clear. If you use a transparent fg or bg, and set +combine, you can overlay the hatch onto an existing image. + +fg defaults to black, bg to white. + +=item dx + +=item dy + +An offset into the hatch cell. Both default to zero. + +=back + +You can call Imager::Fill->hatches for a list of hatch names. + +=head2 Fountain fills + + my $fill = Imager::Fill->new(fountain=>$ftype, + xa=>$xa, ya=>$ya, xb=>$xb, yb=>$yb, + segments=>$segments, repeat=>$repeat, combine=>$combine, + super_sample=>$super_sample, ssample_param=>$ssample_param); + +This fills the given region with a fountain fill. This is exactly the +same fill as the C<fountain> filter, but is restricted to the shape +you are drawing, and the fountain parameter supplies the fill type, +and is required. + +=head2 Image Fills + + my $fill = Imager::Fill->new(image=>$src, xoff=>$xoff, yoff=>$yoff, + matrix=>$matrix, $combine); + +Fills the given image with a tiled version of the given image. The +first non-zero value of xoff or yoff will provide an offset along the +given axis between rows or columns of tiles respectively. + +The matrix parameter performs a co-ordinate transformation from the +co-ordinates in the target image to the fill image co-ordinates. +Linear interpolation is used to determine the fill pixel. You can use +the L<Imager::Matrix2d> class to create transformation matrices. + +The matrix parameter will significantly slow down the fill. + +=head2 Opacity modification fill + + my $fill = Imager::Fill->new(type => "opacity", + other => $fill, opacity => 0.25); + +This can be used to make a fill that is a more translucent or opaque +version of an existing fill. This is intended for use where you +receive a fill object as a parameter and need to change the opacity. + +Parameters: + +=over + +=item * + +type => "opacity" - Required + +=item * + +other - the fill to produce a modified version of. This must be an +Imager::Fill object. Required. + +=item * + +opacity - multiplier for the source fill opacity. Default: 0.5. + +=back + +The source fill's combine mode is used. + +=head1 OTHER METHODS + +=over + +=item Imager::Fill->hatches + +A list of all defined hatch names. + +=item Imager::Fill->combines + +A list of all combine types. + +=back + +=head1 FUTURE PLANS + +I'm planning on adding the following types of fills: + +=over + +=item checkerboard + +combines 2 other fills in a checkerboard + +=item combine + +combines 2 other fills using the levels of an image + +=item regmach + +uses the transform2() register machine to create fills + +=back + +=head1 AUTHOR + +Tony Cook <tony@develop-help.com> + +=head1 SEE ALSO + +Imager(3) + +=cut |