View source for DMelt:Plots/3 Custom Plots



{{sidebar box|[[DMelt:Start|Table of contents]]}}


== Custom plots in 2D ==

You can create fully custom plots with arbitrary layouts by writing Jython and Java code and accessing internal methods.
First, let us consider a simple plots based on the class <javadoc sc>jhplot.HPlotXY</javadoc>. 
Using the method "getPlot()" of this class one can return a plot object of the <javadoc sc>org/jplot2d/element/Plot|Plot</javadoc> class that can be changed using an arbitrary layout. Let us consider a simple example:


<jcode lang="python">
dmelt 67018985.py
</jcode>

The output plots is:

<jput>
image 67018985
</jput>

You can see that <javadoc sc>jhplot.HPlotXY</javadoc> is very similar to  <javadoc sc>jhplot.HPlot</javadoc>. However, it has several features that can help to build non-standard layouts. 


In order to access all such plotting zones, you can look at the following methods:

<jcode lang="python">
c1=HPlotXY("Cosmology",600,700,0)
c1.visible()
ef=c1.getFactory()
plot=c1.getPlot()
env=c1.Env()
</jcode>

The function "getFactory()" returns class, while getPlot() returns the actual plotting area. Look at the API of these
classes:

* <javadoc sc>org.jplot2d.element.ElementFactory</javadoc>
* <javadoc sc>org.jplot2d.env.RenderEnvironment</javadoc>
* <javadoc sc>org.jplot2d.element.Plot</javadoc>

The <javadoc sc>org/jplot2d/element/ElementFactory|ElementFactory</javadoc> class cab be used to create axis, titles, legends and subplots.
In order to export plots to one of the vector-graphics formats supported by dmelt, use the usual method:

<jcode lang="python">
c1.export("image.svg") 
</jcode>
(change the extension to use different file format).


Now let us build an example that shows a plot with two subplots, custom title and data points with the legends.

<ifauth !@member>
<jcode lang="python">
dmelt 52809209.py
</jcode>

