File Coverage

blib/lib/Image/Random.pm

Criterion	Covered	Total	%
statement	24	77	31.1
branch	0	20	0.0
condition	0	9	0.0
subroutine	8	15	53.3
pod	4	4	100.0
total	36	125	28.8

package Image::Random;

# Pragmas.
use strict;
use warnings;

# Modules.
use Class::Utils qw(set_params);
use Error::Pure qw(err);
use File::Basename qw(fileparse);
use Imager;
use Imager::Color;
use List::MoreUtils qw(none);

# Version.
our $VERSION = 0.05;

# Constructor.
sub new {
	my ($class, @params) = @_;

	# Create object.
	my $self = bless {}, $class;

	# Background color.
	$self->{'color_random'} = 1;
	$self->{'color'} = undef;

	# Image type.
	$self->{'type'} = 'bmp';

	# Sizes.
	$self->{'height'} = 1080;
	$self->{'width'} = 1920;

	# Process params.
	set_params($self, @params);

	# Image magick object.
	$self->_imager;

	# Check color.
	if (defined $self->{'color'}
		&& ! $self->{'color'}->isa('Imager::Color')) {

		err 'Bad background color definition. Use Imager::Color '.
			'object.';
	}
	if (! $self->{'color_random'} && ! defined $self->{'color'}) {
		err 'Color isn\'t set.';
	}

	# Check type.
	if (defined $self->{'type'}) {
		$self->_check_type($self->{'type'});
	}

	# Object.
	return $self;
}

# Create image.
sub create {
	my ($self, $path) = @_;

	# Background color.
	my $background;
	if ($self->{'color_random'}) {
		$background = Imager::Color->new(int rand 256, int rand 256,
			int rand 256);
	} else {
		$background = $self->{'color'};
	}

	# Create image.
	$self->{'i'}->box(
		'color' => $background,
		'filled' => 1,
	);

	# Get type.
	my $suffix;
	if (! defined $self->{'type'}) {

		# Get suffix.
		(my $name, undef, $suffix) = fileparse($path, qr/\.[^.]*/ms);
		$suffix =~ s/^\.//ms;

		# Jpeg.
		if ($suffix eq 'jpg') {
			$suffix = 'jpeg';
		}

		# Check type.
		$self->_check_type($suffix);
	} else {
		$suffix = $self->{'type'};
	}

	# Save.
	my $ret = $self->{'i'}->write(
		'file' => $path,
		'type' => $suffix,
	);
	if (! $ret) {
		err "Cannot write file to '$path'.",
			'Error', Imager->errstr;
	}

	return $suffix;
}

# Set/Get image sizes.
sub sizes {
	my ($self, $width, $height) = @_;
	if ($width && $height) {
		$self->{'width'} = $width;
		$self->{'height'} = $height;
		$self->_imager;
	}
	return ($self->{'width'}, $self->{'height'});
}

# Set/Get image type.
sub type {
	my ($self, $type) = @_;
	if ($type) {
		$self->_check_type($type);
		$self->{'type'} = $type;
	}
	return $self->{'type'};
}

# Check supported image type.
sub _check_type {
	my ($self, $type) = @_;

	# Check type.
	if (none { $type eq $_ } ('bmp', 'gif', 'jpeg', 'png',
		'pnm', 'raw', 'sgi', 'tga', 'tiff')) {

		err "Suffix '$type' doesn't supported.";
	}

	return;
}

# Create imager object.
sub _imager {
	my $self = shift;
	$self->{'i'} = Imager->new(
		'xsize' => $self->{'width'},
		'ysize' => $self->{'height'},
	);
	return;
}

1;

__END__