Free 3d model software for linux

Vertex 3D Model Assembler project is a polygon-based live-end modeller.

The Vertex 3D Model Assembler is a 3D modeller geared towards making high performance models for games and other live-end requirements.

It uses the V3D format to maximize efficiency with OpenGL rendering, and can view/edit any V3D hybrid data.

Misfit Model 3D is an OpenGL-based 3D model editor that works with triangle-based models. Misfit Model 3D supports multi-level undo, skeletal animations, simple texturing, scripting, command-line batch processing, and a plugin system for adding new model and image filters.
Complete online help is included. It is designed to be easy to use and easy to extend with plugins and scripts.
Misfit Model 3D was written and tested on Linux (2.4 and 2.6 kernels) and has been compiled and tested on most major Linux distributions.
It is not endian-safe so it is unlikely to run on non-x86 hardware platforms--this will probably not change soon unless I get requests for a version thats usable on big-endian archs.
Enhancements:
- The menus have been re-organized. There is a new command to make normals face outward. The texture coordinate window now has a rotate tool. Material support for COB has been improved. Many animation bugs have been fixed. A "File | Export" command has been added to indicate which formats have less reliable write support.

Model Builder is a graphical tool for designing, simulating, and analyzing mathematical models consisting of a system of ordinary differential equations (ODEs).
Main features:
- Equation-based model definition. No need to learn to program to define and run your models. Just type-in you differential equations
- Graphic output of simulation. You can save the graphics in the most common formats: png, svg, pdf, etc.
- Spreadsheet view of the results. From the spreadsheet you can make customized plots from your variables. You can also export your data to a .csv text file
- Latex rendering of your system of equations.
- Intuitive graphical interface.
- Uncertainty analysis module (coming soon!)

GO::Model::Term is a term or concept in an ontology.

SYNOPSIS

# From a file
use GO::Parser;
my $parser = new GO::Parser({handler=>obj}); # create parser object
$parser->parse("gene_ontology.obo"); # parse file -> objects
my $graph = $parser->handler->graph; # get L object
my $term = $graph->get_term("GO:0001303"); # fetch a term by ID
printf "Term %s %sn", $term->name, $term->acc;

# From a GO Database (requires go-db-perl)
my apph = GO::AppHandle->connect(-dbname=>$dbname);
my $term = $apph->get_term({acc=>00003677});
printf "Term:%s (%s)nDefinition:%snSynonyms:%sn",
$term->name,
$term->public_acc,
$term->definition,
join(", ", @{$term->synonym_list});

Represents an Ontology term; the same class is used for process, compartment and function
currently, a Term is not aware of its Relationships; to find out how a term is related to other terms, use the a GO::Model::Graph object, which will give you the GO::Model::Relationship objects; for example

$rels = $graph->get_parent_relationships($term->acc);

Dice3DS project is a set of Python modules for dealing with 3D Studio format files. I have released it under the terms of a BSD-style license.
3D Studio is a 3D graphics modeling and rendering program that saved it images in a rather simple binary file format known as 3DS format. Although 3D Studio has not released the details of the 3DS format, it has been reverse engineered by some ambitious people, and I used the information to write Dice3DS, a Python package that slices and dices 3DS files.
Dice3DS requires Python 2.2 or higher, as it uses metaclass programming, and Python Numeric. Note that it is not a wrapper for lib3ds; its a Pure Python module.
There are two packages in Dice3DS: Dice3DS, and Dice3DS.example. The latter includes some modules that exemplify the use of Dice3DS, although they are not very versatile.
Heres a brief description of each module:
Dice3DS.dom3ds
Slice and dice 3DS files.
Provides for reading, writing, and manipulating 3DS files. Its
called dom3ds because its reminiscent of XML-DOM: it converts the 3DS
file into a hierarchy of objects, in much the same way XML-DOM
converts an XML file into a hierarchy of objects called the Document
Object Model. The dom3ds module creates an object for each chunk in
the 3DS file, which can be accessed hierarchially as attributes.
For example, once a 3DS file is loaded, you could the smoothing data
of the second object like this:
dom.mdata.objects[2].ntri.faces.smoothing.array
Dice3DS.util
Utitily function for Dice3DS.
Defines some routines for calculating normals and transforming points.
Dice3DS.example.basicmodel
Basic abstract classes representing a 3DS model.
Defines some classes that represent objects and materials of a 3DS
file in a more convienient form. It has methods to convert from the
DOM format. The classes can serve as base classes for more advanced
uses.
Dice3DS.example.glmodel
Classes for rendering 3DS models in OpenGL.
Defines some classes (based on Dice3DS.example.basicmodel) with some
additional methods to draw the model in OpenGL, or create a display
list to do so. Requires PyOpenGL.
Dice3DS.example.gltexture
OpenGL texture object abstraction.
Provides a class that is an abstraction of OpenGL texture objects. It
can create textures from image files, and automatically generates
mipmaps if requested. Requires PyOpenGL and Python Imaging Library.
Dice3DS.example.modelloader
Example of loading 3DS models.
Provides functions to load a 3DS model and creating a GLModel (or
BasicModel) from it. Shows how to load models from the filesystem, or
directly from a zip file.
Enhancements:
- The code was changed to use the constants defined in the "numpy" namespace instead of the "Numeric" namespace, since numpy no longer seems to provide the Numeric constants.
- The advantage is that it works for numpy 1.0.
- The disadvantage is that you can no longer backport it to Numeric by changing the import statements.
- Most inexplicably, the behavior of numpy.sum changed and broke the calculation of normals.
- Thus, the builtin sum is used in util.py instead of numpy.sum.

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.

