Free pie software for linux

Guppi is a GNOME-based framework for graphing and interactive data analysis.
Guppi is a library that can be used to extend other programs. Your own programs can either link directly to Guppis shared libraries, or can embed Guppi plots via Bonobo, GNOMEs component architecture.
Guppi is still in an early stage of development, and is still missing several important features. We would still like to encourage you to download Guppi and try it out. If you need a fully-functional plotting package right now, you might want to look into some other free plot programs.
Main features:
- An Extensible Design: Guppi is designed from the ground up to be easily extensible system. Instead of being a single monolithic program, Guppi consists of a small core system, with all of the interesting functionality residing in modular plug-in extensions. By writing plug-ins, it is possible to add new plot types, data import methods, data processing back-ends and statistical operations.
- Modularity For Reuse: All of the interesting functionality in Guppi is broken out into several shared libraries. This allows other programmers to add Guppis interactive plotting capabilities to their own programs.
- Full Scripting Capabilities: Guppis entire API is available via both Scheme and Python, two widely-known programming languages. Since the graphical toolkit that Guppi is built with can also be accessed via Scheme and Python, this means that Guppis user interface can be extended in arbitrarily complex ways from user scripts.
- GNOME Integration: Guppi is being developed as part of the larger GNOME Project, which is dedicated to creating a totally free, user-friendly computing experience for Unix-like operating systems. Thus Guppi will be a well-integrated with a complete suite of productivity software
- Freely available source code: Guppis full source code is available for you: you are free (and in fact encouraged!) to examine it, modify it, customize it, extend it, and pass copies along to others. The goal of the Guppi Project is to create an open system than can be used by either analysts or academics, and which is both a useful tool and a valuable platform for research.
The following is a list of some of the specific capabilities of Guppi. Guppi is under active development, so expect this list to grow.
Data:
- Basic statistics on sets of real numbers: mean, standard deviation, min, max, median, quartiles, percentiles, covariance, correlation.
- Simple linear regression, with analysis: F, p, t-values of model coefficients.
- Support for missing values in data sets.
- Transformed views of data sets: square root, square, log, exp, absolute value, standardization, logit.
- "Smart" data importer for text files containing delimited data sets.
Plotting:
- Basic plot types: scatter plots, line plots, bar charts, pie charts. All plots are fully interactive.
- Marginal box-plots.
- Overlayed regression lines, labeled with model equation.
- Scatter plot markers can be colored and sized by data.
- Brushing in scatter plots.
- Support for logarithmically-scaled axes.
- All plots can be printed as Postscript or PCL. They can be sized in real-world units (i.e. 6" x 4") and the printed output exactly matches the on-screen display.
- On-screen displays are fully anti-aliased and can be rescaled to any magnification level.
Internationalization:
- Translated into Danish, French, German, Icelandic, Norwegian, Russian, Swedish and Ukrainian.

perlhack is a Perl module that will show you how to hack at the Perl internals.

This document attempts to explain how Perl development takes place, and ends with some suggestions for people wanting to become bona fide porters.
The perl5-porters mailing list is where the Perl standard distribution is maintained and developed. The list can get anywhere from 10 to 150 messages a day, depending on the heatedness of the debate. Most days there are two or three patches, extensions, features, or bugs being discussed at a time.

A searchable archive of the list is at either:

http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/

or

http://archive.develooper.com/perl5-porters@perl.org/

List subscribers (the porters themselves) come in several flavours. Some are quiet curious lurkers, who rarely pitch in and instead watch the ongoing development to ensure theyre forewarned of new changes or features in Perl. Some are representatives of vendors, who are there to make sure that Perl continues to compile and work on their platforms. Some patch any reported bug that they know how to fix, some are actively patching their pet area (threads, Win32, the regexp engine), while others seem to do nothing but complain. In other words, its your usual mix of technical people.

Over this group of porters presides Larry Wall. He has the final word in what does and does not change in the Perl language. Various releases of Perl are shepherded by a "pumpking", a porter responsible for gathering patches, deciding on a patch-by-patch, feature-by-feature basis what will and will not go into the release. For instance, Gurusamy Sarathy was the pumpking for the 5.6 release of Perl, and Jarkko Hietaniemi was the pumpking for the 5.8 release, and Rafael Garcia-Suarez holds the pumpking crown for the 5.10 release.
In addition, various people are pumpkings for different things. For instance, Andy Dougherty and Jarkko Hietaniemi did a grand job as the Configure pumpkin up till the 5.8 release. For the 5.10 release H.Merijn Brand took over.

