Free figure fifteen 1.01 software for linux

When an image is taken from a video capture source (f.i. a freeze-frame), sometimes only either the odd or the even fields in the frame get captured, resulting in an image which, line by line, is data-black-data-black-etc.

De-interlace plug-in does a simple interpolation between the odd or even fields in an image to correct this.

Sealing Wafter is an OpenBSD kernel module that detects nmap scans and prevents proper identification of open TCP ports.
Sealing Wafter module also gives protection against dsniff tcpkill RST packets by dropping them. More testing is needed to prevent breakage of network applications.
Enhancements:
- Wafter has been ported to NetBSD as a kernel patch.
- It now supports identification of most operating systems.

Memoize - Make functions faster by trading space for time.

SYNOPSIS

# This is the documentation for Memoize 1.01
use Memoize;
memoize(slow_function);
slow_function(arguments); # Is faster than it was before

This is normally all you need to know. However, many options are available:

memoize(function, options...);

Options include:

NORMALIZER => function
INSTALL => new_name

SCALAR_CACHE => MEMORY
SCALAR_CACHE => [HASH, %cache_hash ]
SCALAR_CACHE => FAULT
SCALAR_CACHE => MERGE

LIST_CACHE => MEMORY
LIST_CACHE => [HASH, %cache_hash ]
LIST_CACHE => FAULT
LIST_CACHE => MERGE

`Memoizing a function makes it faster by trading space for time. It does this by caching the return values of the function in a table. If you call the function again with the same arguments, memoize jumps in and gives you the value out of the table, instead of letting the function compute the value all over again.

Here is an extreme example. Consider the Fibonacci sequence, defined by the following function:

# Compute Fibonacci numbers
sub fib {
my $n = shift;
return $n if $n < 2;
fib($n-1) + fib($n-2);
}

This function is very slow. Why? To compute fib(14), it first wants to compute fib(13) and fib(12), and add the results. But to compute fib(13), it first has to compute fib(12) and fib(11), and then it comes back and computes fib(12) all over again even though the answer is the same. And both of the times that it wants to compute fib(12), it has to compute fib(11) from scratch, and then it has to do it again each time it wants to compute fib(13). This function does so much recomputing of old results that it takes a really long time to run---fib(14) makes 1,200 extra recursive calls to itself, to compute and recompute things that it already computed.

This function is a good candidate for memoization. If you memoize the `fib function above, it will compute fib(14) exactly once, the first time it needs to, and then save the result in a table. Then if you ask for fib(14) again, it gives you the result out of the table. While computing fib(14), instead of computing fib(12) twice, it does it once; the second time it needs the value it gets it from the table. It doesnt compute fib(11) four times; it computes it once, getting it from the table the next three times. Instead of making 1,200 recursive calls to `fib, it makes 15. This makes the function about 150 times faster.

You could do the memoization yourself, by rewriting the function, like this:

# Compute Fibonacci numbers, memoized version
{ my @fib;
sub fib {
my $n = shift;
return $fib[$n] if defined $fib[$n];
return $fib[$n] = $n if $n < 2;
$fib[$n] = fib($n-1) + fib($n-2);
}
}

Or you could use this module, like this:

use Memoize;
memoize(fib);

# Rest of the fib function just like the original version.

This makes it easy to turn memoizing on and off.

Heres an even simpler example: I wrote a simple ray tracer; the program would look in a certain direction, figure out what it was looking at, and then convert the `color value (typically a string like `red) of that object to a red, green, and blue pixel value, like this:

for ($direction = 0; $direction < 300; $direction++) {
# Figure out which object is in direction $direction
$color = $object->{color};
($r, $g, $b) = @{&ColorToRGB($color)};
...
}

Since there are relatively few objects in a picture, there are only a few colors, which get looked up over and over again. Memoizing ColorToRGB sped up the program by several percent.

Doxygen Filter project is an input filter for Doxygen enabling support for Perl code documentation.
Of course, Perl developers are used to use POD rather than some other code documentation tools.
However, most developers actually are not restricted to using one single language. Instead of using multiple code documentation systems one tends to use one tool for all - Doxygen is quite a powerful code documentation system that already has built-in support for multiple programming languages.
Unfortunately, Doxygen does not directly support Perl. Thus, Doxygen Filter has been written in order to be able to use Doxygen for generating code documentation for Perl projects, too.
Enhancements:
- This release makes huge efforts for automatically extracting namespace/class/method/function information and function argument lists of not explicitly documented entities.
- Non-Perl files are now passed as is to doxygen, or are run through appropriate filters like js2doxy or pas2dox.
- The release includes a Windows executable.

IP accounter application measures and graphs traffic for IPv4 and IPv6 netfilter-based routers. Input data is accounted using several abstraction layers (routers, hosts, flows), and IPv6 traffic accounting may be mixed with IPv4.
Enhancements:
- The WEB frontend is still unavailable. There were some minor dificulties running ipaccounter. Still the main issue is when mysql server crashes. The traffic info is then lost until someone fixes it. Therefore it is advised to use some net watching software like Nagios. For further feature enchancements see the ChangeLog. 2006-09-02 by Ondra Ipaccounter-1.0 was released. Only WEB frontend is unavailable at the moment. The accounter is run on one machine. Namely maximus.spi-net.org. There were no fault ancountered so far, but its running only for one week.

eArea is a simple cross-browser WYSIWYG text editor. It works on Explorer, Firefox/Mozila and Safari/Konqueror.

eArea project even with OS X Dashboard widgets! If eArea comes across a browser it doesnt support (like Opera), it will display an ordinary < textarea > instead.

How does it work?

Putting eArea onto a webpage is really simple. All you need to do is upload the eArea folder to your website and paste a snippet of code into your HTML.

Everything about eArea is customisable: from what buttons are shown to the size of the text area and the style of the text in it. All from within the snippet of code in your HTML! You can even have as many eAreas on you pages as you like!

Sub::Timebound is a Perl extension for timebound computations.

SYNOPSIS

use Sub::Timebound;

sub fun
{
my $i = shift;
if ($i =~ /7$/) {
die "Simulated internal errorn";
}
while ($i) {
$i--;
}
return "All is well";
}

my $x = timeboundretry(10, 3, 5, &fun, 10);
### Returns { value => ..., status => 0(FAILURE)/1(SUCCESS) }
### value is the return value of fun()

if ($x->{status}) {
# SUCCESS
$x->{value}
} else {
# FAILURE
}

Module exports "timeboundretry" - this is a wrapper that watches a function call.

my $x = timeboundretry([TimeAllocated], [NumberOfAttempts],
[PauseBetweenAttempts],[CodeRef],[Param1], [Param2], ...);


[TimeAllocated] - Seconds allocated to [CodeRef] to complete
[NumberOfAttempts] - Number of attempts made to [CodeRef]
[PauseBetweenAttempts] - Seconds to wait before making subsequent attempts
[CodeRef] - Reference to subroutine
[Param1]... - Parameters to subroutine