An simple graph can help you visualize complex data and be a very useful tool in presentations and reports. The plotutils package [1] brings together a group of programs that all access the functions of GNU Libplot.

This library produces device-agnostic vector graphics and even animations in various output formats. There are bindings for C and C++ among other library classes. And, because of the effective interface programs for the shell, in most cases, you don't need to program anything – it's often enough to invoke a smartly crafted command line.

Installing Plotutils

The plotutils package is found in the major distribution repositories so that it can be set up easily with the corresponding package manager. In Ubuntu, you can just use the apt-get install plotutils command with administrative rights. This step pulls in all the necessary dependencies.

You select the desired output format (Table 1) with the -T option as an argument to the command, such as graph -T X … , where plotutils accepts multiple instances of -T . You just need to supply a suitable output redirection:

$ graph -T X -T PNG ... > output.png

Several programs are used for graphics output. The main one is the graph program seen in the previous example. Using --help , you can display all the available options, which are surprisingly clear (see Table 2).

The "plots" created with plotutils consist of the plotted curve, the X and Y axis with their labels, and other possible elements such as a plot title and background grid.

Graph accepts binary and plaintext files, with the latter being significantly easier to handle in that you can easily create and modify them in a text editor. You can use additional Graph options to interpret the input data (Table 3).

In creating the command lines, pay particular attention to the order of options and arguments. The options control the presentation of the data values that follow. Apart from the command-line options, Graph provides a set of environmental variables, which the plotutils programs use as options. However, the command-line options override the environmental variables.

Line by Line

Graph reads the input data from a file or standard in. The program expects the data as simple space-separated X/Y value pairs, one for each measurement. Listing 1 shows an example. Note the use of options as comments at the beginning, which can also occur in the data and determine how the data that follows is represented.

#m=5,S=10
1422968301  140736
[...]
11422973527  137436

Alternatively the input can occur in one piece instead of line by line, such as when reading from standard in, as in the following example:

$ echo 1 1 2 2 3 1 1 1| graph -TX

Graph reads in the values as coordinate pairs. You can also use the -a option to specify reading in the values as Y axis values only – more on this later.

Another interpretation results when you use the -I e option to include error bars in output, which are common in normal measurements. In this case, Graph expects data triplets (x y <error> ), unless you enable -a again.

You should first test the data output in an X window (Figure 1). In this case, you can specify X as the output device (graph -T X <data> ) and the program will take care of things automatically. Pressing Q or clicking the window closes it again.

Figure 1: Graph easily and quickly displays output in an X window.

Curves and Lines

If empty lines appear in the input, Graph interprets them as the start of a new plot and displays the plot correspondingly (Figure 2). The program behaves similarly when data is derived from multiple sources (as shown in the first line of the following example). To distinguish the two plots, give the second one a different color using the -C option as shown in the second line below:

$ graph -TX /tmp/tst /tmp/tst1
$ graph -TX -C /tmp/tst2 /tmp/tst3

See Figures 3 and 4 for examples.

Figure 2: Multiple plot curves are distinguished by different line types, even when they don't overlap.

Figure 3: The -C option adds color to plot curves.

Figure 4: The -S marks plots with data point symbols, even if the plot line is hidden (-m0).

Axis and Surfaces

The -a option automatically labels the X axis and can process data with just Y-axis values. This helps when there are constant values or only one coordinate indicated. An example is described in the "Problems with Date Representation" box. The -a option increments the X value for each given Y value. You can add arguments or (if values are missing) let Graph calculate it for you. The two arguments you can set for -a are the first one for the X-axis increment and the second for its lower limit value, as in the example … -a 100 10 … .

Also interesting is the -q option, whereby Graph fills the polygon formed by the plot line segments with varying shading – with 0.5 halfway between solid and white, as in the following command that generates the plot shown in Figure 5.

$ echo 10 5  5 15  15 15  10 5 | graph -TX -q 0.5

Figure 5: The -q option creates variously shaded surfaces in the plots.

To create a closed surface, the starting and ending plot values have to be identical. The -q argument sets the density of the fill shading, with higher values creating darker shading. Using the -C adds color to the shading. A bit more complicated is filling open curves using -q . In this case, Graph adds a virtual line from the starting and ending points of the curve as the base for the filled surface (Figure 6).

Figure 6: The fill function applies to curves as well, which are closed automatically with a virtual line from start to end point.

On Axis

The axes and their labels are important plotting elements, and several options control them. The -E option can make Graph draw the axes on the right or top instead of the usual left and bottom. Using -N <axis> , you can deactivate the usual ticks and their labels for the X or Y axis. In this case, or later, you can relabel each axis with the -X <label> and -Y <label> options (Figure 7).

Figure 7: You can easily activate and deactivate axis labels.

By default, Graph adds ticks to each axis relative to its origin. Using the -x or -y option, you can be more specific about tick spacing along the axis with the arguments lower_limit , upper_limit , and spacing . If a value is missing or you enter a minus sign, Graph automatically calculates the values from the data. The additional -R <axis> argument tells Graph to round the values to the nearest integer.

More Room

Among Graph's special features is its ability to scale an axis logarithmically. You do this with the -l <axis> option, and you can also add a background grid to help orientation (Figure 8).

Figure 8: Logarithmic scales and grids help represent data.

If the display size isn't big enough, you can use the --bitmap-size option to set a new size. The option takes the <width>x<height> pixels syntax. You can also set the fonts with the -F option and their size with -f . Graph expects a relative value for the size, such as -f .01 , based on the minimum dimension of the plotting box.

Further Possibilities

Apart from the Graph program, plotutils provides other useful programs. Among the options are Plot , a universal converter for Graph output; Pic2plot , which translates Pic drawings, Plotfont for displaying character maps of fonts; and Spline for "smoothing" data. Additional exotic programs can be used for more specialized tasks.

Spline reads data either from standard input or from a file, processes it, and then writes it out as a data stream in the standard output channel. The data can then be fished out for Graph processing:

$ spline input_data | graph -TX ...

In Figure 9, you can see the example of a curve that was "smoothed" by Spline and output to Graph.

Figure 9: Data "smoothed" by Spline.

Conclusion

Viewing numerical data as graphs using plotutils is a pleasure – provided the data is in a reasonable format and can be quickly converted. Because of X mode, you don't need to generate an output file, and automatically closing the output window with a mouse click proves ideal for this purpose.

If you want cleanly created graphs for presentations or other purposes, you should definitely consider generating SVG output and then editing it with Inkscape. The original documentation [2] for plotutils reveals many more details.