doc/groovy/PlotFeatures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section goes over the steps required to create a plot, configure it, and add data and graphics to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Title and Axis Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Plot(title: \"We Will Control the Title\", xLabel: \"Horizontal\", yLabel: \"Vertical\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are multiple ways\n",
    "to specify the points of the line using Groovy. All the following lines achieve\n",
    "the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// just provide lists of x's and y's\n",
    "new Plot().add(new Line(x: [0, 1, 2, 3, 4, 5], y: [0, 1, 6, 5, 2, 8]))\n",
    "\n",
    "// Groovy range works\n",
    "new Plot().add(new Line(x: (0..5), y: [0, 1, 6, 5, 2, 8]))\n",
    "\n",
    "// use '<<' left-shift to save some key strokes\n",
    "new Plot() << new Line(x: (0..5), y: [0, 1, 6, 5, 2, 8])\n",
    "\n",
    "// the constructor of class Line is overloaded to take 1 or 2 lists\n",
    "// if an Line was returned, and empty plot is automatically generated\n",
    "new Line((0..5), [0, 1, 6, 5, 2, 8])\n",
    "                        \n",
    "// if x is not provided, a default list of x values (0..5) will be used\n",
    "new Line([0, 1, 6, 5, 2, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may change the\n",
    "rendering properties of the lines, by specifying the corresponding parameters. E.g.\n",
    "width, color, style, interpolation, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot(title: \"Setting line properties\")\n",
    "def ys = [0, 1, 6, 5, 2, 8]\n",
    "def ys2 = [0, 2, 7, 6, 3, 8]\n",
    "plot << new Line(y: ys, width: 10, color: Color.red)\n",
    "plot << new Line(y: ys, width: 3, color: Color.yellow)\n",
    "plot << new Line(y: ys, width: 4, color: new Color(33, 87, 141), style: StrokeType.DASH, interpolation: 0)\n",
    "plot << new Line(y: ys2, width: 2, color: new Color(212, 57, 59), style: StrokeType.DOT)\n",
    "plot << new Line(y: [5, 0], x: [0, 5], style: StrokeType.LONGDASH)\n",
    "plot << new Line(y: [4, 0], x: [0, 5], style: StrokeType.DASHDOT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stems are vertical line\n",
    "segments. All the rendering properties for lines apply to stems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot();\n",
    "def y1 = [1.5, 1, 6, 5, 2, 8]\n",
    "def cs = [Color.black, Color.red, Color.gray, Color.green, Color.blue, Color.pink]\n",
    "def ss = [StrokeType.SOLID, StrokeType.SOLID, StrokeType.DASH, StrokeType.DOT, StrokeType.DASHDOT, StrokeType.LONGDASH]\n",
    "plot << new Stems(y: y1, color: cs, style: ss, width: 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Draw points at the top /\n",
    "bottom of stems to make stem bases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot(title: \"Setting the base of Stems\")\n",
    "def ys = [3, 5, 2, 3, 7]\n",
    "def y2s = [2.5, -1.0, 3.5, 2.0, 3.0]\n",
    "plot << new Stems(y: ys, width: 2, base: y2s)\n",
    "plot << new Points(y: ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can set the width and color of the bars. You can set the color property for each single bar element using a list\n",
    "Bar colors are fill colors, To change the outline color, use *outlineColor*.\n",
    "Bar width is in terms of the data domain.\n",
    "\n",
    "For Bar Charts, see the other tutorial on Category Plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot(title: \"Bars\")\n",
    "def cs = [new Color(255, 0, 0, 128)] * 5 // transparent bars\n",
    "cs[3] = Color.red // set color of a single bar, solid colored bar\n",
    "plot << new Bars(x: (1..5), y: [3, 5, 2, 3, 7], color: cs, outlineColor: Color.black, width: 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the size and shape of points. Points also support *outlineColor*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shapes = [ShapeType.SQUARE,\n",
    "              ShapeType.CIRCLE,\n",
    "              ShapeType.TRIANGLE,\n",
    "              ShapeType.DOWNTRIANGLE,\n",
    "              ShapeType.DIAMOND,\n",
    "              ShapeType.LEVEL,\n",
    "              ShapeType.VLEVEL,\n",
    "              ShapeType.LINECROSS,\n",
    "              ShapeType.CROSS,\n",
    "              ShapeType.DCROSS]\n",
    "\n",
    "def plot = new Plot(title: \"Point Shapes\")\n",
    "def y = [6, 7, 12, 11, 8, 14]\n",
    "shapes.each {\n",
    "    plot << new Points(y: y, size: 20, shape: it)\n",
    "    y = y.collect { it - 2 }\n",
    "}\n",
    "plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot(title: \"Changing Point Size, Color\")\n",
    "def y1 = [6, 7, 12, 11, 8, 14]\n",
    "def y2 = y1.collect { it - 2 }\n",
    "def y3 = y2.collect { it - 2 }\n",
    "def y4 = y3.collect { it - 2 }\n",
    "plot << new Points(y: y1)\n",
    "plot << new Points(y: y2, size: 10, color: Color.black)\n",
    "plot << new Points(y: y3, size: 15, color: Color.orange, outlineColor: Color.black)\n",
    "plot << new Points(y: y4, size: 20, outlineColor: Color.red, fill: false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also set point properties using lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot(title: \"Changing point properties with list\", yBound:[1.5, 5.5])\n",
    "def cs = [Color.black, Color.red, Color.orange, Color.green, Color.blue, Color.pink]\n",
    "def ss = [6.0, 9.0, 12.0, 15.0, 18.0, 21.0]\n",
    "def fs = [false, false, false, true, false, false]\n",
    "plot << [new Points(y: [5] * 6, size: 12.0, color: cs),\n",
    "         new Points(y: [4] * 6, size: 12.0, color: Color.gray, outlineColor: cs),\n",
    "         new Points(y: [3] * 6, size: ss, color: Color.red),\n",
    "         new Points(y: [2] * 6, size: 12.0, color: Color.black, fill: fs, outlineColor: Color.black)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Areas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot()\n",
    "def y = [3, 5, 2, 3]\n",
    "def x0 = [0, 1, 2, 3]\n",
    "def x1 = [3, 4, 5, 8]\n",
    "plot << new Area(x: x0, y: y)\n",
    "plot << new Area(x: x1, y: y, color: new Color(128, 128, 128, 50), interpolation: 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also set bases for the areas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def p = new Plot()\n",
    "p << new Line(y: [3, 6, 12, 24], displayName: \"Median\")\n",
    "p << new Area(y: [4, 8, 16, 32], base: [2, 4, 8, 16],\n",
    "              color: new Color(255, 0, 0, 50), displayName: \"Q1 to Q3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine plot items that have a base property (Bars, Stems, Area)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def y1 = [1,5,3,2,3]\n",
    "def y2 = [7,2,4,1,3]\n",
    "def p = new Plot(title: 'Plot with XYStacker', initHeight: 200)\n",
    "def a1 = new Area(y: y1, displayName: 'y1')\n",
    "def a2 = new Area(y: y2, displayName: 'y2')\n",
    "p << XYStacker.stack([a1, a2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constant Lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def p = new Plot ()\n",
    "p << new Line(y: [-1, 1])\n",
    "p << new ConstantLine(x: 0.65, style: StrokeType.DOT, color: Color.blue)\n",
    "p << new ConstantLine(y: 0.1, style: StrokeType.DASHDOT, color: Color.blue)\n",
    "p << new ConstantLine(x: 0.3, y: 0.4, color: Color.gray, width: 5, showLabel: true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constant Bands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Plot() << new Line(y: [-3, 1, 3, 4, 5]) << new ConstantBand(x: [1, 2], y: [1, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change bands colors and use Infinity for values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def p = new Plot() \n",
    "p << new Line(x: [-3, 1, 2, 4, 5], y: [4, 2, 6, 1, 5])\n",
    "p << new ConstantBand(x: [Double.NEGATIVE_INFINITY, 1], color: new Color(128, 128, 128, 50))\n",
    "p << new ConstantBand(x: [1, 2])\n",
    "p << new ConstantBand(x: [4, Double.POSITIVE_INFINITY])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot()\n",
    "def xs = (1..10)\n",
    "def ys = [8.6, 6.1, 7.4, 2.5, 0.4, 0.0, 0.5, 1.7, 8.4, 1]\n",
    "def label = { i ->\n",
    "  if (ys[i] > ys[i+1] && ys[i] > ys[i-1]) return \"max\"\n",
    "  if (ys[i] < ys[i+1] && ys[i] < ys[i-1]) return \"min\"\n",
    "  if (ys[i] > ys[i-1]) return \"rising\"\n",
    "  if (ys[i] < ys[i-1]) return \"falling\"\n",
    "  return \"\"\n",
    "}\n",
    "for (i = 0; i < xs.size(); i++) {\n",
    "  if (i > 0 && i < xs.size()-1)\n",
    "    plot << new Text(x: xs[i], y: ys[i], text: label(i),  pointerAngle: -i/3.0)\n",
    "}\n",
    "plot << new Line(x: xs, y: ys)\n",
    "plot << new Points(x: xs, y: ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Legend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ToolTip ##\n",
    "\n",
    "The Beaker Plot includes tool tips. Hover the changing points of the line or the bars to see them in the\n",
    "plot below.\n",
    "\n",
    "You can interact with the tooltips.\n",
    "* Stick a tooltip: Click while a tooltip is visible, and it will remain until you close it by clicking the X.\n",
    "* Click and drag a tooltip to increase its visibility.\n",
    "* When you zoom and pan, the tooltip will try to keep its place within the plot when you later navigate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Legend box ##\n",
    "The Beaker Plots include a legend box by default. You may drag the legend box around just as you drag the tool tips.\n",
    "\n",
    "The legend box includes\n",
    "the control panel features that allow you to show / hide data groups by\n",
    "toggling the checkboxes. You may turn off this feature by using an “omitCheckboxes” property (in this case there would be no checkbox to show / hide data).\n",
    "\n",
    "Use “displayName” to show the data’s legend. The legend will automatically appear when a “displayName”\n",
    "property presents. However, you my turn the legend off explicitly by setting “showLegend”.\n",
    "\n",
    "If you do not specify\n",
    "the “displayName” property, or the “displayName” is an empty string, the data\n",
    "will not appear in the legend box.\n",
    "\n",
    "By default the legend is placed in the top-right corner. To change its position you can specify a “legendPosition” property. You can use predefined values (TOP, TOP_LEFT, etc..) or provide an array of coordinates (x, y).\n",
    "\n",
    "Also you can change legend’s layout to horizontal by setting a “legendLayout” property."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cursor hint ##\n",
    "\n",
    "The cursor hint allows\n",
    "you to quickly identify the x / y values of the mouse location.Use “crosshair” property\n",
    "to enable the cursor hint. \n",
    "\n",
    "The Crosshair object has properties similar to a\n",
    "Line, including color, width and style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TRY IT NOW! ##\n",
    "\n",
    "Now it would be a good\n",
    "time for you to try the above interactions in the following demo plot. Make sure you try out\n",
    "the following things:\n",
    "\n",
    "* Click a line point / bar to stick its tool tip.\n",
    "* Drag a tool tip around.\n",
    "* Show / hide the line or the bar group using the legend box\n",
    "* Change the legend box layout to horizontal and position to top-left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ch = new Crosshair(color: new Color(255, 128, 5), width: 2, style: StrokeType.DOT)\n",
    "pp = new Plot(crosshair: ch, omitCheckboxes: true,\n",
    "                  legendLayout: LegendLayout.HORIZONTAL, legendPosition: LegendPosition.TOP)\n",
    "def x = [1, 4, 6, 8, 10]\n",
    "def y = [3, 6, 4, 5, 9]\n",
    "pp << new Line(displayName: \"Line\", x: x, y: y, width: 3)\n",
    "pp << new Bars(displayName: \"Bar\", x: (1..10), y: [2, 2, 4, 4, 2, 2, 0, 2, 2, 4], width: 0.5)\n",
    "pp << new Points(x: x, y: y, size: 10, toolTip: {xs, ys -> \"x = \" + xs + \", y = \" + ys })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.setLegendPosition(LegendPosition.RIGHT);\n",
    "OutputCell.HIDDEN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import com.twosigma.beakerx.fileloader.CSV\n",
    "rates = new CSV().read(\"../resources/data/interest-rates.csv\")\n",
    "def size = rates.size()\n",
    "(0 ..< size).each{row = rates[it]; row.spread = row.y10 - row.m3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Time Plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using SimpleTimePlot you can create a time plot based on the complex table data.\n",
    "To do this just specify table and table column names for plot, like in the\n",
    "example at the top of this notebook.\n",
    "\n",
    "Data for time axis is taken from 'time' column. To change this behavior use 'timeColumn' parameter.\n",
    "\n",
    "By default lines are used to draw the plot, but you can also add points using the parameter 'displayPoints'.\n",
    "The 'displayNames' property give sthe names of the lines, as displayedin the legend.\n",
    "To specify custom colors use the 'colors' parameter, and give it a list with colors in\n",
    "a variety of formats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new SimpleTimePlot(rates, [\"y1\", \"y10\"], // column names\n",
    "                   timeColumn : \"time\", // time is default value for a timeColumn\n",
    "                   yLabel: \"Price\", \n",
    "                   displayNames: [\"1 Year\", \"10 Year\"],\n",
    "                   colors : [[216, 154, 54], '#aabbcc'],\n",
    "                   displayLines: false, // no lines (true by default)\n",
    "                   displayPoints: true) // show points (false by default))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second Y Axis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot can have two y-axes. Just add a `YAxis` to the plot object, and specify its label.\n",
    "Then for data that should be scaled according to this second axis,\n",
    "specify the property `yAxis` with a value that coincides with the label given.\n",
    "You can use `upperMargin` and `lowerMargin` to restrict the range of the data leaving more white, perhaps for the data on the other axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def p = new TimePlot(xLabel: \"Time\", yLabel: \"Interest Rates\")\n",
    "p << new YAxis(label: \"Spread\", upperMargin: 4)\n",
    "p << new Area(x: rates.time, y: rates.spread, displayName: \"Spread\",\n",
    "              yAxis: \"Spread\", color: new Color(180, 50, 50, 128))\n",
    "p << new Line(x: rates.time, y: rates.m3, displayName: \"3 Month\")\n",
    "p << new Line(x: rates.time, y: rates.y10, displayName: \"10 Year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logarithmic Scale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plots support log scale for both axes, independently.\n",
    "To add log scale you need to specify set the logX (for x-axis) or logY (for y-axis) property to true.\n",
    "By default a base 10 is used. To change this, use properties xLogBase and yLogBase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def points = 100;\n",
    "def logBase = 10;\n",
    "def expys = [];\n",
    "def xs = [];\n",
    "for(int i = 0; i < points; i++){\n",
    "  xs[i] = i / 15.0;\n",
    "  expys[i] = Math.exp(xs[i]); \n",
    "}\n",
    "\n",
    "def cplot = new CombinedPlot(xLabel: \"Linear\");\n",
    "def logYPlot = new Plot(title: \"Linear x, Log y\", yLabel: \"Log\", logY: true, yLogBase: logBase);\n",
    "logYPlot << new Line(x: xs, y: expys, displayName: \"f(x) = exp(x)\");\n",
    "logYPlot << new Line(x: xs, y: xs, displayName: \"g(x) = x\");\n",
    "cplot.add(logYPlot, 3);\n",
    "\n",
    "// works for 2nd Y axis too:\n",
    "// logYPlot << new YAxis(label: \"Right Log Y-Axis\", log: true, logBase: logBase);\n",
    "\n",
    "def linearYPlot = new Plot(title: \"Linear x, Linear y\", yLabel: \"Linear\");\n",
    "linearYPlot << new Line(x: xs, y: expys, displayName: \"f(x) = exp(x)\");\n",
    "linearYPlot << new Line(x: xs, y: xs, displayName: \"g(x) = x\");\n",
    "cplot.add(linearYPlot, 3);\n",
    "\n",
    "cplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def points = 100;\n",
    "def logBase = 10;\n",
    "def expys = [];\n",
    "def xs = [];\n",
    "for(int i = 0; i < points; i++){\n",
    "  xs[i] = i /15\n",
    "  expys[i] = Math.exp(xs[i]);\n",
    "}\n",
    "\n",
    "def plot = new Plot(title: \"Log x, Log y\", xLabel: \"Log\", yLabel: \"Log\",\n",
    "                    logX: true, xLogBase: logBase, logY: true, yLogBase: logBase);\n",
    "\n",
    "plot << new Line(x: xs, y: expys, displayName: \"f(x) = exp(x)\");\n",
    "plot << new Line(x: xs, y: xs, displayName: \"f(x) = x\");\n",
    "\n",
    "plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Date Objects for the Time Coordinate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For Time plots you can provide x coordinate as:\n",
    "\n",
    "* a list of numbers (milliseconds), or\n",
    "* a list of java.util.Date objects, or\n",
    "* a list of java.util.Calendar objects, or\n",
    "* a list of java.time.Instant objects, or\n",
    "* a list of java.time.LocalDateTime objects, or\n",
    "* a list of java.time.LocalTime objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal = Calendar.getInstance();\n",
    "cal.add(Calendar.HOUR, -1)\n",
    "\n",
    "def today = new Date();\n",
    "def millis = today.time;\n",
    "def hour = 1000 * 60 * 60;\n",
    "\n",
    "def plot = new TimePlot(\n",
    "  timeZone: new SimpleTimeZone(10800000, \"America/New_York\")\n",
    ");\n",
    "//list of milliseconds\n",
    "plot << new Points(x:(0..10).collect{millis + hour * it}, y:(0..10), size: 10, displayName: \"milliseconds\");\n",
    "//list of java.util.Date objects\n",
    "plot << new Points(x:(0..10).collect{cal.add(Calendar.HOUR, 1); cal.getTime()}, y:(0..10), size: 4, displayName: \"date objects\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nanosecond Resolution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Handling time with nanosecond resolution is easy in languages like Java and Groovy because they support 64-bit integers.\n",
    "Numbers in JavaScript however are limited to 53 bits. Beaker's plotting library can handle these large numbers, just use the NanoPlot class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def today  = new Date()\n",
    "def millis = today.time\n",
    "def nanos  = millis * 1000 * 1000g // g makes it arbitrary precision\n",
    "def np = new NanoPlot()\n",
    "np << new Points(x:(0..10).collect{nanos + 7 * it}, y:(0..10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Formatting Controls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can remove the tick labels from either or both axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = new Plot(title: \"No Tick Labels\", xTickLabelsVisible: false, yTickLabelsVisible: false)\n",
    "p << new Line([0, 1, 6, 5, 2, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And add arbitrary styles to various elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = new Random()\n",
    "p = new Plot(title: \"Advanced Plot Styling\",\n",
    "         labelStyle: \"font-size:32px; font-weight: bold; font-family: courier; fill: green;\",\n",
    "         gridLineStyle:  \"stroke: purple; stroke-width: 3;\",\n",
    "         titleStyle: \"color: green;\"\n",
    "        )\n",
    "p << new Points(x: (1..1000).collect { r.nextGaussian() * 10.0d },\n",
    "                y: (1..1000).collect { r.nextGaussian() * 20.0d })"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rasters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.nio.file.Files\n",
    "byte[] picture = Files.readAllBytes(new File(\"../resources/img/widgetArch.png\").toPath());\n",
    "def p =  new Plot();\n",
    "// x y width height are coordinates, opacity is a double in 0~1\n",
    "\n",
    "// image can be loaded via bytes, filepath, or url\n",
    "p << new Rasters(x: [-10,3], y: [3,1.5], width: [6,5], height:[10,8], opacity: [1,0.5], dataString: picture);\n",
    "//p << new Rasters(x: -1, y: 4.5, width: 5, height: 8, opacity:0.5, filePath: \"../resources/img/widgetArch.png\");\n",
    "p << new Rasters(x: [-4], y: [10.5], width: [7], height: [2], opacity:[1], fileUrl: \"https://www.twosigma.com/static/img/twosigma.png\");\n",
    "\n",
    "// a list of images!\n",
    "def x = [-8, -5, -3, -2, -1, 1, 2, 4, 6, 8]\n",
    "def y = [4, 5, 1, 2, 0 ,3, 6, 4, 5, 9]\n",
    "def width = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
    "def opacity = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]\n",
    "p << new Rasters(x: x, y: y, width:width, height:width, opacity:opacity,fileUrl: \"http://icons.iconarchive.com/icons/paomedia/small-n-flat/1024/sign-check-icon.png\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot = new Plot(title: \"Setting 2nd Axis bounds\")\n",
    "def ys = [0, 2, 4, 6, 15, 10]\n",
    "def ys2 = [-40, 50, 6, 4, 2, 0]\n",
    "def ys3 = [3, 6, 3, 6, 70, 6]\n",
    "plot << new YAxis(label:\"Spread\")\n",
    "plot << new Line(y: ys)\n",
    "plot << new Line(y: ys2, yAxis: \"Spread\")\n",
    "plot.getYAxes()[0].setBound(1,5);\n",
    "plot.getYAxes()[1].setBound(3,6) // this should change the bounds of the 2nd, right axis\n",
    "plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Line(y: [4, 0], x: [0, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y Axis 0 point auto inclusion\n",
    "You can include `y: 0` point by using yAutoRangeIncludesZero property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Plot(yAutoRangeIncludesZero: true) << new Line(y: [5, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limit  X and Y Bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Plot(xBound: [7, 9], yBound: [6, 9]) << new Line(x: (1..8), y: (1..8)) << new Line(x: (8..10), y: [8, 7, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Plot(xBound: [7, 9]) << new Line(x: (1..8), y: (1..8)) << new Line(x: (8..10), y: [8, 7, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new Plot(yBound: [6, 9]) << new Line(x: (1..8), y: (1..8)) << new Line(x: (8..10), y: [8, 7, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Margins\n",
    "You can add margins to the plot using:\n",
    "\n",
    "- xLowerMargin, \n",
    "- xUpperMargin, \n",
    "- yLowerMargin, \n",
    "- yUpperMargin \n",
    "\n",
    "properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = new Plot(title: \"Margins\", \n",
    "             xLowerMargin: 1, xUpperMargin: 1, \n",
    "             yLowerMargin: 1, yUpperMargin: 1) \n",
    "p << new Line(x: (1..10), y: (5..14))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Groovy",
   "language": "groovy",
   "name": "groovy"
  },
  "language_info": {
   "codemirror_mode": "groovy",
   "file_extension": ".groovy",
   "mimetype": "",
   "name": "Groovy",
   "nbconverter_exporter": "",
   "version": "2.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}