Free modelling software for linux

openModeller library is a spatial distribution modelling library, providing a uniform method for modelling distribution patterns using a variety of modelling algorithms.
openModeller can be used via programatic interfaces, including SOAP and SWIG-python, as well as via a user friendly desktop grapical user interface and a GIS plugin.
Installation:
1. Install proj4 library, (known to work with version 4.4.7)
2. Install the GDAL library, (known to work with version 1.2.5)
3. Install GSL - GNU Scientific Library, (known to work with version 1.4)
4. Download the latest openModeller package from the sourceforge site, uncompress it, get into the "modeller" directory and then:
$ ./configure (see more options in the section "Compile options")
$ make
$ make install
Alternatively, you can try the latest version from CVS:
$ cvs -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/openmodeller login
$ cvs -z3 -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/openmodeller co modeller
$ cd modeller
$ ./autogen.sh
$ make
$ make install
Enhancements:
- Included ROC curve as part of model statistics, added metric Chebyshev in the Environmental Distance algorithm, changed Log object to a singleton, other minor bugfixes.

QML (Quantity Modeling Language) is a "thing"-based language for scientific and mathematical data modeling.
Each "thing" is a quantity which may be associated with either a structure or physical phenomena.
Quantities, in turn, may hold other Quantities or values (numbers or strings). Higher-level data models, which associate or define meanings to various quantities (such as velocity or position), can be built from QML quantities.
The higher-level data model (XML) schema that inherits from QML may be understood, and its instance documents may be parsed into QML documents and objects by the QMLReader.
Enhancements:
- This release adds partial Xerces2 DOM support, and works with Java 1.4 and Java 1.5 (no JAXP DocumentBuilder/Factory support currently).
- The test procedure is a little less chatty.
- Support has been added for testing either/both Crimson/Xerces DOM support.
- (Note: Crimson support only works with Java 1.4, as Java 1.5 interfaces have DOM lvl 2 and 3, which crimson doesnt support).
- This release adds compilerargs, and better build support for different configurations to build.xml.

Config::Model provides a framework to help in validating the semantic content of configuration data. The project can also be used to provide a semantic check of options of a complex program like mplayer or transcode.
For most complex software, configuration upgrade is a difficult task for most people. By using Config::Model, a software can provide a smooth upgrade path for their users.
How does this work ?
Using this project, a typical configuration validation tool will be made of 3 parts :
The user interface
The validation engine which is in charge of validating all the configuration information provided by the user.
The storage facility that store the configuration information
Dont we already have some configuration validation tools ?
Youre probably thinking of tools like webmin. Yes, these tools exist and work fine, but they have their set of drawbacks.
Usually, the validation of configuration data is done with a script which performs semantic validation and often ends up being quite complex (e.g. 2500 lines for Debians xserver-xorg.config script which handles xorg.conf file).
In most cases, the configuration model is expressed in instructions (whatever programming language is used) and interspersed with a lot of processing to handle the actual configuration data.
Whats the advantage of this project ?
The Config::Model projects provide a way to get a validation engine where the configuration model is completely separated from the actual processing instruction.
The configuration model is expressed in a declarative form (i.e. a Perl data structure) which is always easier to maintain than a lot of code.
The declaration specifies:
the structure of the configuration data (which can be queried by generic user interfaces)
the properties of each element (boundaries, check, integer or string, enum like type ...)
the default values of parameters (if any)
mandatory parameters
the targeted audience (intermediate, advance, master)
on-line help (for ach parameter or value of parameter)
the level of expertise of each parameter (to hide expert parameters from newbie eyes)
So, in the end:
maintenance and evolution of the configuration content is easier
user will see a *common* interface for *all* programs using this project.
user will not see advanced parameters
upgrade of configuration data is easier and sanity check is performed
audit of configuration is possible to check what was modified by the user compated to default values
What about the user interface ?
Config::Model will also come with a Curses::UI interface that queries the users model and generate the relevant user screens.
What about data storage ?
Since the syntax of configuration files vary wildly form one program to another, most people who want to use this framework will have to provide a dedicated parser/writer.
Nevertheless, this project can also provide a writer/parser for most common format: like ini style file, or provide an interface to the Elektra or debconf projects. This point is open for discussion.
It is entirely possible for a single configuration model to use several parsers and writers so one model will ensure the consistency of several configuration files together.
Enhancements:
- The Xorg model was updated to Config::model version 0.609.
- Some bugs were fixed.

