Free diagrams software for linux

DiaCanvas2 is a flexible diagramming widget. It is based on GnomeCanvas. It uses its own constraint solver to maintain relationships between items on the canvas.
DiaCanvas2 is Model, View and Controller-based and makes full use of GnomeCanvas features.
Main features:
- Model/View/Controller based design: The DiaCanvas class only holds abstract data (using DiaShape objects), the data is rendered by one or more DiaCanvasViews.
- The widely used GnomeCanvas for visualization. This makes it easy to let DiaCanvas2 display anti-aliased diagrams with translucency (alpha) support.
- Export facilities for GnomePrint and SVG.
- Objects can be rotated/sheared/resized/etc. without the need to recalculate shapes. DiaCanvas relies heavily on the LibArt library (which is a standard GNOME library).
- Objects can connect to each other with handles. The connection is represented as a mathematical equation, which is solved using a linear constraint solver (see the reference documentation for more info). Handles do not need predefined connection points, but can connect to each other in a more generic way.
- Of course DiaCanvas2 has all the features a modern application needs, including undo/redo functionality.
- DiaCanvas2 is tested using Unit-tests. The unit test is a set of tests that ensure a consistent (application programming) interface.
Note that DiaCanvas is not related to the diagramming tool DIA, except for its look and feel.

Clara is a help-documentation tool for C++ or java developers. Basically she paints a diagram - a clara diagram - from a class.

With clara you can visualize your class as if it were a chip with pins for input - representing the input parameters of the methods - and pins for output - representing the return type of the functions-.

Lets see for example the diagram that clara would draw for the following C++ sample class

class sampleInterface
{
public:

void init (MyStructure * pstruct);

void setPoint (float x, float y);

float getX ();
float getY ();

void processIt ();
};

What are these pins for ? Are we going to connect them somehow ? Not at all, it is just a convenient way to represent what the class offers in a very compact form.

Of course the diagram will be drawn by clara automatically, there is no need (and no chance) of manually drawing anything.

Clara gets the needed information in two ways : using reflection in java and parsing the header file in C++. Clara can also draw a call-diagram of the class if the sources are found, note though that for the call-diagram an extra tool is needed (dot.exe from http://www.graphviz.org) and it has to be installed apart.

Dia is designed to be much like the commercial Windows program Visio. It can be used to draw many different kinds of diagrams.

Dia project currently has special objects to help draw entity relationship diagrams, UML diagrams, network diagrams, flowcharts, and simple circuits. It is also possible to add support for new shapes by writing simple XML files, using a subset of SVG to draw the shape.

It can load and save diagrams to a custom XML format (gzipped by default, to save space), can export diagrams to EPS or SVG formats and can print diagrams (including ones that span multiple pages).

UMLGraph facilitates the declarative specification and drawing of UML class and sequence diagrams.
One can specify a class design using the Java syntax complemented by Javadoc tags.
Running the UmlGraph doclet on the specification generates a Graphviz diagram specification that can be automatically processed to create Postscript, GIF, SVG, JPEG, fig, or Framemaker drawings.
Similarly, sequence diagrams are specified using declarative pic macros and compiled with the GNU plotutils pic2plot program into a PNG, PNM, (pseudo) GIF, SVG, AI, Postscript, CGM, FIG, PCL, HPGL, Regis, or TEK drawing.
Enhancements:
- This version improves its invocation interface so that it can be run directly as a jar file.
- It has support for sending results to the standard output for direct piping into dot.
- The distribution includes an example shell script and batch file for invoking UMLGraph.

ArgoUML is a pure Java open source UML CASE tool that provides cognitive support for object-oriented design.
ArgoUML provides some of the same editing and code generation features of a commercial CASE tool, but it focuses on features that enhance usability and support the cognitive needs of designers. Uses XML file formats: XMI and PGML.
Main features:
- Click and Go! with Java Web Start
- Platform Independent: Java 1.4+
- Standard UML 1.3 Meta-Model
- 8 out of 9 Diagrams supported
- XMI-Support
- Export Diagrams as GIF, PS, EPS, PGML and SVG
- Internationalization EN, DE, ES, RU, FR, NB
- Advanced diagram editing and Zoom
- OCL Support
- Forward Engineering
- Reverse Engineering / Jar/class file Import
- Cognitive Support
- Reflection-in-action
- Design Critics
- Corrective Automations (partially implemented)
- "To Do" List
- User model (partially implemented)
- Opportunistic Design
- "To Do" List
- Checklists
- Comprehension and Problem Solving
- Explorer Perspectives
- Multiple, Overlapping Views
- Alternative Design Representations: Graphs, Text, or Table
Enhancements:
- This is the first release which easily generates Debian packages and installs the server cleanly.
- The Perl client works correctly when connecting to the server and allows all the basic operations to be carried out.

Graphviz - Graph visualization is a way of representing structural information as diagrams of abstract graphs and networks. Automatic graph drawing has many important applications in software engineering, database and web design, networking, and in visual interfaces for many other domains.

Graphviz is open source graph visualization software. It has several main graph layout programs. See the gallery for some sample layouts. It also has web and interactive graphical interfaces, and auxiliary tools, libraries, and language bindings.

The Graphviz layout programs take descriptions of graphs in a simple text language, and make diagrams in several useful formats such as images and SVG for web pages, Postscript for inclusion in PDF or other documents; or display in an interactive graph browser. (Graphviz also supports GXL, an XML dialect.)

Graphviz has many useful features for concrete diagrams, such as options for colors, fonts, tabular node layouts, line styles, hyperlinks, and custom shapes.

In practice, graphs are usually generated from an external data sources, but they can also be created and edited manually, either as raw text files or within a graphical editor. (Graphviz was not intended to be a Visio replacement, so it is probably frustrating to try to use it that way.)

Games::Go::Dg2Mp is a Perl extension to convert Games::Go::Diagrams to John Hobbys MetaPost (which is adapted from Donald Knuths Metafont).

SYNOPSIS

use Games::Go::Dg2Mp
my $dg2mp = B convertDiagram($diagram);

A Games::Go::Dg2Mp object converts a Games::Go::Diagram object into a TeX (.tex) and a MetaPost (.mp) file. The MetaPost file contains figures for each of the diagrams and overstones required to make the complete game diagram.

Running MetaPost (mpost or possibly mp) on the .mp file creates a set of figure files, each of which is an Encapsulated PostScript figure. Running TeX (tex) on the .tex file creates a .dvi file which tries to include the Encapsulated PostScript figures. Running dvips on the .dvi file (from TeX) creates the final PostScript (.ps) file containing the complete game diagram.

See man mpost (or possibly man mp) for more details of the overall MetaPost system and environment.