Free svg software for linux

svgl is a library that displays SVG documents using OpenGL, taking advantage of the GPU.

Rendering:

A lot of svg 1.0 features are implemented: simples shapes, path, gradient, clipping, viewBox, opacity, < use >, animations etc.

Fonts are handled by the glft companion library, which allows for autoscaling according to the current scale, and automatic choice between vectorized glyphs or textures based on freetype2 rendering.

Texturized fonts are antialiased by freetype, while every other drawings are FSAA by OpenGL.

Next step is optimization by using various techniques like display list, culling, and cache rendering into textures.

Interacting:

Picking is provided under 2 forms:

- returns the deepest SVG element (leaf) corresponding to the shape designated by the user
- returns the stack of SVG elements under the cursor, so that UI techniques like toolglasses (see screenshot) is easily implemented

PanAndZoom done right (according to me...) : since its fast and usable, we can really use it in an interface

Tansform so-called "consolidation" (concatenation of transform matrices) allows easy implementation of scale-independant DnD.

Programming:

We try to make the api as simple as possible, for creating, manipulating, changing style, loading etc.

See demos/tutorial to see how to code with svgl.

A (pre-alpha) python extension allows for rapid application development and easy integration in wxPython.

SVGpage project is a pyGTK application to view and convert to and from vector (SVG) graphics. In addition to SVG files the application is able to open PNG, GIF, JPG (including Exif), BMP and XPM. It can save as SVG, PNG or JPG.
If you are looking for an SVG editor capable of creating fine, crisp curves and gradients, youve got the wrong program. For simple graphics SVGpage can convert to SVG and render something very close.
For involved images, like pictures, you wind up with a PAINTERLY EFFECT. This effect can be very distinctive and attractive and is sought after by many. Sort of a good, single-click "GIMPressionist." So if thats what youre looking for, youve found it.
SVGpage can also take your SVG images and convert them to a PNG or a JPG. Even resize them. It uses Bilinear Interpolation and does an excellent job.
Enhancements:
- Fixes linking eror(wrong version in symlink) for the binary running on Ubuntu.
- Binary no longer startd from a script, therefore the "what do you want to do with this executable text file" dialog on Ubuntu is bypassed.
- UI layout change to accommodate window dressings on Ubuntu and other distros. All options now fit correctly.