Larry sees Perl development along the lines of the US government: theres the Legislature (the porters), the Executive branch (the pumpkings), and the Supreme Court (Larry). The legislature can discuss and submit patches to the executive branch all they like, but the executive branch is free to veto them. Rarely, the Supreme Court will side with the executive branch over the legislature, or the legislature over the executive branch. Mostly, however, the legislature and the executive branch are supposed to get along and work out their differences without impeachment or court cases.

You might sometimes see reference to Rule 1 and Rule 2. Larrys power as Supreme Court is expressed in The Rules:

Larry is always by definition right about how Perl should behave. This means he has final veto power on the core functionality.

Larry is allowed to change his mind about any matter at a later date, regardless of whether he previously invoked Rule 1.

Got that? Larry is always right, even when he was wrong. Its rare to see either Rule exercised, but they are often alluded to.

New features and extensions to the language are contentious, because the criteria used by the pumpkings, Larry, and other porters to decide which features should be implemented and incorporated are not codified in a few small design goals as with some other languages. Instead, the heuristics are flexible and often difficult to fathom. Here is one persons list, roughly in decreasing order of importance, of heuristics that new features have to be weighed against:

Does concept match the general goals of Perl?

These havent been written anywhere in stone, but one approximation is:

1. Keep it fast, simple, and useful.
2. Keep features/concepts as orthogonal as possible.
3. No arbitrary limits (platforms, data sizes, cultures).
4. Keep it open and exciting to use/patch/advocate Perl everywhere.
5. Either assimilate new technologies, or build bridges to them.

Where is the implementation?

All the talk in the world is useless without an implementation. In almost every case, the person or people who argue for a new feature will be expected to be the ones who implement it. Porters capable of coding new features have their own agendas, and are not available to implement your (possibly good) idea.

Backwards compatibility

Its a cardinal sin to break existing Perl programs. New warnings are contentious--some say that a program that emits warnings is not broken, while others say it is. Adding keywords has the potential to break programs, changing the meaning of existing token sequences or functions might break programs.

Could it be a module instead?

Perl 5 has extension mechanisms, modules and XS, specifically to avoid the need to keep changing the Perl interpreter. You can write modules that export functions, you can give those functions prototypes so they can be called like built-in functions, you can even write XS code to mess with the runtime data structures of the Perl interpreter if you want to implement really complicated things. If it can be done in a module instead of in the core, its highly unlikely to be added.

Is the feature generic enough?

Is this something that only the submitter wants added to the language, or would it be broadly useful? Sometimes, instead of adding a feature with a tight focus, the porters might decide to wait until someone implements the more generalized feature. For instance, instead of implementing a "delayed evaluation" feature, the porters are waiting for a macro system that would permit delayed evaluation and much more.

Does it potentially introduce new bugs?

Radical rewrites of large chunks of the Perl interpreter have the potential to introduce new bugs. The smaller and more localized the change, the better.

Does it preclude other desirable features?

A patch is likely to be rejected if it closes off future avenues of development. For instance, a patch that placed a true and final interpretation on prototypes is likely to be rejected because there are still options for the future of prototypes that havent been addressed.

Is the implementation robust?

Good patches (tight code, complete, correct) stand more chance of going in. Sloppy or incorrect patches might be placed on the back burner until the pumpking has time to fix, or might be discarded altogether without further notice.

Is the implementation generic enough to be portable?

The worst patches make use of a system-specific features. Its highly unlikely that nonportable additions to the Perl language will be accepted.

Is the implementation tested?

Patches which change behaviour (fixing bugs or introducing new features) must include regression tests to verify that everything works as expected. Without tests provided by the original author, how can anyone else changing perl in the future be sure that they havent unwittingly broken the behaviour the patch implements? And without tests, how can the patchs author be confident that his/her hard work put into the patch wont be accidentally thrown away by someone in the future?

Is there enough documentation?

Patches without documentation are probably ill-thought out or incomplete. Nothing can be added without documentation, so submitting a patch for the appropriate manpages as well as the source code is always a good idea.

Is there another way to do it?

Larry said "Although the Perl Slogan is Theres More Than One Way to Do It, I hesitate to make 10 ways to do something". This is a tricky heuristic to navigate, though--one mans essential addition is another mans pointless cruft.

Does it create too much work?

Work for the pumpking, work for Perl programmers, work for module authors, ... Perl is supposed to be easy.

