GD::Image::Scale2x - Implementation of the Scale2x algorithm for the GD library

    use GD;
    use GD::Image::Scale2x;

    # load an image
    my $image = GD::Image->new( 'file.png' );

    # scale2x, 3x, and 4x
    my $scaled2x = $image->scale2x;
    my $scaled3x = $image->scale3x;
    my $scaled4x = $image->scale4x;

    # scale a certain area
    # (10, 10) to (30, 30)
    my $scaled = $image->scale2x( 10, 10, 20, 20 );

    Scale2x is real-time graphics effect able to increase the size of small bitmaps
    guessing the missing pixels without interpolating pixels and blurring the images.

    The effect works repeating a computation pattern for every pixel of the
    original image. The pattern starts from a square of 9 pixels and expands
    the central pixel computing 4 new pixels.

package GD::Image::Scale2x;

use strict;
use warnings;

our $VERSION = '0.07';

package GD::Image;

use strict;
use warnings;

use Algorithm::Scale2x ();

sub scale2x {
    my $self = shift;

    return $self->_scale( 2, @_ );    
}

sub scale3x {
    my $self = shift;

    return $self->_scale( 3, @_ );    
}

sub scale4x {
    my $self = shift;

    my $image = $self->scale2x( @_ );
    return $image->scale2x;
}

sub _scale {
    my $self     = shift;
    my $scale    = shift;
    my $source_x = shift || 0;
    my $source_y = shift || 0;
    my $source_w = shift;
    my $source_h = shift;

    unless( $source_w ) {
        ( $source_w, $source_h ) = $self->getBounds;
        $source_w -= $source_x;
        $source_h -= $source_y;
    }

    my $image   = GD::Image->new( $source_w * $scale, $source_h * $scale );
    my $code    = Algorithm::Scale2x->can( "scale${scale}x" );

    my $bound_x = $source_w - 1;
    my $bound_y = $source_h - 1;

    my @palette;

    for my $y ( $source_y..$bound_y ) {
        for my $x ( $source_x..$bound_x ) {
            my $x_plus  = ( $x + 1 > $bound_x  ? $x : $x + 1 );
            my $x_minus = ( $x - 1 < $source_x ? $x : $x - 1 );
            my $y_plus  = ( $y + 1 > $bound_y  ? $y : $y + 1 );
            my $y_minus = ( $y - 1 < $source_y ? $y : $y - 1 );

            # 0 1 2 #
            # 3 4 5 # 4 => x, y
            # 6 7 8 #

            my @pixels = (
                $self->getPixel( $x_minus, $y_minus ),
                $self->getPixel( $x, $y_minus ),
                $self->getPixel( $x_plus, $y_minus ),
                $self->getPixel( $x_minus, $y ),
                $self->getPixel( $x, $y ),
                $self->getPixel( $x_plus, $y ),
                $self->getPixel( $x_minus, $y_plus ),
                $self->getPixel( $x, $y_plus ),
                $self->getPixel( $x_plus, $y_plus )
            );

            my @E = $code->( @pixels );

            my $scaledx = $x * $scale;
            my $scaledy = $y * $scale;

            for my $y ( 0..$scale - 1 ) {
                for my $x ( 0..$scale - 1 ) {
                    my $E = shift @E;
                    unless( $palette[ $E ] ) {
                        $palette[ $E ] = $image->colorAllocate( $self->rgb( $E ) );
                    }

                    $image->setPixel( $scaledx + $x, $scaledy + $y, $palette[ $E ] );
                }
            }
        }
    }

    return $image;
}

1;