Free equalize 1.00 software for linux

Equalize plug-in does a histogram equalization of the image.

That is, it modifies the images histogram so that it is approximately horizontal, so that all intensity values cover about the same number of pixels in the image (i.e. the histogram is well-balanced).

libmoney is a library that allows a developer to build an application that keeps track of finances. It was originally developed to keep track of a budget, but can be expanded to keep track of all assets.

Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.

It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.

Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, and a file `config.log containing compiler output (useful mainly for
debugging `configure).

It can also use an optional file (typically called `config.cache and enabled with `--cache-file=config.cache or simply `-C) that saves the results of its tests to speed up reconfiguring. (Caching is disabled by default to prevent problems with accidental use of stale cache files.)

If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.

If you are using the cache, and at some point `config.cache contains results you dont want to keep, you may remove or edit it.

The file `configure.ac (or `configure.in) is used to create `configure by a program called `autoconf. You only need `configure.ac if you want to change it or regenerate `configure using a newer version of `autoconf.

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.

If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.

There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Oracle client is a simplistic Perl-based Oracle client that tries to mimic some of the functionality of PostgreSQL and MySQLs text-based SQL clients.

It is relatively simplistic, but much more useful than dbishell or sqlplus.

The project supports readline, history, desc, and various shorthand commands like d, , c, etc.

Search::Lemur is a Perl class to query a Lemur server, and parse the results.

SYNOPSYS

use Search::Lemur;

my $lem = Search::Lemur->new("http://url/to/lemur.cgi");

# run some queries, and get back an array of results
# a query with a single term:
my @results1 = $lem->query("encryption");
# a query with two terms:
my @results2 = $lem->query("encryption MD5");

# get corpus term frequency of MD5:
my $md5ctf = $results2[1]->ctf();

This module will make it easy to interact with a Lemur Toolkit for Language Modeling and Information Retrieval server for information retreival exercises. For more information on Lemur, see http://www.lemurproject.org/.

This module takes care of all parsing of responses from the server. You can just pass a query as a space-separated list of terms, and the module will give you back an array of result objects.

Debug::Message is a Perl module that eases the use of debug print with level, indentation and color.

SYNOPSIS

use Debug::Message;
use Log::Dispatch;
use Log::Dispatch::Screen;

my $dispatcher = Log::Dispatch->new;
$dispatcher->add( Log::Dispatch::Screen->new( name => screen,
min_level => 0 ));

my $info = Debug::Message->new(1);
$info->add_dispatcher($dispatcher);
$info->print("print");
$info->yellow("warn");
$info->red("err");
$info->printcn("error message", bold red);

my $critical = Debug::Message->new(5);
$critical->add_dispatcher($dispatcher);
$critical->redn("err");
For disabling the debugging simply do not attach any dispatchers.
$critical->disable; # Will detach the attached backend

There was no module for simple debug messages supporting debug/verbosity levels and indentation. So this is the one, that is supposed to take this place.
This module is an art of frontend to Log::Dispatch as Log::Dispatch itself supports levels, but no colors and the functions calling is tedious.

There are some methods defined. Each outputs a different color, optionally it can add a newline after the messaage. They dispatch the messages to all added dispatchers, but generaly only one will be needed as the Log::Dispatch itself can have more backends.

Chess::FIDE is a Perl extension for FIDE Rating List.

SYNOPSIS

use Chess::FIDE;
my $fide = Chess::FIDE->new(-file=>filename);
$fide->fideSearch("surname eq Kasparov");

Chess::FIDE - Perl extension for FIDE Rating List. FIDE is the International Chess Federation that every quarter of the year releases a list of its rated members. The list contains about fifty thousand entries. This module is designed to parse its contents and to search across it using perl expressions. A sample list from April 2004 is provided under filename APR04FRL.TXT The following methods are available:

Constructor

$fide = new Chess::FIDE(-file=>localfile); $fide = new Chess::FIDE(-www=>1,[-proxy=>proxyaddress]);

There are two types of constructors - one takes a local file and another one retrieves the up-to-date zip file from the FIDE site, unzips it on the fly and parses the output immediately. In case of the second constructor no files are created. Also usage of an optional proxy is possible in the second case.

Each player entry in the file is scanned against a regexp and then there is a post-parsing as well which is implemented in function parseLine. The entry is then stored in an object defined by the module Chess::FIDE::Player (see its documentation). Every new object is inserted as a hash member where the FIDE ID of the player is the key. A sparse array could be used instead, though.

fideSearch

@result = $fide->fideSearch("perl conditional");
Example: @result = $fide->fideSearch("surname eq Kasparov");

Searches the fide object for entries satisfying the conditional specified as the argument. The conditional MUST be a PERL expression within double quotes. All constant strings should be expressed within single quotes because the conditional is evaled against each entry. Any conditional including a regexp match that may be eval-ed is valid. For the fields to use in conditionals see Chess::FIDE::Player documentation.

sipscreen project is a Linux iptables QUEUE target handler written in perl for screening incoming SIP phone calls.

If you have a network configuration similar to mine, with a Vonage or other Voice-over-IP adapter located behind a Linux gateway, you may find sipscreen useful for programmatically accepting or rejecting inbound calls, based on the caller ID information, the time of day, or any other clever algorithm you can think of.

Hex-a-hop is a puzzle game based on hexagonal tiles. There is no time limit and no real-time elements.

The objective is simply to destroy all the green hexagonal tiles on each of the 100 levels. As you progress through the game, more types of tiles are introduced which make things more difficult and interesting (hopefully).

The project is built on top of SDL, which is an open-source layer for direct media access.