diff --git a/examples/contours.ipynb b/examples/contours.ipynb new file mode 100644 index 00000000..10410f26 --- /dev/null +++ b/examples/contours.ipynb @@ -0,0 +1,3492 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "using Plots\n", + "x = [\"x1\", \"x2\"]\n", + "y = [0.2, 0.7]\n", + "bar(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0.0\n", + " 2.5\n", + " 5.0\n", + " 7.5\n", + " 10.0\n", + " \n", + " \n", + " \n", + " y1\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0.00\n", + " 0.25\n", + " 0.50\n", + " 0.75\n", + " 1.00\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 50\n", + " 100\n", + " \n", + " \n", + " \n", + " y1\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " 0.5\n", + " 1.0\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " -12.5\n", + " -10.0\n", + " -7.5\n", + " -5.0\n", + " -2.5\n", + " 0.0\n", + " 2.5\n", + " 5.0\n", + " 7.5\n", + " 10.0\n", + " 12.5\n", + " 15.0\n", + " 17.5\n", + " 20.0\n", + " 22.5\n", + " -10.0\n", + " -9.5\n", + " -9.0\n", + " -8.5\n", + " -8.0\n", + " -7.5\n", + " -7.0\n", + " -6.5\n", + " -6.0\n", + " -5.5\n", + " -5.0\n", + " -4.5\n", + " -4.0\n", + " -3.5\n", + " -3.0\n", + " -2.5\n", + " -2.0\n", + " -1.5\n", + " -1.0\n", + " -0.5\n", + " 0.0\n", + " 0.5\n", + " 1.0\n", + " 1.5\n", + " 2.0\n", + " 2.5\n", + " 3.0\n", + " 3.5\n", + " 4.0\n", + " 4.5\n", + " 5.0\n", + " 5.5\n", + " 6.0\n", + " 6.5\n", + " 7.0\n", + " 7.5\n", + " 8.0\n", + " 8.5\n", + " 9.0\n", + " 9.5\n", + " 10.0\n", + " 10.5\n", + " 11.0\n", + " 11.5\n", + " 12.0\n", + " 12.5\n", + " 13.0\n", + " 13.5\n", + " 14.0\n", + " 14.5\n", + " 15.0\n", + " 15.5\n", + " 16.0\n", + " 16.5\n", + " 17.0\n", + " 17.5\n", + " 18.0\n", + " 18.5\n", + " 19.0\n", + " 19.5\n", + " 20.0\n", + " -10\n", + " 0\n", + " 10\n", + " 20\n", + " -10\n", + " -9\n", + " -8\n", + " -7\n", + " -6\n", + " -5\n", + " -4\n", + " -3\n", + " -2\n", + " -1\n", + " 0\n", + " 1\n", + " 2\n", + " 3\n", + " 4\n", + " 5\n", + " 6\n", + " 7\n", + " 8\n", + " 9\n", + " 10\n", + " 11\n", + " 12\n", + " 13\n", + " 14\n", + " 15\n", + " 16\n", + " 17\n", + " 18\n", + " 19\n", + " 20\n", + " \n", + " \n", + " \n", + " y1\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -1.25\n", + " -1.00\n", + " -0.75\n", + " -0.50\n", + " -0.25\n", + " 0.00\n", + " 0.25\n", + " 0.50\n", + " 0.75\n", + " 1.00\n", + " 1.25\n", + " 1.50\n", + " 1.75\n", + " 2.00\n", + " 2.25\n", + " -1.00\n", + " -0.95\n", + " -0.90\n", + " -0.85\n", + " -0.80\n", + " -0.75\n", + " -0.70\n", + " -0.65\n", + " -0.60\n", + " -0.55\n", + " -0.50\n", + " -0.45\n", + " -0.40\n", + " -0.35\n", + " -0.30\n", + " -0.25\n", + " -0.20\n", + " -0.15\n", + " -0.10\n", + " -0.05\n", + " 0.00\n", + " 0.05\n", + " 0.10\n", + " 0.15\n", + " 0.20\n", + " 0.25\n", + " 0.30\n", + " 0.35\n", + " 0.40\n", + " 0.45\n", + " 0.50\n", + " 0.55\n", + " 0.60\n", + " 0.65\n", + " 0.70\n", + " 0.75\n", + " 0.80\n", + " 0.85\n", + " 0.90\n", + " 0.95\n", + " 1.00\n", + " 1.05\n", + " 1.10\n", + " 1.15\n", + " 1.20\n", + " 1.25\n", + " 1.30\n", + " 1.35\n", + " 1.40\n", + " 1.45\n", + " 1.50\n", + " 1.55\n", + " 1.60\n", + " 1.65\n", + " 1.70\n", + " 1.75\n", + " 1.80\n", + " 1.85\n", + " 1.90\n", + " 1.95\n", + " 2.00\n", + " -1\n", + " 0\n", + " 1\n", + " 2\n", + " -1.0\n", + " -0.9\n", + " -0.8\n", + " -0.7\n", + " -0.6\n", + " -0.5\n", + " -0.4\n", + " -0.3\n", + " -0.2\n", + " -0.1\n", + " 0.0\n", + " 0.1\n", + " 0.2\n", + " 0.3\n", + " 0.4\n", + " 0.5\n", + " 0.6\n", + " 0.7\n", + " 0.8\n", + " 0.9\n", + " 1.0\n", + " 1.1\n", + " 1.2\n", + " 1.3\n", + " 1.4\n", + " 1.5\n", + " 1.6\n", + " 1.7\n", + " 1.8\n", + " 1.9\n", + " 2.0\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " -150\n", + " -100\n", + " -50\n", + " 0\n", + " 50\n", + " 100\n", + " 150\n", + " 200\n", + " 250\n", + " -100\n", + " -95\n", + " -90\n", + " -85\n", + " -80\n", + " -75\n", + " -70\n", + " -65\n", + " -60\n", + " -55\n", + " -50\n", + " -45\n", + " -40\n", + " -35\n", + " -30\n", + " -25\n", + " -20\n", + " -15\n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " 15\n", + " 20\n", + " 25\n", + " 30\n", + " 35\n", + " 40\n", + " 45\n", + " 50\n", + " 55\n", + " 60\n", + " 65\n", + " 70\n", + " 75\n", + " 80\n", + " 85\n", + " 90\n", + " 95\n", + " 100\n", + " 105\n", + " 110\n", + " 115\n", + " 120\n", + " 125\n", + " 130\n", + " 135\n", + " 140\n", + " 145\n", + " 150\n", + " 155\n", + " 160\n", + " 165\n", + " 170\n", + " 175\n", + " 180\n", + " 185\n", + " 190\n", + " 195\n", + " 200\n", + " -100\n", + " 0\n", + " 100\n", + " 200\n", + " -100\n", + " -90\n", + " -80\n", + " -70\n", + " -60\n", + " -50\n", + " -40\n", + " -30\n", + " -20\n", + " -10\n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " 60\n", + " 70\n", + " 80\n", + " 90\n", + " 100\n", + " 110\n", + " 120\n", + " 130\n", + " 140\n", + " 150\n", + " 160\n", + " 170\n", + " 180\n", + " 190\n", + " 200\n", + " \n", + " \n", + " \n", + " y1\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " -1.0\n", + " -0.5\n", + " 0.0\n", + " 0.5\n", + " 1.0\n", + " 1.5\n", + " 2.0\n", + " 2.5\n", + " -1.00\n", + " -0.95\n", + " -0.90\n", + " -0.85\n", + " -0.80\n", + " -0.75\n", + " -0.70\n", + " -0.65\n", + " -0.60\n", + " -0.55\n", + " -0.50\n", + " -0.45\n", + " -0.40\n", + " -0.35\n", + " -0.30\n", + " -0.25\n", + " -0.20\n", + " -0.15\n", + " -0.10\n", + " -0.05\n", + " 0.00\n", + " 0.05\n", + " 0.10\n", + " 0.15\n", + " 0.20\n", + " 0.25\n", + " 0.30\n", + " 0.35\n", + " 0.40\n", + " 0.45\n", + " 0.50\n", + " 0.55\n", + " 0.60\n", + " 0.65\n", + " 0.70\n", + " 0.75\n", + " 0.80\n", + " 0.85\n", + " 0.90\n", + " 0.95\n", + " 1.00\n", + " 1.05\n", + " 1.10\n", + " 1.15\n", + " 1.20\n", + " 1.25\n", + " 1.30\n", + " 1.35\n", + " 1.40\n", + " 1.45\n", + " 1.50\n", + " 1.55\n", + " 1.60\n", + " 1.65\n", + " 1.70\n", + " 1.75\n", + " 1.80\n", + " 1.85\n", + " 1.90\n", + " 1.95\n", + " 2.00\n", + " -1\n", + " 0\n", + " 1\n", + " 2\n", + " -1.0\n", + " -0.9\n", + " -0.8\n", + " -0.7\n", + " -0.6\n", + " -0.5\n", + " -0.4\n", + " -0.3\n", + " -0.2\n", + " -0.1\n", + " 0.0\n", + " 0.1\n", + " 0.2\n", + " 0.3\n", + " 0.4\n", + " 0.5\n", + " 0.6\n", + " 0.7\n", + " 0.8\n", + " 0.9\n", + " 1.0\n", + " 1.1\n", + " 1.2\n", + " 1.3\n", + " 1.4\n", + " 1.5\n", + " 1.6\n", + " 1.7\n", + " 1.8\n", + " 1.9\n", + " 2.0\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Int64,Compose.MeasureNil}(0.0,0,Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Int64}(0.0,Compose.MeasureNil(),0,0.0,0.0),Compose.Measure{Int64,Compose.MeasureNil}(0.0,1,Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Int64}(0.0,Compose.MeasureNil(),1,0.0,0.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Form{Compose.RectanglePrimitive{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}([Compose.RectanglePrimitive{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0))],symbol(\"\")),Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.StrokePrimitive}([Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]),Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.FillPrimitive}([Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,1.0,1.0))]),Compose.ListNull{Compose.ComposeNode}()))),-1000000,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(5.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(5.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(-10.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(-10.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.JSIncludePrimitive}([Compose.JSIncludePrimitive(\"/Users/tom/.julia/v0.4/Gadfly/src/gadfly.js\",(\"Gadfly\",\"Gadfly\"))]),Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.SVGClassPrimitive}([Compose.SVGClassPrimitive(\"plotroot xscalable yscalable\")]),Compose.ListNode{Compose.ComposeNode}(Compose.Table(2x3 Array{Array{Compose.Context,1},2}:\n", + " [Context(AdhocContainerPromise)] … [Context(AdhocContainerPromise)]\n", + " [] [] ,2:2,1:1,nothing,nothing,nothing,Any[],Compose.UnitBox{Float64,Float64,Float64,Float64}(0.0,1.0,10.0,-1.0,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),0,false,false),Compose.ListNull{Compose.ComposeNode}()))),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNull{Compose.ComposeNode}())),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNull{Compose.ComposeNode}()),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Float64,Compose.MeasureNil}(0.0,0.6,Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Int64}(0.0,Compose.MeasureNil(),0,0.0,0.0),Compose.Measure{Float64,Compose.MeasureNil}(0.0,0.4,Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Float64}(0.0,Compose.MeasureNil(),0.4,0.0,0.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Form{Compose.RectanglePrimitive{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}([Compose.RectanglePrimitive{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0))],symbol(\"\")),Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.StrokePrimitive}([Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]),Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.FillPrimitive}([Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,1.0,1.0))]),Compose.ListNull{Compose.ComposeNode}()))),-1000000,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNode{Compose.ComposeNode}(Compose.Context(Compose.BoundingBox(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(5.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(5.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(-10.0,Compose.MeasureNil(),Compose.MeasureNil(),1.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(-10.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,1.0)),Compose.UnitBox{Void,Void,Void,Void}(nothing,nothing,nothing,nothing,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Rotation{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}(0.0,Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.5,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(0.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.5))),nothing,Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.JSIncludePrimitive}([Compose.JSIncludePrimitive(\"/Users/tom/.julia/v0.4/Gadfly/src/gadfly.js\",(\"Gadfly\",\"Gadfly\"))]),Compose.ListNode{Compose.ComposeNode}(Compose.Property{Compose.SVGClassPrimitive}([Compose.SVGClassPrimitive(\"plotroot xscalable yscalable\")]),Compose.ListNode{Compose.ComposeNode}(Compose.Table(2x3 Array{Array{Compose.Context,1},2}:\n", + " [Context(AdhocContainerPromise)] … [Context(AdhocContainerPromise)]\n", + " [] [] ,2:2,1:1,nothing,nothing,nothing,Any[],Compose.UnitBox{Float64,Float64,Float64,Float64}(0.0,1.0,100.0,-1.0,Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(2.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),0,false,false),Compose.ListNull{Compose.ComposeNode}()))),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNull{Compose.ComposeNode}())),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNull{Compose.ComposeNode}()),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNull{Compose.ComposeNode}())),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\"))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Plots; using Compose\n", + "p1 = plot(rand(10))\n", + "p2 = scatter(rand(100))\n", + "compose(context(),\n", + " (context(0.6,0,0.4,0.4), Gadfly.render(p2.o[2])),\n", + " (context(0,0,1,1), Gadfly.render(p1.o[2])))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "using Gadfly" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: No packages to install, update or remove\n", + "INFO: Package database updated\n" + ] + } + ], + "source": [ + "Pkg.add(\"Contour\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "using Plots\n", + "import Contour\n", + "default(size=(500,300))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "typeof(cs) = Array{Contour.ContourLevel,1}" + ] + } + ], + "source": [ + "n = 100\n", + "x = sort(randn(n)); y = sort(randn(n))\n", + "cs = Contour.contours(x, y, x * y', 5)\n", + "@show typeof(cs) length(cs)\n", + "#xys = [Contour.coordinates(c.lines) for c in cs]\n", + "for clevel in cs\n", + " @show length(clevel.lines)\n", + " #for (x,y) in Contour.coordinates(clevel.lines[1])\n", + " # @show x y\n", + " #end\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x = [0.996311623950869,1.014779586168885,1.0619429011645203,1.0705643632344357,1.0757346819029472,1.2352537493424733,1.3083367492687343,1.3362429344485531,1.3382013214101371,1.381189378592954,1.387758007376257,1.4330616775674128,1.4330873131641844,1.4802974364117303,1.5983182860133243,1.7395968844958194,1.8898088744099915,1.9983557145685487,2.0028308618853106,2.0112886298409127,2.0289470759898443,2.074888219238593,2.10414834798257,2.1510008635888065,2.2151888265553907,2.241346798167681,2.3299639292951215,2.3944690872276184,2.593030479782728,2.6035782354641266,2.620319713774897,2.6412138619889283,2.69457070468019,2.712098273036215,2.844711254707502,2.9183936196692386]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "Plot{Plots.ImmersePackage() n=1}" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "y = [-1.9760705052937122,-1.9401080205046,-1.8539433824658917,-1.8390132174981266,-1.8301743425134045,-1.5938280011038843,-1.5047976106082777,-1.4733713185043547,-1.4712151173905417,-1.4254251043953374,-1.4186781871955039,-1.3738292252100077,-1.3738046496438667,-1.3299908286965345,-1.2317834510179533,-1.1317461141241336,-1.0417889559256392,-0.9852009828969108,-0.9829996389796655,-0.9788659792335812,-0.9703466578644496,-0.9488617246538046,-0.9356669248431247,-0.9152864824451101,-0.8887648721269691,-0.8783924093228624,-0.8449839027191308,-0.8222206854422591,-0.7592591099567633,-0.7561831587594401,-0.7513518307788163,-0.7454080271591599,-0.7306477468752341,-0.7259257652070719,-0.6920850089486591,-0.6746115400271908]\n", + "\n", + "\n" + ] + } + ], + "source": [ + "x, y = Contour.coordinates(cs[2].lines[2])\n", + "@show x y\n", + "plot(x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Nothing to be done\n", + "INFO: METADATA is out-of-date — you may not have the latest version of GeometricalPredicates\n", + "INFO: Use `Pkg.update()` to get the latest versions of your packages\n", + "INFO: Cloning VoronoiDelaunay from https://github.com/JuliaGeometry/VoronoiDelaunay.jl\n", + "INFO: Computing changes...\n", + "INFO: No packages to install, update or remove\n", + "INFO: Package database updated\n" + ] + } + ], + "source": [ + "Pkg.add(\"GeometricalPredicates\")\n", + "Pkg.clone(\"https://github.com/JuliaGeometry/VoronoiDelaunay.jl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "using Plots\n", + "default(size=(500,300))\n", + "n = 100\n", + "x = randn(n)*3\n", + "y = randn(n)*3\n", + "z = Float64[sin(x[i]) + cos(y[i]) for i in 1:n]\n", + "scatter(x,y,z=z,c=:heat)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "zippoints (generic function with 2 methods)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using VoronoiDelaunay\n", + "tess = DelaunayTessellation()\n", + "tmin, tmax = min_coord, max_coord\n", + "twidth = tmax - tmin\n", + "function squash(a)\n", + " amin, amax = extrema(a)\n", + " v = similar(a)\n", + " for i in eachindex(a)\n", + " v[i] = tmin + twidth * (a[i] - amin) / (amax - amin)\n", + " end\n", + " v\n", + "end\n", + "function zippoints(x, y)\n", + " Point2D[Point(x[i], y[i]) for i in eachindex(x)]\n", + "end\n", + "function zippoints(x, y, z)\n", + " Point3D[Point(x[i], y[i], z[i]) for i in eachindex(x)]\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Base.Uint64 is deprecated, use UInt64 instead.\n", + "WARNING: Base.Uint64 is deprecated, use UInt64 instead.\n", + "WARNING: Base.Uint64 is deprecated, use UInt64 instead.\n", + "WARNING: int(x::AbstractFloat) is deprecated, use round(Int,x) instead.\n" + ] + } + ], + "source": [ + "a = zippoints(x, y)\n", + "push!(tess, a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 0.4.0-rc4", + "language": "julia", + "name": "julia-0.4" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "0.4.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/src/contours.jl b/src/contours.jl new file mode 100644 index 00000000..e01d2200 --- /dev/null +++ b/src/contours.jl @@ -0,0 +1,48 @@ + + +# immutable Vertex +# x::Float64 +# y::Float64 +# z::Float64 +# end + +# immutable Edge +# v::Vertex +# u::Vertex +# end + +# # ---------------------------------------------------------- + +# # one rectangle's z-values and the center vertex +# # z is ordered: topleft, topright, bottomright, bottomleft +# immutable GridRect +# z::Vector{Float64} +# center::Vertex +# data::Vector{Vertex} +# end + + + +# type Grid +# xs::Vector{Float64} +# ys::Vector{Float64} +# rects::Matrix{GridRect} +# end + +# function splitDataEvenly(v::AbstractVector{Float64}, n::Int) +# vs = sort(v) + +# end + +# # the goal here is to create the vertical and horizontal partitions +# # which define the grid, so that the data is somewhat evenly split +# function bucketData(x, y, z) + +# end + + +# function buildGrid(x, y, z) +# # create +# end + +