Free die kurve software for linux

Imager::Filters is an entire image filtering operations.

SYNOPSIS

use Imager;

$img = ...;

$img->filter(type=>autolevels);
$img->filter(type=>autolevels, lsat=>0.2);
$img->filter(type=>turbnoise)

# and lots of others

load_plugin("dynfilt/dyntest.so")
or die "unable to load pluginn";

$img->filter(type=>lin_stretch, a=>35, b=>200);

unload_plugin("dynfilt/dyntest.so")
or die "unable to load pluginn";

$out = $img->difference(other=>$other_img);

Filters are operations that have similar calling interface.

filter

Parameters:

type - the type of filter, see "Types of Filters".

many other possible parameters, see "Types of Filters" below.

SimpleCDB - A Perl-only Constant Database.

SYNOPSIS

use SimpleCDB;

# writer
# - tie blocks until DB is available (exclusive), or timeout
tie %h, SimpleCDB, db, O_WRONLY
or die "tie failed: $SimpleCDB::ERRORn";
$h{$k} = $v;
die "store: $SimpleCDB::ERROR" if $SimpleCDB::ERROR;
untie %h; # release DB (exclusive) lock

# reader
# - tie blocks until DB is available (shared), or timeout
tie %h, SimpleCDB, db, O_RDONLY
or die "tie failed: $SimpleCDB::ERRORn";
$v = $h{$i};
die "fetch: $SimpleCDB::ERROR" if $SimpleCDB::ERROR;
untie %h; # release DB (shared) lock

This is a simple perl-only DB intended for constant DB applications. A constant DB is one which, once created, is only ever read from (though this implementation allows appending of new data). That is, this is an "append-only DB" - records may only be added and/or extracted.

Course-grained locking provided to allow multiple users, as per flock semantics (i.e. write access requires an exclusive lock, read access needs a shared lock (see notes below re. perl < 5.004)). As (exclusive) updates may be take some time to complete, shared lock attempts will timeout after a defined waiting period (returning $! == EWOULDBLOCK). Concurrent update attempts will behave similarly, but with a longer timeout.

The DB files are simple flat files, with one record per line. Records (both keys and values) may be arbitrary (binary) data. Records are extracted from these files via a plain linear search. Unsurprisingly, this search is a relatively inefficient operation. To improve extraction speed, records are randomly distributed across N files, with the average search space is reduced by 1/N compared to a single file. (See below for some example performance times.) One advantage of this flat file based solution is that the DB is human readable (assuming the data is), and with some care can be edited with a plain ol text editor.

Finally, note that this DB does not support duplicate entries. In practice, the first record found matching a given key is returned, any duplicates will be ignored.

File::Sync is a Perl access to fsync() and sync() function calls.

SYNOPSIS

use File::Sync qw(fsync sync);
fsync(*FILEHANDLE) or die "fsync: $!";
sync();

use File::Sync qw(fsync);
use IO::File;
$fh = IO::File->new("> /tmp/foo")
or die "new IO::File: $!";
...
fsync($fh) or die "fsync: $!";

The fsync() function takes a Perl file handle as its only argument, and passes its fileno() to the C function fsync(). It returns undef on failure, or true on success.
The fsync_fd() function is used internally by fsync(); it takes a file descriptor as its only argument.

The sync() function is identical to the C function sync().
This module does not export any methods by default, but fsync() is made available as a method of the FileHandle and IO::Handle classes.

Audio:PSID is a Perl module to handle SID files (Commodore-64 music files).

SYNOPSIS

use Audio::SID;

$mySID = new Audio::SID(-filename => Test.sid) or die "Whoops!";

print "Title = " . $mySID->get(title) . "n";

print "MD5 = " . $mySID->getMD5();

$mySID->set(author => LaLa,
title => Test2,
released => 2001 Hungarian Music Crew);

$mySID->validate();
$mySID->write(-filename => Test2.sid) or die "Couldnt write file!";

@array = $mySID->getFieldNames();
print "Fieldnames = " . join( , @array) . "n";

This module is designed to handle SID files (usually bearing a .sid extension), which are music player and data routines converted from the Commodore-64 computer with an additional informational header prepended. For further details about the exact file format, see description of all SID fields in the SID_file_format.txt file included in the module package.

WebService::Eventful is a Perl interface to EVDB public API.

SYNOPSIS

use WebService::Eventful;

my $evdb = WebService::Eventful->new(app_key => $app_key);

$evdb->login(user => harry, password => H0gwart$)
or die "Cant log in: $WebService::Eventful::errstr";

# call() accepts either an array ref or a hash ref.
my $event = $evdb->call(events/get, {id => E0-001-000218163-6})
or die "Cant retrieve event: $WebService::Eventful::errstr";

print "Title: $event->{title}n";

my $venue = $evdb->call(venues/get, [id => $event->{venue_id}])
or die "Cant retrieve venue: $WebService::Eventful::errstr";

print "Venue: $venue->{name}n";

The Eventful API allows you to build tools and applications that interact with Eventful. This module provides a Perl interface to that API, including the digest-based authentication infrastructure.