Free coordinates software for linux

libgnomeprint is a Gnome printing library.
This is an implementation of the Gnome Printing Architecture, as described in:
http://www.levien.com/gnome/print-arch.html
An updated description of gnome-print and future plans can be found in :
http://www.levien.com/gnome/print-summit-2000.htm
We have a mailing list setup:
gnome-print@gnome.org
Overview
1. Imaging
Gnome-print uses semi-standard PostScript imaging model. I.e. all
shapes are described as sequences of path commands (moveto, lineto
curveto, closepath) and images created through fill and stroke
operators.
2. Coordinates
The initial coordinate system is identical to the PostScript one,
i.e. unit is 1 typographic point and y grows upwards on the page.
Coordinate system can be modified, using concat operator.
3. Graphic state
Graphic state is manipulated through usual operators, like
setrgbcolor, setopacity, setlinewidth. There are gsave and grestore
operators that manipulate graphic state stack.
Currently the only supported colorspace is RGB, as we have yet to
figure out the patent issues involved in CMYK and other colorspaces.
4. Text
There are 2 primary text operators. The simpler one (show) accepts
UTF-8 encoded string, and outputs it as well as possible using
current font from graphic state.
The other one (glyphlist) accepts device idependently formatted
sequence of glyphs - i.e. user program should do exact layout and
languge analyzing itself. Glyphlist can include glyphs from different
fonts, use different colors and position glyphs either in
predetermined coordinates or use simple font-specific positioning
rules (glyph advances for latin-like fonts).
5. Fonts
Gnome-print uses type1 fonts for all rendering, so printed output
is always identical to onscreen preview.
Enhancements:
- Fix a crash in Gedit caused by a typo. (Jeremy Messenger, Joe Marcus Clarke)
- Fix compiler warnings (Damien Carberry, Michael Wolf)
Updated translations:
- fi (Ilkka Tuohela)
- ga (Ignacio Casal Quinteiro)
- si (Danishka Navin)
- ta (Tirumurthi Vasudevan)
- vi (Pham Thanh Long)