Patches speak louder than words

Working code is always preferred to pie-in-the-sky ideas. A patch to add a feature stands a much higher chance of making it to the language than does a random feature request, no matter how fervently argued the request might be. This ties into "Will it be useful?", as the fact that someone took the time to make the patch demonstrates a strong desire for the feature.

If youre on the list, you might hear the word "core" bandied around. It refers to the standard distribution. "Hacking on the core" means youre changing the C source code to the Perl interpreter. "A core module" is one that ships with Perl.

GD::Simple module is a simplified interface to GD library.

SYNOPSIS

use GD::Simple;

# create a new image
$img = GD::Simple->new(400,250);

# draw a red rectangle with blue borders
$img->bgcolor(red);
$img->fgcolor(blue);
$img->rectangle(10,10,50,50);

# draw an empty rectangle with green borders
$img->bgcolor(undef);
$img->fgcolor(green);
$img->rectangle(30,30,100,100);

# move to (80,80) and draw a green line to (100,190)
$img->moveTo(80,80);
$img->lineTo(100,190);

# draw a solid orange ellipse
$img->moveTo(110,100);
$img->bgcolor(orange);
$img->fgcolor(orange);
$img->ellipse(40,40);

# draw a black filled arc
$img->moveTo(150,150);
$img->fgcolor(black);
$img->arc(50,50,0,100,gdNoFill|gdEdged);

# draw a string at (10,180) using the default
# built-in font
$img->moveTo(10,180);
$img->string(This is very simple);

# draw a string at (280,210) using 20 point
# times italic, angled upward 90 degrees
$img->moveTo(280,210);
$img->font(Times:italic);
$img->fontsize(20);
$img->angle(-90);
$img->string(This is very fancy);

# some turtle graphics
$img->moveTo(300,100);
$img->penSize(3,3);
$img->angle(0);
$img->line(20); # 20 pixels going to the right
$img->turn(30); # set turning angle to 30 degrees
$img->line(20); # 20 pixel line
$img->line(20);
$img->line(20);
$img->turn(-90); # set turning angle to -90 degrees
$img->line(50); # 50 pixel line

# draw a cyan polygon edged in blue
my $poly = new GD::Polygon;
$poly->addPt(150,100);
$poly->addPt(199,199);
$poly->addPt(100,199);
$img->bgcolor(cyan);
$img->fgcolor(blue);
$img->penSize(1,1);
$img->polygon($poly);

# convert into png data
print $img->png;

GD::Simple is a subclass of the GD library that shortens many of the long GD method calls by storing information about the pen color, size and position in the GD object itself. It also adds a small number of "turtle graphics" style calls for those who prefer to work in polar coordinates. In addition, the library allows you to use symbolic names for colors, such as "chartreuse", and will manage the colors for you.

The Pen

GD::Simple maintains a "pen" whose settings are used for line- and shape-drawing operations. The pen has the following properties:

fgcolor

The pen foreground color is the color of lines and the borders of filled and unfilled shapes.

bgcolor

The pen background color is the color of the contents of filled shapes.

pensize

The pen size is the width of the pen. Larger sizes draw thicker lines.

position

The pen position is its current position on the canvas in (X,Y) coordinates.

angle

When drawing in turtle mode, the pen angle determines the current direction of lines of relative length.

turn

When drawing in turtle mode, the turn determines the clockwise or counterclockwise angle that the pen will turn before drawing the next line.

font

The font to use when drawing text. Both built-in bitmapped fonts and TrueType fonts are supported.

fontsize

The size of the font to use when drawing with TrueType fonts.

One sets the position and properties of the pen and then draws. As the drawing progresses, the position of the pen is updated.

Methods

GD::Simple introduces a number of new methods, a few of which have the same name as GD::Image methods, and hence change their behavior. In addition to these new methods, GD::Simple objects support all of the GD::Image methods. If you make a method call that isnt directly supported by GD::Simple, it refers the request to the underlying GD::Image object. Hence one can load a JPEG image into GD::Simple and declare it to be TrueColor by using this call, which is effectively inherited from GD::Image:

my $img = GD::Simple->newFromJpeg(./myimage.jpg,1);

The rest of this section describes GD::Simple-specific methods.

$img->moveTo($x,$y)

This call changes the position of the pen without drawing. It moves the pen to position ($x,$y) on the drawing canvas.

$img->move($dx,$dy)
$img->move($dr)

