# Difference between revisions of "Advanced Graphing"

Jump to: navigation, search

Some explanatory notes soon.

This is an article about a script to create axes with tick marks, then plot data points to the scale of the graph.

```#!/usr/bin/env python

# File: axes_graphing.py
# originally 2006.05.17 as graph2.py on Scribus wiki
# this version 2010.07.25
# creates graph with axes and plots Y values
# X values are fixed

"""
This script as written assumes a US Letter page in landscape orientation.
The various position and dimension values you see are appropriate for page units
of points. If you prefer other units, there are commands to get your units type, switch
to points, and then at the end back to your preferred units.
No headers are created and even the axis labels are not part of this script.
It was written to plot events over a 24 hour day, so the X axis denotes hours
(i.e., 24 tick points), and the Y axis number of events.

The only user input when the script runs is to specify the range of the Y axis,
and indicate the value of individual tick marks. The reason for not making this
automatic is that you might wish to have a family of graphs with a range of values
from graph to graph, yet keep the same scale.

This having been said, nothing will plot unless the script has values for the yvalue list.
Some arbitrary values are shown below.
With a bit more work, you might load these values from a file or value dialog(s).
If all you wanted to do was to update a graph, then you could add control commands to
skip making axes, but note the importance of creating the X values, which happens
when the X axis ticks are created.
There is also virtually no error detection, or at least no messages other than
the traceback that will show up.

"""

import scribus

xorigin = 64      # x-origin of graph
yorigin = 536     # y-origin of graph
xaxis=637         #x axis length
yaxis=408         #y axis length
color="Black"
a = 1.5 # width of lines
l = 2.0 # width of the plotted line
t = 0.8 # width of scale markers
xvalue = []
yvalue = [1,1,4,2,1,0,1,1,4,1,7,2,3,4,4,2,7,5,5,5,5,4,3,2] # graph points
polyvalue = []
if scribus.haveDoc():
xtick = xorigin
xscale = xaxis/24     # this gives you typographic points per X data unit
yrange = int(scribus.valueDialog('Maximum Y Scale', 'Enter Top Y Value\n(Scale)'))
ymark = int(scribus.valueDialog('Tick Mark Interval', 'Enter Y Interval for Tick Marks'))
ytick = yorigin
yscale = yaxis/yrange # this gives you typographic points per Y data unit
scribus.setRedraw(1)
scribus.setUnit(0)
d = scribus.createLine(xorigin,yorigin,xorigin+xaxis,yorigin) # create X axis
scribus.setLineWidth(a, d)
scribus.setLineColor(color, d)
scribus.setFillColor(color, d)
e = scribus.createLine(xorigin,yorigin,xorigin,yorigin-yaxis) # create Y axis
scribus.setLineWidth(a, e)
scribus.setLineColor(color, e)
scribus.setFillColor(color, e)
ytick = ytick - ymark * yscale
nticks = 0
item = 0
while (nticks < 24):
xtick = xtick + xscale
xvalue.append(xtick)
xt = scribus.createLine(xtick, yorigin, xtick, yorigin + 5) # creating X axis tick lines
scribus.setLineWidth(t, xt)
scribus.setLineColor(color, xt)
scribus.setFillColor(color, xt)
nticks += 1
while (ytick > (yorigin - yaxis)):
yt = scribus.createLine(xorigin, ytick, xorigin - 5, ytick) # creating Y axis tick lines
scribus.setLineWidth(t, yt)
scribus.setLineColor(color, yt)
scribus.setFillColor(color, yt)
ytick = ytick - ymark * yscale
while (item < 24): # this interleaves the X and Y data for createPolyLine
polyvalue.append(xvalue[item])
polyvalue.append((yorigin - yvalue[item] * yscale))
item += 1
poly = scribus.createPolyLine(polyvalue) # this is the actual plotting
scribus.setLineWidth(l, poly)
scribus.setLineColor(color, poly)
scribus.setFillColor("None",poly)

scribus.redrawAll()
```