JGachine project is a Java game machine/engine/browser.
JGachine is a networked game engine for 2D multi-player (networked) games.
It is written in Java and C++.
The games themselves are written in pure Java and can be loaded via the network.
Main features:
- easy game programing for beginners
- a game machine/engine/browser
- one client for multiple games
- you only write the game server (though the server may send bytecode to the client)
- secure client (though executing bytecode from the server
- writing multiplayer networked games within 2 hours
- portable
- try to allow output device independent games
- device independent coordinates
- help with different/changing aspect ratios

Data::Region Perl module can define hierarchical areas with behaviors.

SYNOPSIS

use Data::Region;

$r = Data::Region->new( 8.5, 11, { data => PageObj->new() } );
$r->data( PageObj->new() );

foreach my $c ( $r->subdivide(2.5,3) ) {
$a = $c->area(0.25,0.25, 2.25,2.75);
$a2 = $c->area(0.25,0.25, -0.25,-0.25); # as offset from lower right

($t,$m,$b) = $a->split_vertical(2,5,1); # sequential heights
($t,$m,$b) = $a->split_vertical_abs(0,2,7); # absolute offsets
($l,$r) = $a->split_horizontal(2); # $l gets width of 2, $r gets the rest

my($x1,$y1,$x2,$y2) = $a->coords();
my $data = $a->data(); # data inherits from parent, if not set
$a->action( sub { $data->setfont("Times-Bold", 10);
$data->text($x1,$y1, "Some Text");
$data->line( $_[0]->coords() ); # the non-closure way
} );
}
$r->render(); # heirarchically perform all the actions

# Get some info about a region:
($w,$h) = ( $a->width(), $a->height() );
($x1,$y1, $x2,$y2) = $a->coords();
($x1,$y1) = $a->top_left();
($x2,$y1) = $a->top_right();
($x1,$y2) = $a->bottom_left();
($x2,$y2) = $a->bottom_right();

Data::Region allows you to easily define a set of nested (2-dimensional) areas, defined by related coordinates, and to associate actions with them. The actions can then be performed hierarchically from any root of the tree.

Data::Region was written to provide an easy way to do simple page layout, but has, perhaps, more general uses.

Conc is a console concentrator for Linux and Gnome. Conc project features remote maintenance of systems over IP, and concurrent connections to consoles.
Serial lines on multiple machines may be pooled into one system allowing a virtually unlimited number of consoles to be managed - ideal for large server farms, clusters or off-site server rooms.
Please feel free to try it out and send me any comments, feature requests, and bug reports.
The systems consists of three components. The first is concserv, the central daemon, that keeps logs from all the consoles and coordinates the rest of the system. When it starts, concserv spawns a number of termserv processes that control the serial lines to which the console lines are connected. The link between a termserv and concserv is encrypted and termservs may run on separate machines to concserv, communicated over TCP/IP.
The final component, conc, is the user interface. It connects to concserv over an encrypted TCP/IP link, and allows the system administrator to view the logs of a particular machine, connect to its console, add and remove consoles etc. There is also a small, text-based interface called console that allows connection to a single console.
Any number of user interface programs may run concurrently and multiple connections to the same are possible, allowing groups to work on one system. Having all the components communicate by TCP/IP allows administration of machines from off site or unifying management of co-located and local equipment.
Enhancements:
- This release improves the reliability of the connection between manager and servers, and removes the worst of the memory leaks from the client.

Approximator Line is an application which allows to synthesize approximation function of one argument. Both coordinates of known points or mathematical expression can be used as input data.
The application uses evolutionary algorithm which allows to find more optimal results. The enhanced evolutionary algorithm allows to avoid long-time hitting to local maximum.
In few hours the application can evaluate milliards of combinations with using of reasonable number of input data points and on contemporary computer. Approximator Line uses multithreading that can help to utilize maximum computation power.
Approximator Lines primary goal is to search of function, which value, most come nearer to the initial data. The preference is given the smallest functions. The weight of this preference is established in options of synthesis.
Search of function is made by the next way:
The random mathematical variant is under construction. Its fitness to the data is calculated. Further the variant is copied and changes. Fitness of the changed variant is calculated. If it is more, the new variant becomes base. It is simplified.
Key parameter of the found function is fitness of its set goal. Fitness is expressed in percentage. Its value depends on a way of the assignment of fitness of a point (it is established in parameters of synthesis). The program uses two basic such as fitness:
General fitness
Calculates on the general points.
Additional fitness
Calculates on general and additional points. It is used for more exact definition of fitness. It also is used for avoidance of a finding of such functions which correspond to the basic points, but in an interval between them strongly differ.
Additional fitness is used for a finding of the most corresponding functions at smaller amount of computing expenses as it calculates only if the basic fitness more than at the previous variant. Besides each of the mentioned above fitness can be normal or effective.
Normal fitness
Fitness in view of amount of elements of expression.
Effective fitness
Fitness without taking into account amount of elements of expression.
In the list of results normal additional conformity and effective additional conformity is accordingly displayed.
By search of the most suitable variant, or in other words synthesis cancelation constant subexprassions is made also.
Synthesis is based on use of random numbers. Functions making expression, operators variables and numbers get out randomly. The application is optimized on speed. So synthesized function in memory represents a tree of mathematical objects. Values of function are calculates by the most effective way. The mutation also is made above a tree of objects.
Usage:
- Determine the form of the input data (coordinates or expression).
- Choose points of your graph. Synthesis will be estimated on them.
- Enter coordinates of points (use autonumbering for simplification of input) or expression.
- Determine a range of value of function, amount of the basic points, amount of additional points.
- Open parameters of synthesis and adjust if it is necessary.
- Save the project.
- Press Start of synthesis.
- Pass to results and see on them.
- Leave the application working on long time.
- Periodically check results. When the application will find, in your opinion, suitable function, press Stop and save results.