This call changes the position of the pen without drawing. When called with two arguments it moves the pen $dx pixels to the right and $dy pixels downward. When called with one argument it moves the pen $dr pixels along the vector described by the current pen angle.

$img->lineTo($x,$y)

The lineTo() call simultaneously draws and moves the pen. It draws a line from the current pen position to the position defined by ($x,$y) using the current pen size and color. After drawing, the position of the pen is updated to the new position.

$img->line($dx,$dy)
$img->line($dr)

The line() call simultaneously draws and moves the pen. When called with two arguments it draws a line from the current position of the pen to the position $dx pixels to the right and $dy pixels down. When called with one argument, it draws a line $dr pixels long along the angle defined by the current pen angle.

$img->clear

This method clears the canvas by painting over it with the current background color.

$img->rectangle($x1,$y1,$x2,$y2)

This method draws the rectangle defined by corners ($x1,$y1), ($x2,$y2). The rectangles edges are drawn in the foreground color and its contents are filled with the background color. To draw a solid rectangle set bgcolor equal to fgcolor. To draw an unfilled rectangle (transparent inside), set bgcolor to undef.

$img->ellipse($width,$height)

This method draws the ellipse centered at the current location with width $width and height $height. The ellipses border is drawn in the foreground color and its contents are filled with the background color. To draw a solid ellipse set bgcolor equal to fgcolor. To draw an unfilled ellipse (transparent inside), set bgcolor to undef.

$img->arc($cx,$cy,$width,$height,$start,$end [,$style])

This method draws filled and unfilled arcs. See GD for a description of the arguments. To draw a solid arc (such as a pie wedge) set bgcolor equal to fgcolor. To draw an unfilled arc, set bgcolor to undef.

$img->polygon($poly)

This method draws filled and unfilled polygon using the current settings of fgcolor for the polygon border and bgcolor for the polygon fill color. See GD for a description of creating polygons. To draw a solid polygon set bgcolor equal to fgcolor. To draw an unfilled polygon, set bgcolor to undef.

$img->polyline($poly)

This method draws polygons without closing the first and last vertices (similar to GD::Image->unclosedPolygon()). It uses the fgcolor to draw the line.

$img->string($string)

This method draws the indicated string starting at the current position of the pen. The pen is moved to the end of the drawn string. Depending on the font selected with the font() method, this will use either a bitmapped GD font or a TrueType font. The angle of the pen will be consulted when drawing the text. For TrueType fonts, any angle is accepted. For GD bitmapped fonts, the angle can be either 0 (draw horizontal) or -90 (draw upwards).

For consistency between the TrueType and GD font behavior, the string is always drawn so that the current position of the pen corresponds to the bottom left of the first character of the text. This is different from the GD behavior, in which the first character of bitmapped fonts hangs down from the pen point.
This method returns a polygon indicating the bounding box of the rendered text. If an error occurred (such as invalid font specification) it returns undef and an error message in $@.

$metrics = $img->fontMetrics

($metrics,$width,$height) = GD::Simple->fontMetrics($font,$fontsize,$string)

This method returns information about the current font, most commonly a TrueType font. It can be invoked as an instance method (on a previously-created GD::Simple object) or as a class method (on the GD::Simple class).

When called as an instance method, fontMetrics() takes no arguments and returns a single hash reference containing the metrics that describe the currently selected font and size. The hash reference contains the following information:

xheight the base height of the font from the bottom to the top of
a lowercase m

ascent the length of the upper stem of the lowercase d

descent the length of the lower step of the lowercase j

lineheight the distance from the bottom of the j to the top of
the d

leading the distance between two adjacent lines

($delta_x,$delta_y)= $img->stringBounds($string)

This method indicates the X and Y offsets (which may be negative) that will occur when the given string is drawn using the current font, fontsize and angle. When the string is drawn horizontally, it gives the width and height of the strings bounding box.

$delta_x = $img->stringWidth($string)

This method indicates the width of the string given the current font, fontsize and angle. It is the same as ($img->stringBounds($string))[0]

($x,$y) = $img->curPos

Return the current position of the pen. Set the current position using moveTo().

$font = $img->font([$newfont] [,$newsize])

Get or set the current font. Fonts can be GD::Font objects, TrueType font file paths, or fontconfig font patterns like "Times:italic" (see fontconfig). The latter feature requires that you have the fontconfig library installed and are using libgd version 2.0.33 or higher.

