Free interpolation software for linux

Interpolate/Extrapolate plug-in does a simple linear interpolation between two images. However, it does not constrain the blending factor to be in [0, 1]. By using values outside that range, you can perform more interesting extrapolations among images.

For examples on how to use this sort of plug-in, check the Grafica Obscura pages. As an interesting example, below is shown a color image and its grayscale version. Extrapolating `away from the grayscale image leads to an image with increased saturation.

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.

MapGeneration Project is a project featuring a server and helper programs to collect GPS information from various sources and to then automatically generate a continuously improved, time annotated road map.
Nowadays gps-receivers are quite cheap and many people use them for route planning in their cars. On the other hand updated maps for the route planing systems are relativly expansive, if available at all.
The idea is to collect the data that people have recorded with their gps-receivers and combine it into one freely available road map. Besides being cheap and always current this map would also contain actual driving time information: Route planning on such a map would not have to use road type based approximations to calculate the fasted route.
In the MapGeneration Project we implement such a program and the end user tools needed to access the data. At the moment we concentrate on two programs: The MapGenerator itself and the MapGeneratorGUI used to administer the generator.
The MapGenerator is a server that accepts incoming data via network and combines the received road information into one big map. As the map might become quite big a database is used as storage. The MapGeneratorGUI connects to this database and displays the map.
As the best way to understand a program is to use it we will now give a short introduction to using the program.
Enhancements:
New features
- (Server) New filter to detect gaps in the input traces.
- (Server) Calculates and outputs total length and time of processed traces.
- (Server) Added full support for more than one processing thread, 2 is default now.
Changes
- (Server) Rewrote TraceServer and TraceConnection to support commoncpp2 1.0.x.
- (Server) Server tries to bind to 127.0.0.1 if no interfaces are found.
- (Server) Added curvature as a criterion for merging -> much better merging!
- (Server) Improved avoidance of double processing of nodes.
- (Server) Moved parsing of traces into TraceFilter.
- (General) Added lots of new methods to handle distances, bearings and interpolation.
- (General) Configuration system supports boolean values.
- (Buildsys) Changed parameters to specify config files to --with-wx-config and --with-ccgnu2-config
Bugfixes
- (Server) Protected data handling between thread with mutexs.
- (GUI) Fixed some string literals for full unicode support.
- (General) Cache: Fixed all size calculations and the size handling system.
- (General) Raised requirements for wxWidgets to 2.6 (beta versions since 2.5.3 should work).
- (General) Some small fixes to build with commoncpp2 1.0.x.

PulseAudio is a networked sound server for Linux and other Unix like operating systems. PulseAudio is intended to be an improved drop-in replacement for the Enlightened Sound Daemon (ESOUND).
Main features:
- Extensible plugin architecture (by loading dynamic loadable modules with dlopen())
- Support for more than one sink/source
- Better low latency behaviour
- Embedabble into other software (the core is available as C library)
- Completely asynchronous C API
- Simple command line interface for reconfiguring the daemon while running
- Flexible, implicit sample type conversion and resampling
- "Zero-Copy" architecture
- Module autoloading
- Very accurate latency measurement for playback and recording.
- May be used to combine multiple sound cards to one (with sample rate adjustment)
- Client side latency interpolation
- Ability to fully synchronize multiple playback streams
Installation:
As this package is made with the GNU autotools you should run ./configure inside the distribution directory for configuring the source tree. After that you should run make for compilation and make install (as root) for installation of polypaudio.
Enhancements:
- padsp has support for SNDCTL_DSP_SETTRIGGER, SNDCTL_DSP_SETDUPLEX, and SNDCTL_DSP_GETOPTR.
- A new ".ifexists" directive has been added to the CLI language for conditional configuration based on file existence.
- FLOAT32RE sample type support has been added.
- There are other bugfixes, cleanups, and portability fixes.

XML::Literal is a Perl module with syntax support for XML literals.

SYNOPSIS

# This is not a source filter: it just augments glob().
use XML::Simple;
use XML::Literal &XMLin;

# Simple element
my $xml1 = < hr/ >;

# With variable interpolation
my $xml2 = < input value=$ARGV[0] / >;

# With an extra pair of angle brackets
my $xml3 = < < a href=/ > Some Text < /a > >;

# With escaped angle brackets
my $xml4 = < a href=/ > Some Text < /a >;

# Direct call to the xml-building glob constructor
my $xml5 = glob
< p >< em >
Some Text
< /em >< /p >
;

# This does not look like XML, so its still shell glob
my @files = < *.* >;

This module takes one function at its use line. Afterwards, all single-line < ... > calls that looks like a XML literal will be processed with that function, instead of the built-in shell glob.

Support for qx< ... > overriding for multiline XML literals is planned for Perl 5.10.

Template::Manual::Directives is a Perl module that contains template directives.

Accessing and Updating Template Variables

GET

The GET directive retrieves and outputs the value of the named variable.

[% GET foo %]

The GET keyword is optional. A variable can be specified in a directive tag by itself.

[% foo %]

The variable can have an unlimited number of elements, each separated by a dot .. Each element can have arguments specified within parentheses.

[% foo %]
[% bar.baz %]
[% biz.baz(10) %]
...etc...

See Template::Manual::Variables for a full discussion on template variables.
You can also specify expressions using the logical (and, or, not, ?:) and mathematic operators (+ - * / % mod div).

[% template.title or default.title %]

[% score * 100 %]

[% order.nitems ? checkout(order.total) : no items %]

The div operator returns the integer result of division. Both % and mod return the modulus (i.e. remainder) of division. mod is provided as an alias for % for backwards compatibility with version 1.

[% 15 / 6 %] # 2.5
[% 15 div 6 %] # 2
[% 15 mod 6 %] # 3

CALL

The CALL directive is similar to GET in evaluating the variable named, but doesnt print the result returned. This can be useful when a variable is bound to a sub-routine or object method which you want to call but arent interested in the value returned.

[% CALL dbi.disconnect %]

[% CALL inc_page_counter(page_count) %]

SET

The SET directive allows you to assign new values to existing variables or create new temporary variables.

[% SET title = Hello World %]

The SET keyword is also optional.

[% title = Hello World %]

Variables may be assigned the values of other variables, unquoted numbers (digits), literal text (single quotes) or quoted text ("double quotes"). In the latter case, any variable references within the text will be interpolated when the string is evaluated. Variables should be prefixed by $, using curly braces to explicitly scope the variable name where necessary.

[% foo = Foo %] # literal value Foo
[% bar = foo %] # value of variable foo
[% cost = $100 %] # literal value $100
[% item = "$bar: ${cost}.00" %] # value "Foo: $100.00"

Multiple variables may be assigned in the same directive and are evaluated in the order specified. Thus, the above could have been written:

[% foo = Foo
bar = foo
cost = $100
item = "$bar: ${cost}.00"
%]

Simple expressions can also be used, as per GET.

[% ten = 10
twenty = 20
thirty = twenty + ten
forty = 2 * twenty
fifty = 100 div 2
six = twenty mod 7
%]

You can concatenate strings together using the _ operator. In Perl 5, the . is used for string concatenation, but in Perl 6, as in the Template Toolkit, the . will be used as the method calling operator and _ will be used for string concatenation. Note that the operator must be specified with surrounding whitespace which, as Larry says, is construed as a feature:

[% copyright = (C) Copyright _ year _ _ author %]

You can, of course, achieve a similar effect with double quoted string interpolation.

[% copyright = "(C) Copyright $year $author" %]

DEFAULT

The DEFAULT directive is similar to SET but only updates variables that are currently undefined or have no "true" value (in the Perl sense).

[% DEFAULT
name = John Doe
id = jdoe
%]

This can be particularly useful in common template components to ensure that some sensible default are provided for otherwise undefined variables.

[% DEFAULT
title = Hello World
bgcol = #ffffff
%]
< html>
< head>
< title>[% title %]
< /head>

< body bgcolor="[% bgcol %]">

Text::MicroMason::Mason is a simple compiler for Mason-style Templating.
SYNOPSIS
Mason syntax provides several ways to mix Perl into a text template:
< %args >
$name
< /%args >
% if ( $name eq Dave ) {
Im sorry < % $name % >, Im afraid I cant do that right now.
% } else {
< %perl >
my $hour = (localtime)[2];
my $daypart = ( $hour > 11 ) ? afternoon : morning;
< /%perl >
Good < % $daypart % >, < % $name % >!
% }
< & "includes/standard_footer.msn" & >
< %doc >
Heres a private developr comment describing this template.
< /%doc >
Create a Mason object to interpret the templates:
use Text::MicroMason;
my $mason = Text::MicroMason->new();
You can compile and execute templates using the standard MicroMason methods:
$coderef = $mason->compile( file => simple.tmpl );
print $coderef->( %arguments );
print $mason->execute( file => simple.tmpl, %arguments );
Main features:
- Template interpolation with
- Literal Perl lines with leading %
- Named %args, %perl, %once, %init, %cleanup, and %doc blocks
- The $m mason object, although with many fewer methods
- Expression filtering with |h and |u (via -Filter mixin)

PDL::Slatec is a PDL interface to the slatec numerical programming library.

SYNOPSIS

use PDL::Slatec;

($ndeg, $r, $ierr, $a) = polyfit($x, $y, $w, $maxdeg, $eps);

This module serves the dual purpose of providing an interface to parts of the slatec library and showing how to interface PDL to an external library. Using this library requires a fortran compiler; the source for the routines is provided for convenience.

Currently available are routines to: manipulate matrices; calculate FFTs; fit data using polynomials; and interpolate/integrate data using piecewise cubic Hermite interpolation.

Piecewise cubic Hermite interpolation (PCHIP)

PCHIP is the slatec package of routines to perform piecewise cubic Hermite interpolation of data. It features software to produce a monotone and "visually pleasing" interpolant to monotone data. According to Fritsch & Carlson ("Monotone piecewise cubic interpolation", SIAM Journal on Numerical Analysis 17, 2 (April 1980), pp. 238-246), such an interpolant may be more reasonable than a cubic spline if the data contains both "steep" and "flat" sections. Interpolation of cumulative probability distribution functions is another application. These routines are cryptically named (blame FORTRAN), beginning with ch, and accept either float or double piddles.

Most of the routines require an integer parameter called check; if set to 0, then no checks on the validity of the input data are made, otherwise these checks are made. The value of check can be set to 0 if a routine such as chim has already been successfully called.

If not known, estimate derivative values for the points using the chim, chic, or chsp routines (the following routines require both the function (f) and derivative (d) values at a set of points (x)).

Evaluate, integrate, or differentiate the resulting PCH function using the routines: chfd; chfe; chia; chid.
If desired, you can check the monotonicity of your data using chcm.

EOD # un-confuse emacs

# if define chbs, then add something like the following to point 3: # # or use chbs to convert a PCH function into B-representation # for use with the B-spline routines of slatec # (although no interface to them currently exist). #
# add function definitions after finishing the first pp_addpm(), since this # adds a =head1 FUNCTIONS line at the end of the text

pp_addpm(<<less