K-3D is the free-as-in-freedom 3D modeling, animation, and rendering system for GNU / Linux, Posix, and Win32 operating systems. K-3D features a robust, object-oriented plugin architecture, designed to scale to the needs of professional artists, and is designed from-the-ground-up to generate motion-picture-quality animation using RenderMan-compliant render engines. We strongly recommend the Aqsis render engine for use with K-3D.
K-3Ds innovative interactive tutorial system will introduce you to basic use of the program. New tutorials can easily be recorded and shared with the rest of the community.
K-3D allows you to create and edit documents in multiple realtime OpenGL solid, shaded, texture-mapped views. You can even model, animate, and interact with animations while they play back for maximum productivity!
Main features:
- Camera: pan/tilt, zoom, dolly, modeling and tripod modes.
- Viewing Modes: Detailed selection of visible features.
- Hide / unhide geometry.
- Powerful scene graph procedual modeling with complete modeling history.
- Selection: Objects, meshes, faces, edges, patched, curves, point groups, point.
- Geometry types: Polygon, NURBS, subdivision, blobby.
- 3D Primitives: Cone, circle, cushion, cylinder, disk, grid, paraboloid, polyhedon, sphere, torus.
- Boolean modeling operations.
- Text: FreeType? support.
- Instantiation: Create duplicates without adding gemometry to the scene.
- Directed Acyclic Graph (DAG) allows arbitrary dataflow - any object property can be connected to any other compatible property.
- Animate any value.
- Unlimited number of animation channels.
- Bezier curve channels.
- Animate modeling operations.
- Textures with 16-bit float bitdepth.
- Procedual RenderMan shaders.
- Full RenderMan Support: Aqsis, Pixie, BMRT, PRman, 3Delight, Render Dot C.
- Extensible support for alternate render engines and models: YafRay.
- Render OpenGL previews to disk.
- Python engine (preferred for new script development).
- K3DScript engine (minimal scripting engine for tutorials / macros).
- JavaScript engine (legacy script engine).
- Support for alternate script engine plugins and environments.
- Basic 2D compositing.
- Bitdepth 16-bit float per channel.
- Geometry Formats: AC3D, ASCII Scene Export, Apple QuickDraw?3D, AutoCad, Ayam, DirectX?, GNU Triangulated Surfaces, Quake II, PDB, RenderMan Interface Bytestream, VRML, Wavefront ... (some of them depend on PLIB installation)
- Image Formats:
- JPEG (all platforms).
- PNG (all platforms).
- TIFF (all platforms).
- OpenEXR (requires optional OpenEXR plugin).
- BMP (requires optional ImageMagick? plugin).
- SUN (requires optional ImageMagick? plugin).
Enhancements:
- This release features major changes to the internal file-handling code to work correctly with files containing non-ASCII characters.
- Due to the sweeping changes needed to make this possible, this version is considered a "development" release, so users are encouraged to use this release for testing and feedback only.
- All users are strongly encouraged to upgrade to the 0.6 series of K-3D for its completely rewritten user interface, many new features, and significantly improved stability over 0.4.