Free chart software for linux

Libchart is a free chart creation PHP library, that is easy to use.
Main features:
- Bar charts (horizontal or vertical).
- Line charts.
- Pie charts.
- Compatibility with PHP 4 / PHP 5.
- No external dependency, need only PHP compiled with GD and FreeType

Bootchart is a software for performance analysis and visualization of the GNU/Linux boot process. Resource utilization and process information are collected during the boot process and can later be displayed in a PNG, SVG or EPS-encoded chart.

The boot process is modified to start the boot logger (/sbin/bootchartd) instead of /sbin/init. The boot logger will run in background and collect information from the proc file system (/proc/[PID]/stat, /proc/stat and /proc/diskstats).

The statistics are logged to a virtual memory file system (tmpfs). Once the boot process completes (denoted by the existence of specific processes), the log files are packaged to /var/log/bootchart.tgz.

The log package can later be processed using a Java application which builds the process tree and renders a performance chart. The chart may then be analyzed to examine process dependency and overall resource utilization. A renderer web form is also available on the project web site.

The chart can then be analyzed to examine process dependency and overall resource utilization.

Runing:

1. Install bootchartd and the bootchart renderer. See INSTALL for details.

2. Modify your boot loader (GRUB/LILO) if necessary. Alternatively, change the kernel command line interactively upon reboot.
Reboot.

3. Verify that /var/log/bootchart.tgz was created and contains the log files.

4. Render the chart by running:

$ java -jar bootchart.jar

Alternatively (if no Java Development Kit is installed to build the JAR package), the web renderer may be used.

To use the web renderer from a script, run:
curl --form format=svg --form log=@/var/log/bootchart.tgz
http://bootchart.klika.si:8080/bootchart/render > bootchart.svgz

(optionally replacing the svg/bootchart.svgz pair with png/bootchart.png or eps/bootchart.eps.gz)