As a shortcut, you may pass two arguments to set the font and the fontsize simultaneously. The fontsize is only valid when drawing with TrueType fonts.

$size = $img->fontsize([$newfontsize])

Get or set the current font size. This is only valid for TrueType fonts.

$size = $img->penSize([$newpensize])

Get or set the current pen width for use during line drawing operations.

$angle = $img->angle([$newangle])

Set the current angle for use when calling line() or move() with a single argument.

Here is an example of using turn() and angle() together to draw an octagon. The first line drawn is the downward-slanting top right edge. The last line drawn is the horizontal top of the octagon.

$img->moveTo(200,50);
$img->angle(0);
$img->turn(360/8);
for (1..8) { $img->line(50) }

$angle = $img->turn([$newangle])

Get or set the current angle to turn prior to drawing lines. This value is only used when calling line() or move() with a single argument. The turning angle will be applied to each call to line() or move() just before the actual drawing occurs.
Angles are in degrees. Positive values turn the angle clockwise.

$color = $img->fgcolor([$newcolor])

Get or set the pens foreground color. The current pen color can be set by (1) using an (r,g,b) triple; (2) using a previously-allocated color from the GD palette; or (3) by using a symbolic color name such as "chartreuse." The list of color names can be obtained using color_names().

$color = $img->bgcolor([$newcolor])

Get or set the pens background color. The current pen color can be set by (1) using an (r,g,b) triple; (2) using a previously-allocated color from the GD palette; or (3) by using a symbolic color name such as "chartreuse." The list of color names can be obtained using color_names().

$index = $img->translate_color(@args)

Translates a color into a GD palette or TrueColor index. You may pass either an (r,g,b) triple or a symbolic color name. If you pass a previously-allocated index, the method will return it unchanged.

$index = $img->alphaColor(@args,$alpha)

Creates an alpha color. You may pass either an (r,g,b) triple or a symbolic color name, followed by an integer indicating its opacity. The opacity value ranges from 0 (fully opaque) to 127 (fully transparent).
@names = GD::Simple->color_names

$translate_table = GD::Simple->color_names

Called in a list context, color_names() returns the list of symbolic color names recognized by this module. Called in a scalar context, the method returns a hash reference in which the keys are the color names and the values are array references containing [r,g,b] triples.

$gd = $img->gd

Return the internal GD::Image object. Usually you will not need to call this since all GD methods are automatically referred to this object.

($red,$green,$blue) = GD::Simple->HSVtoRGB($hue,$saturation,$value)

Convert a Hue/Saturation/Value (HSV) color into an RGB triple. The hue, saturation and value are integers from 0 to 255.

($hue,$saturation,$value) = GD::Simple->RGBtoHSV($hue,$saturation,$value)

Convert a Red/Green/Blue (RGB) value into a Hue/Saturation/Value (HSV) triple. The hue, saturation and value are integers from 0 to 255.

COLORS

This script will create an image showing all the symbolic colors.

#!/usr/bin/perl

use strict;
use GD::Simple;

my @color_names = GD::Simple->color_names;
my $cols = int(sqrt(@color_names));
my $rows = int(@color_names/$cols)+1;

my $cell_width = 100;
my $cell_height = 50;
my $legend_height = 16;
my $width = $cols * $cell_width;
my $height = $rows * $cell_height;

my $img = GD::Simple->new($width,$height);
$img->font(gdSmallFont);

for (my $c=0; $cfgcolor($color);
$img->rectangle(@topleft,@botright);
$img->moveTo($topleft[0]+2,$botright[1]+$legend_height-2);
$img->fgcolor(black);
$img->string($color);
}
}

print $img->png;

Distcc Livecd is a small bootable cdrom that contains a uClibc Linux system, the GNU compiler and a distcc daemon.

The purpose of this CD is to be able to borrow compile CPU power from computers without installing anything on the harddisk. The CD is build with the Gentoo portage framework.

Unlike distccKnoppix, the C compiler on this CD (the default gentoo hardened gcc compiler) supports position independent code (PIE) and stack smashing protection (SSP).

Contents:

gcc
distcc
dropbear ssh

Office Tournament project is a tool for keeping track of office tournaments, such as foosball.

You may enter data from the command line or from the CGI Web interface. It outputs all kinds of stats and even a nice chart if you use the Imager::Graph::Pie Perl library available from CPAN.

It currently requires no database to run, but there are plans to migrate the text (flat file db) to MySQL.