The original package used to make this code is called "jplot2d" and the description of the most essential methods is give here
[https://code.google.com/p/jplot2d/wiki/Overview?tm=6 jplot2d wiki].
</ifauth>

The output image created by the above  code is:

<jput>
image 52809209
</jput>


= Building titles =

After you create the "plot" object of the class 
<javadoc sc>org.jplot2d.element.Plot</javadoc> and "ef" factory object using 
<javadoc sc>org.jplot2d.element.ElementFactory</javadoc> class, you can add a title as:

<jcode lang="python">
from org.jplot2d.element import *
title = ef.createTitle("Custom Title")
title.setFontScale(2)
plot.addTitle(title)
</jcode>
The "title" object belongs to <javadoc sc>org.jplot2d.element.Title</javadoc> class.

You can use TeX-like formatting of strings in plots. Entering math mode using a "dollar" symbol it is possible to insert Greek characters, for instance using 

<jcode lang="python">
\\alpha - greek alpha 
\\beta  - greek beta
</jcode>

<jcode lang="python">
{| class="wikitable sortable" border=1
!  # superscript symbol 
|-
|}
_  # subscript symbol
</jcode>

Here is how to show math:
<jcode lang="python">
text="$A_{1.3}^{b-3/2}$"
text="$\\alpha_{1.3}^{\\beta-3/2}$"
</jcode>

The following special symbols are available:

*  All the lower-case Greek letters.
*  The following upper-case Greek letters: \Gamma, \Delta, \Theta, \Lambda, \Xi, \Pi, \Sigma, \Upsilon, \Phi, \Psi, \Omega .
*  The \angstrom and \micro symbols.

To insert other symbols you can use the Unicode escape sequence \uxxxx , where xxxx is the hexadecimal code of the symbol. For example, \u2299 corresponds to the circle dot operator, which can also be used as symbol for the Sun.  Use [http://www.utf8-chartable.de/] table to look at how to map unicode characters.

= Creating  Axes =

To create axised for X and Y, use "createAxis" method of 
"ef" factory object of
<javadoc sc>org.jplot2d.element.ElementFactory</javadoc> class

<jcode lang="python">
xaxis = ef.createAxis();
yaxis = ef.createAxis();
# setting an axis transform to LOGARITHMIC
xaxis.getTickManager().getAxisTransform().setTransform(TransformType.LOGARITHMIC);
</jcode>
The objects "xaxis" and "yaxis" belong to <javadoc sc>org.jplot2d.element.Axis|Axis</javadoc> class.
To add an axis to the plot, use these methds:

<jcode lang="python">
plot.addXAxis(xaxis)
plot.addYAxis(yaxis)
</jcode>

You may want 2 x-axes and 2 y-axes to box the plot contents. In this case, 2 x-axes or y-axes can be created and added together. The created 2 x-axes share the same tickManager. And so the 2 y-axes.

<jcode lang="python">
xaxes = ef.createAxes(2)
yaxes = ef.createAxes(2)
# setting an axis transform to LOGARITHMIC
xaxes[0].getTickManager().getAxisTransform().setTransform(TransformType.LOGARITHMIC);
plot.addXAxes(xaxes) # add them to the plot
plot.addYAxes(yaxes)
</jcode>


Let us show  how  to make titles, subtitles and axes in this example:

<ifauth !@member>
<jcode lang="python">
dmelt 45425594.py
</jcode>
</ifauth>


The resulting plot is:

<jput>
image 45425594
</jput>

= Creating  layers =
A layer can associate with a x-axis and a y-axis, i.e. it is associated with a x AxisTransform and a y AxisTrasform. When adding a layer to a plot, the associated x AxisTransform and y AxisTrasform must be given as arguments, and they must already exist in the plot (by adding the x axis and y axis object). 

<jcode lang="python">
layer = ef.createLayer();
# The xaxis and yaxis must has been added to the plot
plot.addLayer(layer, xaxis.getTickManager().getAxisTransform(), yaxis.getTickManager().getAxisTransform())
</jcode>

The "layer" object belongs to the  <javadoc sc>org.jplot2d.element.Layer</javadoc> class.
You can extract layers from the plots as:

<jcode lang="python">
layers = plot.getLayers()
</jcode>

= Creating Graphs =

A 2d graph can be created with 2 double array

<jcode lang="python">
from array import *
x = array('d',[0,1,2,3])
y = array('d',[0,2,1,4])
graph = ef.createXYGraph(x, y)
layer.addGraph(graph)  # add this graph to layer
</jcode>

Similarly, your code in Java will look as:
<jcode lang="java">
double[] x = new double[] {0,1,2,3};
double[] y = new double[] {0,2,1,4};
XYGraph graph = ef.createXYGraph(x, y);
layer.addGraph(graph)  # add this graph to layer
</jcode>
The "layer" object belongs to the  <javadoc sc>org.jplot2d.element.XYGraph</javadoc> class.
You can customize the graph using the methods:

<jcode lang="python">
graph.setColor(Color.GREEN);
graph.setLineVisible(False);
graph.setSymbolVisible(True);
graph.setSymbolShape(SymbolShape.SQUARE);
</jcode>
Look at the <javadoc sc>org.jplot2d.element.XYGraph</javadoc> class.



See the <javadoc sc>org.jplot2d.util.SymbolShape</javadoc> class.

Data points can have errors bars in X and Y. Create a XYGraph with the given x/y array, x low/high error array and y low/high error array, use this method:

<jcode lang="python">
graph=ef.createXYGraph(x_array, y_array, xErrorLow, xErrorHigh, yErrorLow, yErrorHigh, name)
</jcode>

= Creating Annotations =


There are several kind of annotations can be created

# symbol annotation A point annotation with a symbol and a text string
# horizontal line annotation A horizontal line annotation to highlight a value.
# vertical line annotation A vertical line annotation to highlight a value.
# horizontal strip annotation A horizontal strip annotation to highlight a range.
# vertical strip annotation A vertical strip annotation to highlight a range.
# rectangle annotation A rectangle annotation to highlight a area. 
 
The "annotations" objects belong to the  <javadoc sc>org.jplot2d.element.Annotation</javadoc> class.
Look at how the annotations can be made:
<jcode lang="python">
ann0 = ef.createSymbolAnnotation(x, y, "text annotation") # symbol annotation
ann1 = ef.createHLineAnnotation(y)       #  horizontal line annotation
ann2 = ef.createHStripAnnotation(y1, y2) #  horizontal strip annotation
layer.addAnnotation(annotation) # Adding an annotation to a layer
</jcode>

[[Category:Plots]]
[[Category:Statistical charts and diagrams]]