Free plane software for linux

Infinite Planes of Reality project is a text-only D20 MMORPG engine.
Infinite Planes of Reality is a next-generation MMORPG engine that enables interaction with text-only, ANSI telnet, and XML clients.
It has online/in-game world creation capability. It is D20 (OGL) and Java-based, capable of scalable worlds across distributed servers.
Main features:
- Support for multiple outstream formats (XML, Ansi)
- You can kill something
- A nice world to walk in
- A fair start

PDL::Transform is a Perl module that coordinate transforms, image warping, and N-D functions.

SYNOPSIS

use PDL::Transform;
my $t = new PDL::Transform:: ( )

$out = $t->apply($in) # Apply transform to some N-vectors (Transform method)
$out = $in->apply($t) # Apply transform to some N-vectors (PDL method)

$im1 = $t->map($im); # Transform image coordinates (Transform method)
$im1 = $im->map($t); # Transform image coordinates (PDL method)

$t2 = $t->compose($t1); # compose two transforms
$t2 = $t x $t1; # compose two transforms (by analogy to matrix mult.)

$t3 = $t2->inverse(); # invert a transform
$t3 = !$t2; # invert a transform (by analogy to logical "not")

PDL::Transform is a convenient way to represent coordinate transformations and resample images. It embodies functions mapping R^N -> R^M, both with and without inverses. Provision exists for parametrizing functions, and for composing them. You can use this part of the Transform object to keep track of arbitrary functions mapping R^N -> R^M with or without inverses.

The simplest way to use a Transform object is to transform vector data between coordinate systems. The apply method accepts a PDL whose 0th dimension is coordinate index (all other dimensions are threaded over) and transforms the vectors into the new coordinate system.

Transform also includes image resampling, via the map method. You define a coordinate transform using a Transform object, then use it to remap an image PDL. The output is a remapped, resampled image.

You can define and compose several transformations, then apply them all at once to an image. The image is interpolated only once, when all the composed transformations are applied.

In keeping with standard practice, but somewhat counterintuitively, the map engine uses the inverse transform to map coordinates FROM the destination dataspace (or image plane) TO the source dataspace; hence PDL::Transform keeps track of both the forward and inverse transform.

For terseness and convenience, most of the constructors are exported into the current package with the name t_ , so the following (for example) are synonyms:

$t = new PDL::Transform::Radial(); # Long way

$t = t_radial(); # Short way

Several math operators are overloaded, so that you can compose and invert functions with expression syntax instead of method syntax (see below).