uml2svg is an XSLT-based tool for converting XMI-compliant UML Diagrams into SVG.
We started the developing uml2svg with six main goals in mind:
- Standard conformance
- Good Documentation
- Modularity
- Extensibility
- Comprehensible SVG
- Multiple diagrams per XMI-file
SVG is a standard language for describing two-dimensional vector graphics in XML. As the open SVG standard gains in popularity and gradually replaces proprietary formats for vectorial graphics, the support provided by the Web browsers is getting better.
Plugins to display SVG exist for most browsers and it is most likely that the next generation of Web browser will provide built-in support for SVG. When that happens there will be no better way to distribute vector graphics on the web. Furthermore, not only web browsers can process SVG in a meaningful way; in fact that is just the tip of the iceberg. SVG can be easily read in, processed, and then transformed into many other formats, being well suited for both text and graphic tools as well as for web agents and screen readers.
UML diagrams are composed of lines, polygons, ellipses and text labels, so they are inherently vectorial. However, the SVG is not very well suited for direct use by UML tools. While some of them can in fact export UML diagrams directly to SVG, they do that by discarding all the information about structure, and converting everything into a shape. Moreover, some tools use the screen-capture function provided by their environment (such as java2d) and then they apply a filter to generate SVG out of the "screenshot".
What comes out of that is a pile of meaningless information, which by accident happens to draw a gorgeous diagram. How will a screen reader interpret such a file? How will a web crawler be able to index it? How will a web agent process it in a meaningful way? A program needs the semantic information that the humans can extract just by looking at a picture. For a machine, an obfuscated SVG file is not easier to process than a PNG file or any other image.
Although for humans it is better to be able to scale the image, for a program this is irrelevant. Programs need a way to "understand" the semantics of the UML models to be able to process and interchange them in a meaningfull way. This was the main idea behind the XML Metadata Interchange (XMI), an OMG specification for model interchange. And probably the best use that XMI has found so far is the exchange of UML models between different modeling tools. And while the XMI provides a standard way for tools to represent models as XML documents, it is still limited to the model elements only.
With the introduction of the UML 2.0 Diagram Interchange Specification as part of the upcoming UML 2.0 standard, it will become possible for tools to exchange the models together with the layout of the diagrams. We think that, once this specification appears, XMI will be used averywhere. Not only will the tools be able to exchange diagrams, but could even represent them internaly as DOM trees. Have you ever considered drawing your UML diagrams online, using only a web browser? This could be done even now by using a custom SVG syntax for the DOM tree, but a solution based on XMI could do even better and be a standard at the same time.
Therefore, we believe that with the advent of UML 2.0 and the increase in the use of SVG, the need for transformations between XMI and SVG will be great. Nevertheless when the uml2svg project was started, there was hardly any good open-source solution to convert XMI diagams into SVG.
The UML 2.0 Diagram Interchange Adopted Specification in its current incipient form references a set of XSL transformations. Although the standard draft covers them to a large extent, the link is actually broken (you can try for yourself). It has been broken for more than a year and most likely it will stay like that forever.
The personal webpage of Professor Mario Jeckle provides an online transformation service capable of dynamically generating SVG from XMI-compliant XML files. The XSL files accomplishing the transformations are also available on that website. These transformations are monolithic and not well documented (the only documentation is in the code, and it is generally written in German). With the tragic accident that took the life of Professor Jeckle, the transformations have no longer been maintained.
Finally, the STZ-IDA research center in Karlsruhe had to convert UML diagrams to SVG, as part of one of their projects. The XSLT stylesheet they created for this purpose was named xmi2svg and is available under the terms of the MIT license. At the time we started work on uml2svg the only type of diagrams supported was class diagrams.
Recently the package reached version 0.2 and it supports more diagram types, without major changes in the code (the opposite of what we were expecting). Andreas Junghans, the author of xmi2svg, provided us with a lot of insightful hints which helped us eliminate many glitches in uml2svg. It looks that the development of uml2svg and xmi2svg will continue in parallel, at least for a while. The good thing about this is that the two (quite different) implementations prove each others validity and the features tend to propagate freely from one side to the other. However, this comes with the prize of having to maintain two different code-trees and possibly confusing some users.
We did not like the two existing solutions because they were:
incomplete - just prototypes, not well suited for production environment
monolithic - hard to maintain and extend
not documented - hard to understand
At first sight, we thought we could find a way to improve one of the existing solutions and just add the features we needed. However, we slowly came to the conclusion that it would be better if we started anew. There are things one can fix in a project, but that does not include what we thought is was bad design. The fact that the two implementations presented above are open source helped us get quickly on the way with our own project.
Enhancements:
- Two annoying bugs were fixed.
- The site and documentation were updated.

The SVG Icons project provides SVG icon themes for desktop environments, including KDE and GNOME. They provide high rendering quality due to anti-aliasing, and reduce the amount of disk space required.

SVG Icons project has a goal to provide Open-Source reference implementation of SVG icon themes for leading Linux and UNIX Desktop Environments, in particular (but not limited to) KDE3 and GNOME2 Desktop environments.

SVG implementation for icons and other User Interface elements provides better rendering quality (due to extensive usage of anti-aliasing), reduces amount of disk space used, and decreases download time for icon themes over the web.

Developing icons in SVG also dramatically reduces development cycle, and allows to deliver results quickly, in prompted timeframe.

SVGSlice application can generate chopped up images from Inkscape SVG drawings.

To figure out where to cut, SVGSlice can use Inkscapes built in guides (for simpler, grid-like cuts), or it can use a specially named "slices" layer that contains rectangles that mark areas to slice.

Demo files showing both approaches are included.

SVGGraph is a Perl extension for creating SVG Graphs / Diagrams / Charts / Plots.

SYNOPSIS

use SVGGraph;

my @a = (1, 2, 3, 4);
my @b = (3, 4, 3.5, 6.33);

print "Content-type: image/svg-xmlnn";
my $SVGGraph = new SVGGraph;
print SVGGraph->CreateGraph(
{title => Financial Results Q1 2002},
[@a, @b, Staplers, red]
);

This module converts sets of arrays with coordinates into graphs, much like GNUplot would. It creates the graphs in the SVG (Scalable Vector Graphics) format. It has two styles, verticalbars and spline. It is designed to be light-weight.

If your internet browser cannot display SVG, try downloading a plugin at adobe.com.

EXAMPLES

For examples see: http://pearlshed.nl/svggraph/1.png and http://pearlshed.nl/svggraph/2.png

Long code example:

#!/usr/bin/perl -w -I.