DISLIN is a high-level plotting library for displaying data as curves, polar plots, bar graphs, pie charts, 3D-color plots, surfaces, contours and maps.
DISLIN is intended to be a powerful and easy to use software package for scientists and programmers. There are only a few graphics routines with a short parameter list needed to display the desired graphical output. A large variety of parameter setting routines can then be called to create individually customized graphics.
The software is available for several C, Fortran 77 and Fortran 90/95 compilers on the operating systems UNIX, Linux, FreeBSD, OpenVMS, Windows and MS-DOS. DISLIN programs are very system-independent, they can be ported from one operating system to another without any changes.
For some operating systems, the programming languages textExtern Python, textExtern Perl and textExtern Java are also supported by DISLIN. The DISLIN interpreter DISGCL is availble for all supported operating systems. See a complete list of the supported operating systems and compilers.
A short description of the DISLIN features is given in Overview. DISLIN manuals can be downloaded as compressed tar files in PostScript, PDF and HTML format. An online manual is also available as an alphabetical list of all DISLIN routines.
DISLIN is free for non-commercial use. Licenses for selling programs linked with
DISLIN or for using DISLIN in an environment related to business are available from this site.
The DISLIN software and manuals can be downloaded via HTML and from FTP servers.
Enhancements:
- Thread-safe C libraries, additional character features, hardware symbols, an unlimited number of widgets, and bugfixes.

JpGraph makes it easy to draw both "quick and dirty" graphs with a minimum of code and complex professional graphs which requires a very fine grain control.
The library assigns context sensitive default values for most of the parameters which minimizes the learning curve. The features are there when you need it - they dont get in your way. The JpGraph library also comes wih very extensive documentation.
Main features:
- Web-friendly, average image size for a 300*200 image is around 2K and images are seldomly bigger than 4-5K
- Support for both GD1 and GD2 The library will autodetect which library is installed.
- Automatic generation of client side image maps to make it possible to generate drill-down graphs.
- Advanced interpolation with cubic splines to get smooth curves from just a few data points.
- Advanced support to add text to images with multi-line paragraphs and formatting support in several TTF fonts.
- Support for alpha blending
- has over 200+ built in Country flags
- Support automatic timing of images.
- Supports adding arbitrary lines and filled areas (with patterns) to plots
- Supports several plot types,spider-plots, pie-charts (both 2d and 3d) , scatter-plots, line-plots, filled line-plots, accumulated line-plots, bar plots, accumulated bar plots, grouped bar plots, error plots, line error plots, box plots, stock plots
- Supports advanced Gantt-charts (ex1, ex2)
- Flexible scales, supports text-lin, text-log, lin-lin, lin-log, log-lin and log-log
- Supports integer scale (labels are restricted to integers).
- Supports both PNG, GIF and JPG graphic formats. and can automatically choose the best available graphic format. Note that the available formats are dependent on the specific PHP installation where the library is used.
- Support various layout with a background image behind the plot
- Supports horizontal bar graphs
- Supports scientific plots
- More than 400 named colors
- Several possible axis positions
- Supports caching (with timeout) of generated graphs to lessen burden of a HTTP server.
- Intelligent autoscaling which gravitates towards aesthetical values.
- Fully supports manual scaling, with fine grain control of position of ticks
- Several different fill styles for line plots
- Supports up to two different y-scales, it is possible to have different left and right y-scale and add plots to both
- Supports unlimited number of plots in each graph, makes it easy to compose complex graph which consists of several plot types
- Designed as a flexible OO framework which makes it easy to add new types of plots
- Supports anti-aliasing of lines, more ...
- Supports color-gradient fill for bar graphs
- Supports automatic legend generation with user supplied format.
- Supports both vertical and horizontal grids (with image depth specification)
- Supports both on-the fly image generation and batch processing.
- Includes graph module to make it very easy to draw arbitrary shapes using custom scale on a canvas including Bezier-curves with full support for all the features of JpGraph (including caching and timeout).x
- Barcode generation The professional version includes a Barcode module that makes it easy to generate barcodes in all commonly used symbologies.
- Designed modularly - you dont have to include code which isnt used. JpGraph Architecture Block diagram
- extensive documentation with both a 150 pages tutorial and an extensive class reference.
- ... and many, many more features
Enhancements:
- This release follows the PHP4 version with functionality and defect fixes.
- 7x4 LED-like displays have been added.
- A long-standing issue with user-defined pie colors and legends has been fixed.
- There are various bugfixes.