ParaView project is an application designed with the need to visualize large data sets in mind. The goals of the ParaView project include the following:
- Develop an open-source, multi-platform visualization application.
- Support distributed computation models to process large data sets.
- Create an open, flexible, and intuitive user interface.
- Develop an extensible architecture based on open standards.
ParaView runs on distributed and shared memory parallel as well as single processor systems and has been succesfully tested on Windows, Linux and various Unix workstations and clusters. Under the hood, ParaView uses the Visualization Toolkit as the data processing and rendering engine and has a user interface written using a unique blend of Tcl/Tk and C++. Please go here for a detailed list of features.
ParaView was created by Kitware in conjunction with Jim Ahrens of the Advanced Computing Laboratory at Los Alamos National Laboratory (LANL). Contributors and developers of ParaView currently include: Kitware, LANL, Sandia National Laboratories, and Army Research Laboratory. ParaView is funded by the US Department of Energy ASCI Views program as part of a three-year contract awarded to Kitware, Inc. by a consortium of three National Labs - Los Alamos, Sandia, and Livermore. The goal of the project is to develop scalable parallel processing tools with an emphasis on distributed memory implementations. The project includes parallel algorithms, infrastructure, I/O, support, and display devices. One significant feature of the contract is that all software developed is to be delivered open source. Hence ParaView is available as an open-source system.
Main features:
- Handles structured (uniform rectilinear, non-uniform rectilinear, and curvilinear grids), unstructured, polygonal and image data.
- All processing operations (filters) produce datasets. This allows the user to either further process or save as a data file the result of every operation. For example, the user can extract a cut surface, reduce the number of points on this surface by masking, and apply glyphs (for example, vector arrows) to the result.
- Contours and isosurfaces can be extracted from all data types using scalars or vector components. The results can be colored by any other variable or processed further. When possible, structured data contours/isosurfaces are extracted with fast and efficient algorithms which make use of the special data layout.
- Vectors fields can be inspected by applying glyphs (arrows, cones, lines, spheres, and various 2D glyphs) to the points in a dataset. The glyphs can be scaled by scalars, vector component or vector magnitude and can be oriented using a vector field.
- A sub-region of a dataset can be extracted by cutting or clipping with an arbitrary plane (all data types), specifying a threshold criteria to exclude cells (all data types) and/or specifying a VOI (volume of interest - structured data types only)
- Streamlines can be generated using constant step or adaptive integrators. The results can be displayed as points, lines, tubes, ribbons, etc., and can be processed by a multitude of filters.
- The points in a dataset can be warped (displaced) with scalars (given a user defined displacement vector) or with vectors (unavailable for non-linear rectilinear grids).
- With the array calculator, new variables can be computed using existing point or cell field arrays. A multitude of scalar and vector operations are supported.
- Data can be probed at a point or along a line. The results are displayed either graphically or as text and can be exported for further analysis.
- ParaView provides many other data sources and filters by default (edge extraction, surface extraction, reflection, decimation, extrusion, smoothing...) and any VTK filter can be added by providing a simple XML description (VTK provides hundreds of sources and filters, see VTK documentation for a complete list).
Enhancements:
- This release adds parallel uniform rectilinear grid volume rendering (vtkImageData).
- It introduces new algorithms for parallel unstructured grid volume rendering.
- Support for hardware accelerated offscreen rendering using OpenGL framebuffers.
- Improved multi-block support.
- Improved AMR support.
- Animation saving with ffmpeg.
- Filters have been added for FLUENT, OpenFOAM, MFIX, LSDyna, and AcuSolve.
- A gradient filter for unstructured data.
- Many other enhancements and bugfixes.

SimpleLogBook is a simple (obviously) pilots logbook. SimpleLogBook is at a very early stage at the moment and can only record basic flight information (take a look at the screen shots below). The flight information is stored as an XML file and can currently be used to calculate total flight time across one or more flights.

Immediate plans for development include a greatly increased time calculating facility; allowing the calculation of total time spent flying each plane type, in each operating capability and under which conditions.

Longer term plans include the addition of filters, to limit the flights displayed, the ability to attach more complex data (e.g. photos) to each flight and a print function.

Usage:

To run the application either double click on its icon or run it from the command-line; the main flight window will be displayed upon startup. Logbooks can be created, loaded and saved via the File menu. The Flights menu contains the functionality for adding, deleting and editing flights. This menu also contains the total flying time calculation function.

Right-clicking on the flights table will duplicate the Flights menu.

The new/edit flight dialog contains all the fields found in a standard paper log book. Hitting OK will save any changes you have made, Cancel will abandon them.

SLFFEA stands for San Les Free Finite Element Analysis. SLFFEA is a package of scientific software and graphical user interfaces for use in finite element analysis. It is written in ANSI C by San Le and distributed under the terms of the GNU license.
SLFFEA includes:
9 of the basic finite element types:
- 3-D 2 node beam
- 3-D 8 node brick
- 2-D 4 node plate
- 2-D 4 node quad (plane stress and plane strain)
- 3-D 4 node doubly curved shell (individual element defined by 4 or 8 nodes)
- 3-D 4 node tetrahedron
- 2-D 3 node triangle
- 3-D 2 node truss
- 3-D 6 node wedge
non-linear large deformation element:
- 3-D 8 node brick - Updated Lagrange formulation with Jaumann Stress Rate
And 1 thermal element:
- 3-D 8 node brick - It can handle thermal loads as well as orthotropy.
9 Graphical User Interfaces for each element type.
- Example of brick GUI
- Example of beam GUI
SLFFEA is dedicated to Richard Stallman , Granddaddy of the Free Software Movement, Linus Torvalds, its prodigal son, and everyone on comp.os.linux.setup .