use strict;
use SVGGraph;

### Array with x-values
my @a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
### Arrays with y-values
my @b = (-5, 2, 1, 5, 8, 8, 9, 5, 4, 10, 2, 1, 5, 8, 8, 9, 5, 4, 10, 5);
my @c = (6, -4, 2, 1, 5, 8, 8, 9, 5, 4, 10, 2, 1, 5, 8, 8, 9, 5, 4, 10);
my @d = (1, 2, 3, 4, 9, 8, 7, 6, 5, 12, 30, 23, 12, 17, 13, 23, 12, 10, 20, 11);
my @e = (3, 1, 2, -3, -4, -9, -8, -7, 6, 5, 12, 30, 23, 12, 17, 13, 23, 12, 10, 20);

### Initialise
my $SVGGraph = new SVGGraph;
### Print the elusive content-type so the browser knows what mime type to expect
print "Content-type: image/svg-xmlnn";
### Print the graph
print $SVGGraph->CreateGraph( {
graphtype => verticalbars, ### verticalbars or spline
imageheight => 300, ### The total height of the whole svg image
barwidth => 8, ### Width of the bar or dot in pixels
horiunitdistance => 20, ### This is the distance in pixels between 1 x-unit
title => Financial Results Q1 2002,
titlestyle => font-size:24;fill:#FF0000;,
xlabel => Week,
xlabelstyle => font-size:16;fill:darkblue,
ylabel => Revenue (x1000 USD),
ylabelstyle => font-size:16;fill:brown,
legendoffset => 10, 10 ### In pixels from top left corner
},
[@a, @b, Bananas, #FF0000],
[@a, @c, Apples, #006699],
[@a, @d, Strawberries, #FF9933],
[@a, @e, Melons, green]
);

libRSVG is a component used within software applications to enable support for SVG-format scalable graphics.
In contrast to raster formats, scalable vector graphics provide users and artists a way to create, view, and provide imagery that is not limited to the pixel or dot density that an output device is capable of.
Many software developers use the librsvg library to render SVG graphics. It is lightweight and portable, requiring only libxml and libart at a minimum, while providing extra features when used with libcroco, libgsf, and mozilla. It is included as part of the GNOME Desktop, and is licensed under the LGPL license.
Enhancements:
- rsvg-styles.c: Basic support for SVG 1.1s text-rendering and shape-rendering properties (#464599)
- http://www.w3.org/TR/SVG/painting.html#ShapeRenderingProperty
- rsvg-styles.h: Ditto
- rsvg-cairo-draw.c: Ditto

SVG::Metadata is a Perl module to capture metadata info about an SVG file.

SYNOPSIS

use SVG::Metadata;

my $svgmeta = new SVG::Metadata;

$svgmeta->parse($filename)
or die "Could not parse $filename: " . $svgmeta->errormsg();
$svgmeta2->parse($filename2)
or die "Could not parse $filename: " . $svgmeta->errormsg();

# Do the files have the same metadata (author, title, license)?
if (! $svgmeta->compare($svgmeta2) ) {
print "$filename is different than $filename2n";
}

if ($svgmeta->title() eq ) {
$svgmeta->title(Unknown);
}

if ($svgmeta->author() eq ) {
$svgmeta->author(Unknown);
}

if ($svgmeta->license() eq ) {
$svgmeta->license(Unknown);
}

if (! $svgmeta->keywords()) {
$svgmeta->addKeyword(unsorted);
} elsif ($svgmeta->hasKeyword(unsorted) && $svgmeta->keywords()>1) {
$svgmeta->removeKeyword(unsorted);
}

print $svgmeta->to_text();

This module provides a way of extracting, browsing and using RDF metadata embedded in an SVG file.

The SVG spec itself does not provide any particular mechanisms for handling metadata, but instead relies on embedded, namespaced RDF sections, as per XML philosophy. Unfortunately, many SVG tools dont support the concept of RDF metadata; indeed many dont support the idea of embedded XML "islands" at all. Some will even ignore and drop the rdf data entirely when encountered.
The motivation for this module is twofold. First, it provides a mechanism for accessing this metadata from the SVG files. Second, it provides a means of validating SVG files to detect if they have the metadata.

The motivation for this script is primarily for the Open Clip Art Library (http://www.openclipart.org), as a way of filtering out submissions that lack metadata from being included in the official distributions. A secondary motivation is to serve as a testing tool for SVG editors like Inkscape (http://www.inkscape.org).