view release on metacpan or search on metacpan
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
use strict;
use warnings;
use Finance::MICR::LineParser;
use Finance::MICR::GOCR;
use File::PathInfo;
use Image::Magick;
our $VERSION = sprintf "%d.%02d", q$Revision: 1.3 $ =~ /(\d+)/g;
$Finance::MICR::GOCR::Check::DEBUG=0;
sub DEBUG : lvalue { $Finance::MICR::GOCR::Check::DEBUG }
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
sub im { # object containing image magick object already reading the check image
my $self = shift;
unless( defined $self->{im} ){
my $i = new Image::Magick;
$i->Read($self->f->abs_path);
$self->{im} = $i;
}
return $self->{im}->Clone;
}
view release on metacpan or search on metacpan
examples/magick.pl view on Meta::CPAN
#!/usr/bin/perl -w
use strict;
# This program demonstrates using Font::FreeType with Image::Magick.
# It uses the font metrics to position glyphs next to each other as
# a typesetting engine would, and renders them both by compositing a
# bitmap of each glyph onto the output image (using the bitmap_magick()
# convenience method) and by drawing the outline using ImageMagick
# drawing functions.
# TODO - use kerning.
use Font::FreeType;
use Image::Magick;
use List::Util qw( sum );
my $text = "\xC2g."; # 'Ag.', with a circumflex over the 'A'
my $size = 72;
my $dpi = 600;
examples/magick.pl view on Meta::CPAN
$width -= $glyphs[-1]->right_bearing;
my $height = $face->height;
$width += $border * 2;
$height += $border * 2;
my $img = Image::Magick->new(size => "${width}x$height");
$img->Read('xc:white');
$img->Set(stroke => '#0000AA');
my $origin_y = -$face->descender + $border;
my ($text_x, $text_y) = (-$glyphs[0]->left_bearing + $border, $origin_y);
view release on metacpan or search on metacpan
lib/Foorum/TheSchwartz/Worker/ResizeProfilePhoto.pm view on Meta::CPAN
use warnings;
our $VERSION = '1.001000';
use base qw( TheSchwartz::Moosified::Worker );
use Foorum::SUtils qw/schema/;
use Foorum::XUtils qw/base_path/;
use Image::Magick;
use File::Copy ();
use File::Spec;
sub work {
my $class = shift;
lib/Foorum/TheSchwartz/Worker/ResizeProfilePhoto.pm view on Meta::CPAN
$directory_2, $upload->filename
)
);
# resize photo
my $p = new Image::Magick;
$p->Read($file);
$p->Scale( geometry => '120x120' );
$p->Sharpen( geometry => '0.0x1.0' );
$p->Set( quality => '75' );
lib/Foorum/TheSchwartz/Worker/ResizeProfilePhoto.pm view on Meta::CPAN
# check bin/cron/TheSchwartz_client.pl and bin/cron/TheSchwartz_worker.pl for usage
=head1 DESCRIPTION
Since L<Image::Magick> is a bit heavy to load into httpd, we move use Image::Magick; in this cron job.
=head1 SEE ALSO
L<TheSchwartz>
view release on metacpan or search on metacpan
lib/GD/Barcode/Image.pm view on Meta::CPAN
package GD::Barcode::Image;
use strict;
use Image::Magick;
use GD::Barcode;
require Exporter;
use vars qw($VERSION @ISA $AUTOLOAD);
@ISA = qw(Exporter); # HAS-A GD::Barcode:<Symbology>, no IS-A
$VERSION = 1.03;
lib/GD/Barcode/Image.pm view on Meta::CPAN
sub init() {
return 'Error in init() - Invalid Barcode Type: "Image"';
}
#------------------------------------------------------------------------------
# plot_imagick: Convert to Image::Magick Object (for GD::Barcode)
# Requires both the GD and Image::Magick modules.
# signature is similar to GD::Barcode::QRcode->plot()
#------------------------------------------------------------------------------
sub plot_imagick($%) {
my ( $oThis, %hParam ) = @_;
#Create Image
my $imNew = undef;
eval {
require Image::Magick;
my ( $gdNew, $png ) = ( undef, undef );
$gdNew = $oThis->{gd_barcode}->plot(%hParam);
if ($gdNew) {
$png = $gdNew->png();
$imNew = Image::Magick->new();
$GD::Barcode::errStr = $imNew->BlobToImage($png);
$imNew = undef
if ($GD::Barcode::errStr); # on error, free imagick object
}
lib/GD/Barcode/Image.pm view on Meta::CPAN
}
#------------------------------------------------------------------------------
=head1 NAME
GD::Barcode::Image - Create Image::Magick object for a barcode
=head1 SYNOPSIS
use GD::Barcode::Image;
lib/GD/Barcode/Image.pm view on Meta::CPAN
=item plot_imagick()
I<$oGdIm> = $oGdBarIm->plot_imagick([Height => I<$iHeight>, NoText => I<0 | 1>]);
creates Image::Magick object for the barcode object.
I<$iHeight> is height of the image. If I<NoText> is 1, the image has no text image of I<$sTxt>.
Height and NoText parameters will not apply to the QRcode barcode type.
=item plot_gd()
view release on metacpan or search on metacpan
GD::Map to function. The create_basemap function modifies this file.
NOTE!!!. Once the basemap file has been created, you need to scale it down 25%.
You can do this in whatever editor you want, but the initial drawing is a little
crunchy, so I usually use gimp or something to smooth things out. This seemed
better than trying to incorporate Image::Magick in here, which sometimes gets cranky.
Plus, basemaps do not get created very often so it is not much work. Maybe in the
future I will add an option to do this for you if you have Image::Magick installed.
=head2 CREATING MAPS
my $m = GD::Map::new(
basemap_path => "/data/basemaps",
view release on metacpan or search on metacpan
table_name => 'sessions', # only change this value, if you *really* have to use another table name. Also change the SQL code below.
user => 'root', # database user name
pass => q{}, # database user's password
font => getcwd.'/StayPuft.ttf', # ttf font. change this to an absolute path if getcwd is failing
itype => 'png', # image format. set this to gif or png or jpeg
use_magick => 0, # use Image::Magick or GD
img_stat => 1, # display statistics on the image?
program => q{}, # if CGI.pm fails to locate program url, set this value.
);
# You'll need this to create the sessions table.
sub backenduri {
my $self = shift;
my $rv = q{Security image generated with <b>};
$rv .= $self->{IS_GD}
? qq~<a href="$self->{CPAN}/GD" target="_blank">GD</a> v$GD::VERSION~
: qq~<a href="$self->{CPAN}/PerlMagick" target="_blank">Image::Magick</a> v$Image::Magick::VERSION~;
return $rv . '</b>';
}
sub _random { return String::Random->new->randregex('\d\d\d\d\d\d') }
</tr>
<tr>
<td> use_magick </td>
<td><i>FALSE</i></td>
<td>False value: <b>GD</b> will be used; True value: <b>Image::Magick</b>
will be used.</b>
</td>
</tr>
<tr>
DBI
DBD::mysql
Apache::Session::MySQL
String::Random
GD::SecurityImage (with GD or Image::Magick)
and these CORE modules:
CGI
Cwd
Time::HiRes
Also, be sure to use recent versions of GD. This demo needs at least
version C<1.31> of GD. And if you want to use C<Image::Magick> it must
be C<6.0.4> or newer.
You'll also need a MySQL server to run the program. You must create
a table with this SQL code:
view release on metacpan or search on metacpan
lib/GD/Thumbnail.pm view on Meta::CPAN
error.
=head1 SEE ALSO
L<GD>, L<Image::Thumbnail>, L<GD::Image::Thumbnail>, L<Image::GD::Thumbnail>
L<Image::Magick::Thumbnail>, L<Image::Magick::Thumbnail::Fixed>.
=head1 AUTHOR
Burak Gursoy <burak@cpan.org>
view release on metacpan or search on metacpan
=head1 SEE ALSO
L<GD::Polyline>,
L<GD::SVG>,
L<GD::Simple>,
L<Image::Magick>
=cut
1;
view release on metacpan or search on metacpan
Graph/colour.pm view on Meta::CPAN
=head2 rgb2hex($red, $green, $blue)
=head2 hex2rgb('#7fe310')
These functions translate a list of RGB values into a hexadecimal
string, as is commonly used in HTML and the Image::Magick API, and vice
versa.
Exported with the :convert tag.
=cut
view release on metacpan or search on metacpan
GFL/Image.pm view on Meta::CPAN
This wrapper is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=head1 SEE ALSO
GD(3), Image::Magick(3)
=cut
1;
view release on metacpan or search on metacpan
GIFgraph.pm view on Meta::CPAN
This module should work with all versions of GD, but it has only been
tested with version 1.19 and above. Version 1.19 is the last version
that produces GIF output directly. Any version later than that requires
a conversion step. The default distribution of GIFgraph uses
Image::Magick for this. If you'd like to use something else, please
replace the sub png2gif in GIFgraph::Convert with something more to your
liking.
=head1 NOTES
view release on metacpan or search on metacpan
use strict;
use warnings;
use GRNOC::WebService::Client;
use Image::Magick;
use Data::Dumper;
my $FILENAME = 'image.jpg';
# use the image webservice and set it to use raw output
open(SAVE, ">$FILENAME") or warn($!);
print SAVE $image;
close(SAVE) or warn($!);
# create imagemagick object used to validate image
my $imagick = Image::Magick->new();
# make sure it appears to be a valid jpeg
$imagick->Read($FILENAME);
my $rows = $imagick->Get( 'rows' );
view release on metacpan or search on metacpan
lib/GSM/SMS/NBS.pm view on Meta::CPAN
For this method you'll also need to provide a country code and an operator code.
I've assembled a list of country and operator codes for different mobile
operators in the file "I<docs/codes.txt>". For the moment there is no convenience class that implements the lookup of these code according to the mobile phone number. Due to the dynamic nature of these numbers - numbers can be kept when switching ope...
The method expects a base64 serialised image and the format of the image, 'gif', 'png'. The L<Image::Magick> package is used to process the image, this guarabntees a lot of supported formats. The image needs to be 71 by 14 pixels.
=cut
sub sendOperatorLogo_b64 {
my ($self, $msisdn, $country, $operator, $b64, $format) = @_;
lib/GSM/SMS/NBS.pm view on Meta::CPAN
=item B<sendGroupGraphic_b64> - Send a group graphic
$nbs->sendGroupGraphic_b64( $msisdn, $b64, $format);
Send a group graphic, also called a Caller Line Identification icon ( CLIicon ),to the recipient indicated by the telephone number $msisdn. It expects a base 64 encoded image and the format the image is in, like 'gif', 'png'. To find out which image ...
=cut
sub sendGroupGraphic_b64 {
my ($self, $msisdn, $b64, $format) = @_;
view release on metacpan or search on metacpan
lib/GFtemplate.pm view on Meta::CPAN
our $VERSION = '0.081';
use parent qw(Backend::MainWindow); ##
use Image::Magick; ##other modules that need to be loaded
use Exporter 'import'; ##somefunctions are always passed back to GUIDeFATE.pm
our @EXPORT_OK = qw<addButton addStatText addTextCtrl addMenuBits addPanel setScale $frame $winScale $winWidth $winHeight $winTitle>;
our $frame; # The frame which is the parent of all the widgets
lib/GFtemplate.pm view on Meta::CPAN
if ($panelType eq "I"){ # Image panels start with I
$content=~s/^\s+|\s+$//g;
if (! -e $content){ return; }
no warnings; # sorry about that...suppresses a "Useless string used in void context"
my $image = Image::Magick->new;
my $r = $image->Read("$content");
if ($image){
# function to place image at ${$location}[0],${$location}[1] of size ${$size}[0],${$size}[1]
# Image id is "Image".($id+1)...notice capital I and also $id is incremented (sometimes useful to put
# image in a container and if the container needs an ID then the containers ID is suffexed $id
lib/GFtemplate.pm view on Meta::CPAN
sub setImage{
my ($self,$id,$file)=@_;
my $location=getLocation($self,$id,\@subpanels);
my $size=getSize($self,$id,\@subpanels);
if ($size){
my $image = Image::Magick->new;
my $r = $image->Read("$file");
if ($image){
# function to place image at ${$location}[0],${$location}[1] of size ${$size}[0],${$size}[1]
# Image id is "Image".($id+1)...notice capital I and also $id is incremented (sometimes useful to put
# image in a container and if the container needs an ID then the containers ID is suffexed $id
view release on metacpan or search on metacpan
lib/Games/Risk/Tk/Main.pm view on Meta::CPAN
package Games::Risk::Tk::Main;
# ABSTRACT: main prisk window
$Games::Risk::Tk::Main::VERSION = '4.000';
use POE qw{ Loop::Tk };
use Image::Magick;
use Image::Size qw{ imgsize };
use List::Util qw{ min };
use MIME::Base64 qw{ encode_base64 };
use Moose;
use MooseX::Has::Sugar;
lib/Games/Risk/Tk/Main.pm view on Meta::CPAN
my $c = $self->_w('canvas');
# first time that the country is flashed
if ( not defined $on ) {
# load greyscale image...
my $magick = Image::Magick->new;
$magick->Read( Games::Risk->new->map->greyscale );
# and paint everything that isn't the country in white
my $id = $country->id;
my $grey = "rgb($id,$id,$id)";
lib/Games/Risk/Tk/Main.pm view on Meta::CPAN
# check if we're at startup screen...
my $map = Games::Risk->new->map;
if ( defined $map ) {
# in a game
# create a new image resized to fit new dims
my $magick = Image::Magick->new;
$magick->Read( $map->background );
$magick->Scale(width=>$neww, height=>$newh);
# install this new image inplace of previous background
my $img = $c->Photo( -data => encode_base64( $magick->ImageToBlob ) );
view release on metacpan or search on metacpan
Revision history for Perl module Geo::Heatmap
0.15 2013-12-05
* Moved from Image::Magick to Imager
* migrated HTML example to Google Map API V3
view release on metacpan or search on metacpan
* Build:
Support Module::Build as an alternative to ExtUtils::MakeMaker.
* Feature:
Allow on the fly rescaling of tiles. E.g. a tile for zoom level n
will be zoomed by 200% (using Image::Magick or Graphics::Magick or
something alike), cut into four, and stored as four tiles of zoom
level n+1.
Problem: Image::Magick or Graphics::Magick is quite a heavy
prerequisite given that Geo::OSM::Tiles is also used on handheld
devices. Consider to make this feature configurable at build time.
# Local Variables:
view release on metacpan or search on metacpan
examples/draw-lab-colorspace.pl view on Meta::CPAN
# draw a RGB gamut in Lab space (uses Adobe RGB)
$space = $ARGV[0] || 'Adobe';
use Graphics::ColorObject;
use Image::Magick;
$img = Image::Magick->new;
($w, $h, $z) = (200, 200, 10);
$img->Set(size=>$w .'x'. $h);
$img->ReadImage('xc:black');
my ($r, $g, $b);
view release on metacpan or search on metacpan
lib/Graphics/DZI.pm view on Meta::CPAN
=over
=item C<image>
The L<Image::Magick> object which is used as canvas.
(since 0.05)
The image can also be a whole stack (L<Image::Magick> allows you to do that). In that case the
bottom image is regarded as the one with the I<highest> degree of detail, and that is tiled first
(at the higher resolutions). Images up the stack are then taken in turn, until only the top-level
image remains. See C<pop> if you want to influence this policy.
=item C<scale> (integer, default: 1)
lib/Graphics/DZI.pm view on Meta::CPAN
=back
=cut
has 'image' => (isa => 'Image::Magick', is => 'rw', required => 1);
has 'scale' => (isa => 'Int', is => 'ro', default => 1);
has 'overlap' => (isa => 'Int', is => 'ro', default => 4);
has 'tilesize' => (isa => 'Int', is => 'ro', default => 256);
has 'format' => (isa => 'Str' , is => 'ro', default => 'png');
has 'overlays' => (isa => 'ArrayRef', is => 'rw', default => sub { [] });
view release on metacpan or search on metacpan
lib/Graphics/HotMap.pm view on Meta::CPAN
=over 4
=cut
use Data::Dumper;
use Image::Magick;
use Math::Gradient qw(multi_array_gradient);
use PDL;
use PDL::NiceSlice;
use PDL::IO::Pic;
use POSIX qw(strftime);
lib/Graphics/HotMap.pm view on Meta::CPAN
=cut
sub _genPicture {
my $self = shift;
my $image = $self->{_im} = new Image::Magick();
# write a temporary image of the piddle
my $imag = byte $self->{_mapPoints};
my $tmpName = tmpnam().'.png';
#eval { $self->{_hotMap}->genImage };
lib/Graphics/HotMap.pm view on Meta::CPAN
my $fileName = shift || $self->{_outfileGif} || die "No output GIF specified";
my $image = shift;
my $im = $self->{_im};
unless (defined $image) {
$image = new Image::Magick(size => "$self->{_mapSize}{x}x$self->{_mapSize}{y}");
$image->Read($fileName);
}
$image->Set(magick=>'GIF', loop=> 100);
$im->Set(magick=>'GIF', delay=>100);
push (@$image, $im);
view release on metacpan or search on metacpan
lib/Graphics/Skullplot.pm view on Meta::CPAN
use Data::Dumper;
use File::Basename qw( fileparse basename dirname );
# use List::Util qw( first max maxstr min minstr reduce shuffle sum );
# use List::MoreUtils qw( any zip uniq );
use Image::Magick;
use lib "../../../Table-Classify/lib";
use lib "../../../Data-BoxFormat/lib";
use Table::BoxFormat;
lib/Graphics/Skullplot.pm view on Meta::CPAN
Defaults to "/tmp".
=item image_viewer
Defaults to 'display', the ImageMagick viewer
(a dependency on Image::Magick ensures it's available)
=back
=cut
view release on metacpan or search on metacpan
lib/Graphics/TIFF.pm view on Meta::CPAN
The build dependencies are additionally the development headers for libtiff
and Perl.
=head2 Test
In addition to the above, the Perl module Image::Magick is required to run some
of the tests.
=head1 INCOMPATIBILITIES
=head1 BUGS AND LIMITATIONS
view release on metacpan or search on metacpan
"requires" : {
"Carp::Always" : "0",
"ExtUtils::MakeMaker" : "0",
"File::Spec" : "0",
"File::Temp" : "0",
"Image::Magick" : "0",
"MIME::Base64" : "0",
"Test::Deep" : "0",
"Test::MockObject" : "0",
"Test::More" : "0",
"Try::Tiny" : "0"
view release on metacpan or search on metacpan
lib/HTML/Bricks.pm view on Meta::CPAN
#
# Check for URIs handled Bricks::Magick
#
# Wrapped in Eval because we want Bricks to mostly work even if the user
# hasn't installed Image::Magick
#
eval {
require "HTML/Bricks/Magick.pm";
return OK if HTML::Bricks::Magick::handler(@_) == OK;
view release on metacpan or search on metacpan
lib/HTML/FromMail/Default/Previewers.pm view on Meta::CPAN
our @previewers =
( 'text/plain' => \&previewText
, 'text/html' => \&previewHtml
, 'image' => \&previewImage # added when Image::Magick is installed
);
sub previewText($$$$$)
{ my ($page, $message, $part, $attach, $args) = @_;
lib/HTML/FromMail/Default/Previewers.pm view on Meta::CPAN
};
}
BEGIN
{ eval { require Image::Magick };
if($@) { warn "No Image::Magick installed" }
else { push @previewers, image => \&previewImage }
}
sub previewImage($$$$$)
{ my ($page, $message, $part, $attach, $args) = @_;
my $filename = $attach->{filename};
my $magick = Image::Magick->new;
my $error = $magick->Read($filename);
if(length $error)
{ __PACKAGE__->log(ERROR =>
"Cannot read image from $filename: $error");
return;
view release on metacpan or search on metacpan
eg/ApacheHandler2.pm view on Meta::CPAN
use Apache::Session;
use MasonX::Request::WithApacheSession2;
use DBI;
use Data::Dumper;
use Image::Magick;
use Date::Format;
use Net::IP::CMatch;
use HTML::Lint;
}
view release on metacpan or search on metacpan
lib/HTML/Revelation.pm view on Meta::CPAN
=over 4
=item Where did the colors come from?
From the Image::Magick web site. I extracted them from a web page there using the
amazing HTML::TreeBuilder module. See scripts/extract.colors.pl.
=item Why do you discard the first 220 colors?
Because they are too dark for my liking.
view release on metacpan or search on metacpan
lib/Health/SHC/Extract.pm view on Meta::CPAN
=item * L<PostScript::Convert>
=item * L<File::Temp>
=item * L<Image::Magick>
=item * L<Barcode::ZBar>
=back
lib/Health/SHC/Extract.pm view on Meta::CPAN
=cut
sub extract_qr_from_png {
my $self = shift;
my $filename = shift;
require Image::Magick;
require Barcode::ZBar;
# obtain image data
my $magick = Image::Magick->new();
$magick->Read($filename) && die;
my $raw = $magick->ImageToBlob(magick => 'GRAY', depth => 8);
# wrap image data
my $image = Barcode::ZBar::Image->new();
view release on metacpan or search on metacpan
lib/IIIF.pm view on Meta::CPAN
=over
=item L<https://github.com/IIIF/awesome-iiif>
=item L<Image::Magick>
=item L<Plack::App::ImageMagick>
=back
view release on metacpan or search on metacpan
devel/magick.pl view on Meta::CPAN
# with Image-Base-Magick. If not, see <http://www.gnu.org/licenses/>.
use 5.010;
use strict;
use warnings;
use Image::Magick;
use Smart::Comments;
use lib 't';
use MyTestImageBase;
# Is this wrapped by perlmagick ?
# {
# my @MagickVersion = Image::Magick->GetMagickVersion;
# ### @MagickVersion
# exit 0;
# }
{
devel/magick.pl view on Meta::CPAN
}
{
my $filename = 'temp%d.png';
my $m = Image::Magick->new or die;
# if (my $err = $m->Set (size => '20x10')) { die $err }
if (my $err = $m->ReadImage('xc:black')) { die $err }
if (my $err = $m->Set (filename => $filename)) { die $err }
require Fcntl;
devel/magick.pl view on Meta::CPAN
exit 0;
}
{
my $m = Image::Magick->new (
# width => 20, height => 10,
size => '20x10',
# size => '20x',
);
### initial width: $m->Get('width')
devel/magick.pl view on Meta::CPAN
{
use strict;
use warnings;
use Image::Magick;
unlink "/tmp/out.png";
my $m = Image::Magick->new (size => '1x1');
if (!$m) { die; }
### $m
my $err = $m->ReadImage('xc:black');
if ($err) { die $err; }
devel/magick.pl view on Meta::CPAN
$filename = "/tmp/xx.png";
$m->Write (filename => $filename,
# quality => 75,
);
$m = Image::Magick->new; # (size => '64x64');
if (!$m) { die; }
### $m
# $err = $m->SetAttribute (debug => 'all,trace');
# $err = $m->SetAttribute (debug => 'all');
devel/magick.pl view on Meta::CPAN
}
{
my $m = Image::Magick->new;
### m: $m->Get('magick')
$m->Read('/usr/share/emacs/23.2/etc/images/icons/hicolor/16x16/apps/emacs.png');
### magick: $m->Get('magick')
### width: $m->Get('width')
### height: $m->Get('width')
devel/magick.pl view on Meta::CPAN
$m->Write(filename => '/tmp/image%%03d.data');
exit 0;
}
{
my $m = Image::Magick->new;
# $m->Set(width=>10, height => 10);
$m->Set(size=>'20x10');
$m->ReadImage('xc:black');
say $m->Get('width');
devel/magick.pl view on Meta::CPAN
$m->Write ('xpm:-');
exit 0;
$m->Set (size=>'20x10');
$m->Set (magick=>'xpm');
$m = Image::Magick->new;
$m->Set(size=>'20x10');
$m->ReadImage('xc:white');
# #$m->Read ('/usr/share/emacs/22.3/etc/images/icons/emacs_16.png');
# $m->Draw (primitive => 'rectangle',
devel/magick.pl view on Meta::CPAN
{
use strict;
use warnings;
use Image::Magick;
my $m = Image::Magick->new (size => '20x10');
if (!$m) { die; }
### $m
my $err = $m->ReadImage('xc:black');
if ($err) { die $err; }