OPAL is a high-level interface for low-level physics engines used in games, robotics simulations, and other 3D applications.
Features a simple C++ API, intuitive objects (e.g. Solids, Joints, Motors, Sensors), and XML-based file storage for complex objects.
Main features:
- Open Source
- Cross-platform
- Tested on Linux, Irix, Windows, and Mac OS X
- XML file loading
- OPAL XML exporter for 3ds Max
- Breakable joints
- Linear and angular motion damping
- Per-shape material settings
- Contact groups (define which objects can interact physically)
- Collision detection primitive shapes
- Boxes
- Spheres
- Capsules (i.e. capped cylinders)
- Planes
- User-defined triangular mesh collision detection (best for terrains)
- Joints
- Hinge joints (one rotational degree of freedom)
- Universal joints (two rotational degrees of freedom)
- Ball joints (three rotational degrees of freedom)
- Wheel joints (two rotational degrees of freedom)
- Slider joints (i.e. prismatic joints; one translational degree of freedom)
- Fixed joints (zero degrees of freedom)
- Motors
- Attractor motors (provide gravitational attraction between two objects)
- Geared motors (simplified automobile engines)
- Servo motors (use limited torque to achieve a desired angle or velocity; similar to PD/PID controllers)
- Spring motors (simple damped springs; pull objects to a desired position and/or orientation)
- Thruster motors (provide a constant force on an object)
- Sensors
- Acceleration sensors
- Incline sensors
- Raycast sensors
- Volume sensors
- Event handlers
- Collision event handler (notified when objects collide)
- Joint break event handler (notified when a joint breaks)
- Post-step event handler (notified at the end of each time step)
Enhancements:
- Many bugfixes, unit tests, and enhancements.
- New features: handling a large number of object updates, a new motor, better joint damage monitoring, and enhanced event handling.
- The project has been migrated to Subversion.

The Persistence of Vision Ray-Tracer creates three-dimensional, photo-realistic images using a rendering technique called ray-tracing. It reads in a text file containing information describing the objects and lighting in a scene and generates an image of that scene from the view point of a camera also described in the text file.
The Persistence of Vision Ray-Tracer(tm) was developed from DKBTrace 2.12 (written by David K. Buck and Aaron A. Collins) by a bunch of people (called the POV-Team?) in their spare time. The headquarters of the POV-Team is on the internet (see "Where to Find POV-Ray Files" for more details).
The POV-Ray package includes detailed instructions on using the ray-tracer and creating scenes. Many stunning scenes are included with POV-Ray so you can start creating images immediately when you get the package. These scenes can be modified so you do not have to start from scratch.
In addition to the pre-defined scenes, a large library of pre-defined shapes and materials is provided. You can include these shapes and materials in your own scenes by just including the library file name at the top of your scene file, and by using the shape or material name in your scene.
Ray-tracing is not a fast process by any means, but it produces very high quality images with realistic reflections, shading, perspective and other effects.
Ray-tracing is a rendering technique that calculates an image of a scene by simulating the way rays of light travel in the real world. However it does its job backwards. In the real world, rays of light are emitted from a light source and illuminate objects. The light reflects off of the objects or passes through transparent objects. This reflected light hits our eyes or perhaps a camera lens. Because the vast majority of rays never hit an observer, it would take forever to trace a scene.
Ray-tracing programs like POV-Ray start with their simulated camera and trace rays backwards out into the scene. The user specifies the location of the camera, light sources, and objects as well as the surface texture properties of objects, their interiors (if transparent) and any atmospheric media such as fog, haze, or fire.
For every pixel in the final image one or more viewing rays are shot from the camera, into the scene to see if it intersects with any of the objects in the scene. These "viewing rays" originate from the viewer, represented by the camera, and pass through the viewing window (representing the final image).
Every time an object is hit, the color of the surface at that point is calculated. For this purpose rays are sent backwards to each light source to determine the amount of light coming from the source. These "shadow rays" are tested to tell whether the surface point lies in shadow or not. If the surface is reflective or transparent new rays are set up and traced in order to determine the contribution of the reflected and refracted light to the final surface color.
Special features like inter-diffuse reflection (radiosity), atmospheric effects and area lights make it necessary to shoot a lot of additional rays into the scene for every pixel.
Main features:
- Easy to use scene description language.
- Large library of stunning example scene files.
- Standard include files that pre-define many shapes, colors and textures.
- Very high quality output image files (up to 48-bit color).
- 16 and 24 bit color display on many computer platforms using appropriate hardware.
- Create landscapes using smoothed height fields.
- Many camera types, including perspective, orthographic, fisheye, etc.
- Spotlights, cylindrical lights and area lights for sophisticated lighting.
- Photons for realistic, reflected and refracted, caustics. Photons also interact with media.
- Phong and specular highlighting for more realistic-looking surfaces.
- Inter-diffuse reflection (radiosity) for more realistic lighting.
- Atmospheric effects like atmosphere, ground-fog and rainbow.
- Particle media to model effects like clouds, dust, fire and steam.
- Several image file output formats including Targa, BMP (Windows only), PNG and PPM.
- Basic shape primitives such as ... spheres, boxes, quadrics, cylinders, cones, triangle and planes.
- Advanced shape primitives such as ... Tori (donuts), bezier patches, height fields (mountains), blobs, quartics, smooth triangles, text, superquadrics, surfaces of revolution, prisms, polygons, lathes, fractals, isosurfaces and the parametric object.
- Shapes can easily be combined to create new complex shapes using Constructive Solid Geometry (CSG). POV-Ray supports unions, merges, intersections and differences.
- Objects are assigned materials called textures (a texture describes the coloring and surface properties of a shape) and interior properties such as index of refraction and particle media (formerly known as "halos").
- Built-in color and normal patterns: Agate, Bozo, Bumps, Checker, Crackle, Dents, Granite, Gradient, Hexagon, Leopard, Mandel, Marble, Onion, Quilted, Ripples, Spotted, Spiral, Radial, Waves, Wood, Wrinkles and image file mapping. Or build your own pattern using functions.
- Users can create their own textures or use pre-defined textures such as ... Brass, Chrome, Copper, Gold, Silver, Stone, Wood.
- Combine textures using layering of semi-transparent textures or tiles of textures or material map files.
- Display preview of image while rendering (not available on all platforms).
- Halt and save a render part way through, and continue rendering the halted partial render later.

