Free geometrical software for linux

Geomview is an interactive 3D viewing program for Unix. Geomview lets you view and manipulate three-dimensional objects: you use the mouse to rotate, translate, zoom in and out, and so on.

Geomview can be used as a standalone viewer for static objects or as a display engine for other programs which produce dynamically changing geometry. Geomview can display objects described in a variety of file formats. Geomview comes with a wide selection of example objects, and you can create your own objects too.

Geomview runs on most Unix platforms, including GNU/Linux. Geomview can run under Microsoft Windows using Cygwin. Geomview is free software available under the terms of the GNU Lesser General Public License (GPL).

You can also use Geomview to handle the display of data coming from another program that is running simultaneously. As the other program changes the data, the Geomview image reflects the changes. Programs that generate objects and use Geomview to display them are called external modules. External modules can control almost all aspects of Geomview. The idea here is that many aspects of the display and interaction parts of geometry software are independent of the geometric content and can be collected together in a single piece of software that can be used in a wide variety of situations. The author of the external module can then concentrate on implementing the desired algorithm and leave the display aspects to Geomview. Geomview comes with a collection of sample external modules, and the manual describes how to write your own.

Geomview allows multiple independently controllable objects and cameras. It provides interactive control for motion, appearances (including lighting, shading, and materials), picking on an object, edge or vertex level, snapshots in many image file, PostScript, or Renderman RIB format, and adding or deleting objects is provided through direct mouse manipulation, control panels, and keyboard shortcuts.

Geomview supports the following simple data types: polyhedra with shared vertices (.off), quadrilaterals, rectangular meshes, vectors, and Bezier surface patches of arbitrary degree including rational patches. Object hierarchies can be constructed with lists of objects and instances of object(s) transformed by one or many 4x4 matrices. Arbitrary portions of changing hierarchies may be transmitted by creating named references.

The full specification for object file formats is in the OOGL (Object Oriented Graphics Language) Reference section of the Geomview manual. If you already have Geomview you might want to try out the OOGL tutorial.

Geomview can be used as a Mathematica graphics output device; this makes viewing Mathematica graphics much more interactive. The same is true for Maple. Geomview began as an effort at the Geometry Center at the University of Minnesota to provide interactive geometry software which is particularly appropriate for mathematics research and education. In particular, Geomview can display objects in hyperbolic and spherical space as well as Euclidean space.

Derbrill Tutorials are Free Tutorials For Writing Games and Multimedia Applications in Runtime Revolution with ArcadeEngine.

The tutorials come in a visually appealing e-book format which is both easy to read and use, the range of topics covered includes:

* The basics of Revolution such as: stacks, cards, scripts, messages and timers
* How to use geometric properties such as distances, angles and intersection rectangles
* Understanding and using different movements including linear, polygonal, circular and elliptic
* Advanced use of images
* Using the built-in collision detection

GEO project is a C++ geometric template class library.

Use this library for your graphical, image processing, or scientific applications.

GEO has rich set of operations with vectors and matrices, 2D and 3D objects (such as finding convex hull, bounding box), triangulation, tesselation, etc.

TinyGL is a small, free and fast Subset of OpenGL for embedded systems or games.
It is a software only implementation. Only the main OpenGL calls are implemented. All the calls I considered not important are simply *not implemented.
The main strength of TinyGL is that it is fast and simple because it has not to be exactly compatible with OpenGL. In particular, the texture mapping and the geometrical transformations are very fast.
Main features:
- Header compatible with OpenGL (the headers are adapted from the very good Mesa by Brian Paul et al.)
- Zlib-like licence for easy integration in commercial designs (read the LICENCE file).
- Subset of GLX for easy testing with X Window.
- GLX like API (NGLX) to use it with NanoX in MicroWindows/NanoX.
- Subset of BGLView under BeOS.
- OpenGL like lightening.
- Complete OpenGL selection mode handling for object picking.
- 16 bit Z buffer. 16/24/32 bit RGB rendering. High speed dithering to paletted 8 bits if needed. High speed conversion to 24 bit packed pixel or 32 bit RGBA if needed.
- Fast Gouraud shadding optimized for 16 bit RGB.
- Fast texture mapping capabilities, with perspective correction and texture objects.
- 32 bit float only arithmetic.
- Very small: compiled code size of about 40 kB on x86. The file src/zfeatures.h can be used to remove some unused features from TinyGL.
- C sources for GCC on 32/64 bit architectures. It has been tested succesfully on x86-Linux and sparc-Solaris.
TinyGL is made up four main modules:
- Mathematical routines (zmath).
- OpenGL-like emulation (zgl).
- Z buffer and rasterisation (zbuffer).
- GLX interface (zglx).
To use TinyGL in an embedded system, you should look at the GLX layer and modify it to suit your need. Adding a more user friendly developper layer (as in Mesa) may be useful.