5. View the generated image and analyze the chart.
SVG images may be viewed using any of the following programs:
- rsvg-view (librsvg; GNOME)
- svgdisplay (ksvg; KDE)
- Gimp (using the gimp-svg plugin)
- Inkscape
- Squiggle (Batik; http://xml.apache.org/batik/)

To get help for additional options, run:

$ java -jar bootchart -h

How it works:

Logger Startup

The boot logger (/sbin/bootchartd) is run by the kernel instead of /sbin/init. This can be achieved by modifying the GRUB or LILO kernel command line, e.g.:

/boot/grub/menu.lst
[...]
title Fedora Core (2.6.10) - bootchart
root (hd0,1)
kernel /vmlinuz-2.6.10 ro root=/dev/hda1 init=/sbin/bootchartd
initrd /initrd-2.6.10.img

The installation script and RPM package will try to add the boot loader entry automatically.

The boot logger will start itself in the background and immediately run the default init process, /sbin/init. The boot process will then continue as usual.

Data Collection

Since the root partition is mounted read-only during boot, the logger needs to store data in memory, using a virtual memory file system (tmpfs).

As soon as the /proc file system is mounted — usually early in the sysinit script — the logger will start collecting output from various files:
/proc/stat system-wide CPU statistics: user, system, IO and idle times
/proc/diskstats system-wide disk statistics: disk utilization and throughput
(only available in 2.6 kernels)
/proc/[PID]/stat information about the running processes: start time, parent PID, process state, CPU usage, etc.

The contents of these files are periodically appended to corresponding log files, every 0.2 seconds by default.

The logger will try to detect the end of the boot process by looking for specific processes. For example, when in runlevel 5 (multi-user graphical mode), it will look for gdmgreeter, kdm_greet, etc. As soon as one of these processes is found running, the logger will stop collecting data, package the log files and store them to /var/log/bootchart.tgz.

Optional Process Accounting

In most cases, the output from /proc/[PID]/stat files suffices to recreate the process tree. It is possible however, that a short-lived process will not get picked up by the logger. If that process also forks new processes, the logger will lack dependency information for these "orphaned" processes — meaning that they might get incorrectly grouped by the chart renderer.

When truly accurate dependency information is required, process accounting may be utilized. If configured, the kernel will keep a log file with detailed information about processes. BSD process accounting v3 includes information about the process PID and parent PID (PPID) — effectively enabling an accurate reconstruction of the process tree.

To enable process accounting, the kernel needs to be configured to include CONFIG_BSD_PROCESS_ACCT_V3, under:

[ ] General setup
[ ] BSD Process Accounting
[ ] BSD Process Accounting version 3 file format

The GNU accounting utilities (package psacct or acct) also need to be installed. The boot logger will use the accton command to enable process accounting; it will include the accounting log in the tarball.

Visualization

The log tarball is later passed to the Java application for parsing and rendering the data. The CPU and disk statistics are used to render stacked area and line charts. The process information is used to create a Gantt chart showing process dependency, states and CPU usage.

A typical boot sequence consists of several hundred processes. Since it is difficult to visualize such amount of data in a comprehensible way, tree pruning is utilized. Idle background processes and short-lived processes are removed. Similar processes running in parallel are also merged together.

Finally, the performance and dependency charts are renderer as a single image in either PNG, SVG or EPS format.

Chart::XMGR is a Perl object for displaying data via XMGR.

SYNOPSIS

use Chart::XMGR;

xmgr($a, { SYMBOL => plus};

use Chart::XMGR ();

$xmgr = new Chart::XMGR;
$xmgr->line($pdl);

$pdl->$xmgr->line;

xmgr($pdl, { LINESTYLE => dotted });

Provides a perl/PDL interface to the XMGR plotting package. Can be used to plot PDLs or Perl arrays.

A simple function interface is provided that is based on the more complete object-oriented interface.

The interface can be implemented using either anonymous pipes or named pipes (governed by the module variable Chart::XMGR::NPIPE). If named pipes are used ($NPIPE = 1) XMGR can be controlled via the pipe and buttons are available for use in XMGR. If an anonymous pipe is used XMGR will not accept button events until the pipe has been closed.

Currently the named pipe option can not support data sets containing 3 or more columns (I havent worked out how to do it anyway!). This means that only TYPE XY is supported. For anonymouse pipe 3 or more columns can be supplied along with the graph type.

The default option is to use the named pipe.

Chart::Plot is a Perl module to plot two dimensional data in an image.

SYNOPSIS

use Chart::Plot;

my $img = Chart::Plot->new();
my $anotherImg = Chart::Plot->new ($image_width, $image_height);

$img->setData (@dataset) or die( $img->error() );
$img->setData (@xdataset, @ydataset);
$img->setData (@anotherdataset, red_dashedline_points);
$img->setData (@xanotherdataset, @yanotherdataset,
Blue SolidLine NoPoints);

my ($xmin, $ymin, $xmax, $ymax) = $img->getBounds();

$img->setGraphOptions (horGraphOffset => 75,
vertGraphOffset => 100,
title => My Graph Title,
horAxisLabel => my X label,
vertAxisLabel => my Y label );

print $img->draw();

I wrote Chart::Plot to create images of some simple graphs of two dimensional data. The other graphing interface modules to GD.pm I saw on CPAN either could not handle negative data, or could only chart evenly spaced horizontal data. (If you have evenly spaced or nonmetric horizontal data and you want a bar or pie chart, I have successfully used the GIFgraph and Chart::* modules, available on CPAN.)

Chart::Plot will plot multiple data sets in the same graph, each with some negative or positive values in the independent or dependent variables. Each dataset can be a scatter graph (data are represented by graph points only) or with lines connecting successive data points, or both. Colors and dashed lines are supported, as is scientific notation (1.7E10). Axes are scaled and positioned automatically and 5-10 ticks are drawn and labeled on each axis.

You must have already installed the GD.pm library by Lincoln Stein, available on CPAN or at http://stein.cshl.org/WWW/software/GD/ Versions of GD below 1.19 supported only gif image format. Versions between 1.20 and 1.26 support only png format. GD version 1.27 supports either png or jpg image formats. Chart::Plot will draw whichever format your version of GD will draw. (See below for a method to determine which format your version supports.)

Daylight Chart project shows sunrise and sunset times in an attractive chart, for any location in the world. The effect of daylight savings time is also displayed. Charts can be exported to image files.

Chart::GRACE is a Perl object for displaying data via Xmgrace.

SYNOPSIS

use Chart::GRACE;

xmgrace($a, { SYMBOL => plus};

use Chart::GRACE ();

$grace = new Chart::GRACE;
$grace->plot($pdl);

xmgrace($pdl, { LINESTYLE => dotted });

Provides a perl/PDL interface to the XMGR plotting package. Can be used to plot PDLs or Perl arrays.

A simple function interface is provided that is based on the more complete object-oriented interface.

The interface can be implemented using either anonymous pipes or named pipes (governed by the module variable Chart::GRACE::NPIPE). If named pipes are used ($NPIPE = 1) XMGR can be controlled via the pipe and buttons are available for use in XMGR. If an anonymous pipe is used XMGR will not accept button events until the pipe has been closed.

Currently the named pipe option can not support data sets containing 3 or more columns (I have not worked out how to do it anyway!). This means that only TYPE XY is supported. For anonymouse pipe 3 or more columns can be supplied along with the graph type.

The default option is to use the named pipe.

KDChart application is a tool for creating business charts and is the most powerful Qt component of its kind.
Besides from having all the standard features, it also enables the developer to design and manage a large number of axes and provides sophisticated means of customization.
In addition to detailed and precisely configuring the chart layout it is possible to complement the design by adding custom rich-text boxes and/or frames to data points or to random positions.
Being extremely configurable, KDChart is also easily scalable by automatically adjusting font sizes and layout when being resized. This makes it possible to quickly and efficiently create user-friendly programs that offer the same level of functionality, or a even higher one, in Qt programs as on other platforms. It is no coincidence that the current version of the KOffice productivity suite uses our library.
Whats New in 1.1.3 Stable Release:
Besides from various smaller fixes, code adjusting and other issues like documentation updates, the following list contains a list of bugfixes included in the KD Chart 1.1.3 release.
Printing:
- Fixed the display of the axis title font when using high resolution printing.
Bars:
Fixes 3D bars painting:
- The front face of the bar now matches the y axis labels.
- Fixed various rendering errors depending of the values of the bars (high values - negative values ...)
Fixes bars painting
- Fixed painting of excess arrows, when the user choose to display a restricted view of the chart ( start/end values).
- The user have a better control over the bar Width when needed.
- Fixed occasional painting problem when resizing a barPercent view.
- Bar painting is more accurate and looks better.
3D Lines:
- Fixed wrong display for 3D lines painting.
Axis
- Fixed axis subdelimiters: Were not always precisely matching with the grid lines, data values.
- Added the possibility to force the diplay of non fractional values on the axis.
Legends:
- Fixed alignment of the legend text to its marker.
- Fixed rendering legends when changing its position and orientation
Compiling:
- Fixed a compilation issue on gcc 3.4
Labels truncation and position:
- Several small issues has been fixed. Those cases were happening occasionally.
- .. and various other bug fixes and code tuning.

This program enables you to draw sky charts, making use of the data in 16 catalogs of stars and nebulae. In addition the position of planets, asteroids and comets are shown.
The purpose of this program is to prepare different sky maps for a particular observation.
A large number of parameters help you to choose specifically or automatically which catalogs to use, the colour and the dimension of stars and nebulae, the representation of planets, the display of labels and coordinate grids, the superposition of pictures, the condition of visibility and more. All these features make this celestial atlas more complete than a conventional
planetarium.
Enhancements:
- The default database is now SQLite to simplify the installation process.
- MySQL is still available if need.
- Add the Calendar menu with more functions for the comets and asteroids.
- Add a display bar to quickly show or hide some object from the chart.
- Complete the menu with all the available functions.
- In the configuration menu you can set the nebulae color and preview the background picture.
- Now it use Xplanet (xplanet.sourceforge.net) to display the planet image on Linux.
- Plus a lot of bug fix the previous version was filled with.