Astro::Aladin::LowLevel is a Perl class designed to drive CDS Aladin Application.

SYNOPSIS

my $aladin = new Astro::Aladin::LowLevel( );

Drives the CDS Aladin Application through a anonymous pipe, expects the a copy of the standalone Aladin application to be installed locally and pointed to by the ALADIN_JAR environment variable.

REVISION

$Id: LowLevel.pm,v 1.2 2003/02/24 22:45:56 aa Exp $

METHODS

Constructor

new

Create a new instance from a hash of options

$aladin = new Astro::Aladin::LowLevel( );

returns a reference to an Aladin object.

Accessor Methods

close

Closes the anonymous pipe to the aladin application

$aladin->close();

it should be noted that if you DONT do this after finishing with the object youre going to have zombie Java VM hanging around eating up all your CPU. This is amougst the many reasons why you should use Astro::Aladin rather than Astro::Aladin::LowLevel to drive the Aladin Application.

reopen

Reopen the anonymous pipe to the aladin application

my $status = $aladin->reopen()

returns undef if the pipe if defined and (presumably) already active.

status

Prints out the status of the current stack.

$aladin->status()

sync

Waits until all planes are ready

$aladin->sync()

export

Export a plane to a file

$aladin->sync( $plane_number, $filename )

get

Gets images and catalogues from the server

$aladin->get( $server, @args, $object, $radius );
$aladin->get( $server, $object );

For example

$aladin->get( "aladin", ["DSS1"], $object_name, $radius );
$aladin->get( "aladin", ["DSS1", "LOW"], $object_name, $radius );
$aladin->get( "aladin", [""], $object_name, $radius );

the radius arguement can be omitted

$aladin->get( "aladin", ["DSS1"], $object_name );

or even more simply

$aladin->get( "simbad", $object_name );

always remember to sync after a series of request, or you might end up closing Aladin before its actually finished download the layers.