Games::Othello is a Perl extension for modelling a game of Othello.

SYNOPSIS

use Games::Othello;

my $game = Games::Othello->new();

while( !game->over ) {
printf "It is presently %ss move",
($game->whos_move eq b) ? black, white;
my @possible_moves = values $game->possible_moves();

if ( ! @possible_moves ) {
print "You have no moves available, you must pass.
$game->pass_to_opponent;
} else {
foreach ( my $move ) @possible_moves ) {
printf
"You will take %d of your opponents chips if you place your chip on %d,%d",
scalar @{ $move->{chips} }, $move->{x}, $move->{y};
}
my ($locx, $locy) = get_move();
my $flipped = $game->place_chip( $locx, $locy );
}

my $layout = $game->chip_layout();
foreach my $row ( @$layout ) {
foreach my $pos ( @$row ) {
printf %3s,
($pos eq b) ? B # Black occupied square.
: ($pos eq w) ? W # White occupied square.
: # Un-occupied square.
}
print "nn";
}
}
my ($black_score, $white_score) = $game->score;

powerPlant is a geometry generator and editor. powerPlant is specially suitable to generate terrain and plant models. The geometry generation is based on custom implementations of L-Systems, Turtle-Interpretation and the Diamond-and-Square algorithm.

powerPlant is composed of a Java application supplying the application logic and external Haskell programs for geometry generation.

The application is intended to create complex, realistic models by supplying a minimum ammount of parameters instead of explicit modelling. Created models can be combined recursively to make up complete scenes. This scene creation is presented in a WYSIWYG tree view. The integrated terrain tool can also be used to generate various coloured, tileable textures.

Every work result (models, scenes) can be loaded and saved in a xml file. User interaction takes place in a convenient Java Swing GUI that brings together all the aspects of the application.

The chosen approach should significantly shorten the process of creating adequate 3D-models and entire virtual landscapes with realtime visualization. Visualization is based on OpenGL/GLU API and includes adjustable speed optimizations.

openModeller project is a generic framework for carrying out fundamental niche modelling experiments - typically used to predict species distribution given a set of environmental raster layers.
The openModeller Desktop application builds on the openModeller library by providing a user friendly graphical user interface for carrying out niche modelling experiments.
Enhancements:
- Added experiment level summary report
- Fixed issues with text file splitter and show status when done
- Updated about window to show plugins and changelog
- Installer supports unattended install on windows (install using openModeller1.0.5.exe /S from the command prompt)
- Fixed issues with raster data format convertor
- Enabled locality fetching using scraper plugins and added GBIF Web, GBIF Rest, and speciesLink scrapers
- Fixed issue with splash screen hovering modally over firstrun wizard on mac
- You can now export samples as TAB delimited or CSV delimited text
- Dont smooth images when resampling
- Added support for new (mandatory) locality ids in openModeller library
- Fixed issues with window modality (various dialogs)
- Fix for [ 1636820 ] oM Desktop: Interface unresponsvive during experiment run.
- Fixed bug where ascii export was getting rounded to integers
- Handle missing qgis vector data providers more gracefully
- Double clicking on an item int eh experemient selector will cause it to be loaded
- By Popular request, store the experiment outputs in a folder with a human readable name.
- Fix for [ 1636715 ] oM Desktop: Display output format details in options dialog
- Fix for [ 1636825 ] oM Desktop: Select a mask for layers its not default
- Fixed bug [ 1636706 ] openModeller Desktop: generated ascii raster files headers incorrect
- Add new localities options gui - to support modelling with multiple locality files in one directory
- Fixed bug [ 1642350 ] File format filter missing in export image
- Fix for bug [ 1639715 ] Splash windows go to the limbo
- Show alg name after species name in progress dialog (fixes [ 1682407 ] om Desktop: Progress windows should show alg next to sp name)
- Added some better error handling for aborted models. openModeller Desktop is now much less prone to crashing when a problem occurs in the library.
- Fixed support for building on Mac OSX
- Implemented new build system using CMake
- Cleanups and improvments to windows installer to support on demand downloading of sample data and various other improvements.

Art of Illusion is a free, open source 3D graphics studio.

Art of Illusion combines modelling, animation, texturing and rendering in one application, with advanced features which compare favorably to those found in many commercial programs.

Art of Illusion is written entirely in Java. It should (in theory) work under any Java Virtual Machine (JVM) which is compatible with Suns Java Development Kit (JDK) 1.4 or later.