VCG TriMeshInfo is a tool designed to inspect 3D models and retrieve many types of topological and geometrical information from them.
It can be used to automate the process of decoding 3D mesh inherent properties and ease data classification and retrieval.
For each analyzed dataset, the following data are extracted:
- Number of Vertices (Unreferenced vertices are listed separately)
- Number of Faces
- Number of Edges
- Number of Connected Components
- Number of Boundaries
- Number of Isolated Vertices (i.e. Unreferenced)
- Manifold
- Genus (Computed only for Manifold Datasets)
- Orientability
- Orientation
- Regularity (We consider as regular those meshes generated through regular subdivision. Each non boundary vertex of a regular mesh has 6 incident edges, if there are only 5 incident edges the mesh is said to be semi-regular, irregular in all other cases)
- Number of Duplicated Vertices
- Self-Intersection (Currently computed only for Datasets with less than 3M faces)
Enhancements:
- This release included a major rewrite of the core component for computing geometrical and topological features of the analyzed mesh.
- Important changes included speeded up self-intersection tests, more robust (and correct) computation of topological genus and volume, and more flexible output with an HTML output option.

Gerris project is an Open Source Free Software library for the solution of the partial differential equations describing fluid flow.
Gerris is supported by NIWA (National Institute of Water and Atmospheric research) and by the Marsden Fund of the Royal Society of New Zealand.
The code is written entirely in C and uses both the GLib Library and the GTS Library for geometrical functions and object-oriented programming.
Main features:
- The same code base is compiled with 2D and 3D support.
- Quadtree-based (Octree in 3D) spatial discretisation with automatic and dynamic local refinement.
- Multigrid Poisson solver.
- Second-order Godunov type advection scheme.
- Solves the time-dependent incompressible variable-density Euler, Stokes or Navier-Stokes equations or the 2D shallow-water and 3D hydrostatic oceanic equations.
- Support for complex solid boundaries (automatic locally-refined mesh generation).
- Semi-implicit multigrid diffusion solver with support for complex boundaries and associated boundary conditions in 2D and 3D.
- Semi-implicit multigrid barotropic solver for the oceanic equations.
- Adaptive mesh refinement: the resolution is adapted dynamically to the features of the flow.
- Flexible and powerful specifications of parameters.
- Flexible object-oriented custom specification of initial and boundary conditions, source terms, outputs etc...
- Portable parallel support using the MPI library.
- Volume of Fluid advection scheme for interfacial flows.
Enhancements:
- Bugfixes and significant speedups in the multilevel Poisson solver.
- Support for variable mesh resolution along solid boundaries.
- Improvements have been made to the robustness of very complex solid boundaries.
- Adaptive refinement of VOF-advected tracers has been added, as well as a preliminary implementation of CSF surface tension using Renardy El Ab.
- "proper discretisation".
- Solid boundaries can be refined according to the local curvature.
- Implicit Coriolis terms work with the Navier-Stokes solver.
- There is support for "thin" 3D domains.

Dr. Geo is a GTK interactive geometry software. It allows one to create geometric figure plus the interactive manipulation of such figure in respect with their geometric constraints. It is useable in teaching situation with students from primary or secondary level.

Dr. Geo integrates advanced features as an integrated Scheme programming language to define scripts within a figure. The language is also used to define functionnaly interactive figure.

Dr. Geo is a software part of the GNU project. This means it is a free software (as free speech) and you have access to the source code under the GPL license. You can modify and distribute it as long as the same distribution license (GPL) is used.

mezoGIS project is a GIS application, a graphical interface to query and analyse spatial data. mezoGIS does not store or compute data directly, but operates external PostGIS databases. The goal of mezoGIS is to provide a tool for geo-spatial analysis with PostGIS, through on-the-fly SQL queries as well as through larger, external plugin scripts.
There are other, excellent open source applications that can display PostGIS data sets (like QGis or GRASS). Those projects, however, expect properly indexed tables as an input, and dont provide a built in functionality to launch SQL queries. The focus of mezoGIS is to stay close to the SQL workflow: Spatial queries are launched through manually entered SQL commands, and result sets containing geometry are displayed as map layers.
The first public release of mezoGIS was in march 2006. mezoGIS is entirely written in the python programming language, for gtk+. It works fine on the GNOME Desktop on linux, and has not yet been tested on other desktops or platforms.
Main features:
- Fast SQL queries: SQL commands and queries can be entered and sent to PostGIS within mezoGIS. Common SQL tasks and commands can also be accessed though context menues.
- View any kind of result: SQL queries yield result tables. If such a table contains geometric data, mezoGIS will display it in a map. There is no need to copy the data into a table or to create spatial indices. This is very useful for on-the-fly geoanalysis.
- Map creation: Result sets can be overlayed and layouted to create elaborate maps, the display engine currently has rough support for transparent colours, line styles, and symbols.
- Plugin engine: Plugin scripts written in python can be loaded and executed. The API is only a very rudimentary implementation, and will be subject to substantial change.
- XML file format: Projects are saved into an XML file format. The data itself is not stored, and must be reloaded from the database after loading.