diff --git a/examples/meetup/nnet.ipynb b/examples/meetup/nnet.ipynb index 438fccd0..d414382e 100644 --- a/examples/meetup/nnet.ipynb +++ b/examples/meetup/nnet.ipynb @@ -75,11 +75,35 @@ }, { "cell_type": "code", - "execution_count": 941, + "execution_count": 3, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Recompiling stale cache file /home/tom/.julia/lib/v0.4/OnlineStats.ji for module OnlineStats.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0.366577 seconds (2.08 M allocations: 156.080 MB, 3.22% gc time)\n", + "\n", + "\n", + "\n", + "maxabs(β - coef(o)) for\n", + "\n", + "glm: 0.005542500269197448\n", + "sgd: NaN\n", + "proxgrad: 0.004859362717011262\n", + "rda: 0.007882387662070361\n" + ] + } + ], "source": [ "using OnlineAI\n", "\n", @@ -87,7 +111,11 @@ "numInputs = 2\n", "numOutputs = 1\n", "hiddenLayerStructure = [3,3,2]\n", - "net = buildClassificationNet(numInputs, numOutputs, hiddenLayerStructure; hiddenActivation = TanhActivation())\n", + "net = buildClassificationNet(numInputs, numOutputs, hiddenLayerStructure;\n", + " hiddenActivation = TanhActivation(),\n", + " finalActivation = TanhActivation(),\n", + "\n", + ")\n", "\n", "# show the network\n", "viz = visualize(net);" @@ -102,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 942, + "execution_count": null, "metadata": { "collapsed": false }, @@ -133,27 +161,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Yikes... that looks tricky to separate..." + "# That looks tricky..." ] }, { "cell_type": "code", - "execution_count": 945, + "execution_count": null, "metadata": { "collapsed": false }, - "outputs": [ - { - "data": { - "text/plain": [ - "activateHidden (generic function with 1 method)" - ] - }, - "execution_count": 945, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# function to sample from x's\n", "xsample() = rand(Distributions.Uniform(lim...)) \n", @@ -169,14 +186,19 @@ "\n", "# take x matrix and convert to the first layer's activation\n", "function activateHidden(net, x)\n", - " input = x\n", - " for layer in net.layers[1:end-1]\n", - " proj = Array(nrows(x), layer.nout)\n", - " for i in 1:nrows(x)\n", + "# input = x\n", + " @assert net.layers[end].nin == 2\n", + " proj = Array(nrows(x), 2)\n", + " for i in 1:nrows(x)\n", + " data = row(x,i)\n", + " for layer in net.layers[1:end-1]\n", + " #proj = Array(nrows(x), layer.nout)\n", " OnlineAI.forward!(layer, row(proj,i), false)\n", - " row!(proj, i, layer.a)\n", + " data = layer.a\n", + "# row!(proj, i, layer.a)\n", " end\n", - " input = proj\n", + " row!(proj, i, data)\n", + "# input = proj\n", " end\n", " vec(proj[:,1]), vec(proj[:,2])\n", "end " @@ -184,22 +206,11 @@ }, { "cell_type": "code", - "execution_count": 946, + "execution_count": null, "metadata": { "collapsed": false }, - "outputs": [ - { - "ename": "LoadError", - "evalue": "LoadError: MethodError: `convert` has no method matching convert(::Type{Array{T,N}}, ::Int64, ::Int64)\nThis may have arisen from a call to the constructor Array{T,N}(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n convert{T,N}(::Type{Array{T,N}}, !Matched::DataArrays.DataArray{T,N}, ::Any)\n convert{T,R,N}(::Type{Array{T,N}}, !Matched::DataArrays.PooledDataArray{T,R,N}, ::Any)\n Array{T}(!Matched::Type{T}, ::Integer)\n ...\nwhile loading In[946], in expression starting on line 8", - "output_type": "error", - "traceback": [ - "LoadError: MethodError: `convert` has no method matching convert(::Type{Array{T,N}}, ::Int64, ::Int64)\nThis may have arisen from a call to the constructor Array{T,N}(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n convert{T,N}(::Type{Array{T,N}}, !Matched::DataArrays.DataArray{T,N}, ::Any)\n convert{T,R,N}(::Type{Array{T,N}}, !Matched::DataArrays.PooledDataArray{T,R,N}, ::Any)\n Array{T}(!Matched::Type{T}, ::Integer)\n ...\nwhile loading In[946], in expression starting on line 8", - "", - " in activateHidden at In[945]:17" - ] - } - ], + "outputs": [], "source": [ "# update net with new samples\n", "for i in 1:10000\n", @@ -232,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 940, + "execution_count": null, "metadata": { "collapsed": false }, diff --git a/examples/palettes.ipynb b/examples/palettes.ipynb index ef762949..36628d63 100644 --- a/examples/palettes.ipynb +++ b/examples/palettes.ipynb @@ -3599,7 +3599,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": { "collapsed": false }, @@ -3699,7 +3699,7 @@ " LCHab{Float32}(80.0,0.0,0.0) " ] }, - "execution_count": 4, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -3718,7 +3718,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 38, "metadata": { "collapsed": false }, @@ -3734,96 +3734,106 @@ " shape-rendering=\"crispEdges\">\n", "\n", + " fill=\"#5C95C9\" stroke=\"none\" />\n", "\n", + " fill=\"#E16D6C\" stroke=\"none\" />\n", "\n", + " fill=\"#749D45\" stroke=\"none\" />\n", "\n", + " fill=\"#BB78C7\" stroke=\"none\" />\n", "\n", + " fill=\"#C0843B\" stroke=\"none\" />\n", "\n", + " fill=\"#00A6A9\" stroke=\"none\" />\n", "\n", + " fill=\"#15A572\" stroke=\"none\" />\n", "\n", + " fill=\"#00A2D6\" stroke=\"none\" />\n", "\n", + " fill=\"#DF6A92\" stroke=\"none\" />\n", "\n", + " fill=\"#AA8E34\" stroke=\"none\" />\n", "\n", + " fill=\"#D17A4B\" stroke=\"none\" />\n", "\n", + " fill=\"#9B82DA\" stroke=\"none\" />\n", "\n", + " fill=\"#919637\" stroke=\"none\" />\n", "\n", + " fill=\"#00A68E\" stroke=\"none\" />\n", "\n", + " fill=\"#D26FB0\" stroke=\"none\" />\n", "\n", + " fill=\"#52A15A\" stroke=\"none\" />\n", "\n", + " fill=\"#708DE5\" stroke=\"none\" />\n", "\n", + " fill=\"#00A5C2\" stroke=\"none\" />\n", "\n", + " fill=\"#009DE3\" stroke=\"none\" />\n", "" ], "text/plain": [ - "19-element Array{ColorTypes.RGB{FixedPointNumbers.UfixedBase{UInt8,8}},1}:\n", - " RGB{U8}(0.0,0.698,1.0) \n", - " RGB{U8}(0.659,0.635,0.0) \n", - " RGB{U8}(0.0,0.729,0.545) \n", - " RGB{U8}(0.792,0.494,0.965)\n", - " RGB{U8}(1.0,0.373,0.51) \n", - " RGB{U8}(0.62,0.62,0.62) \n", - " RGB{U8}(0.467,0.863,0.506)\n", - " RGB{U8}(1.0,0.659,0.345) \n", - " RGB{U8}(0.576,0.757,1.0) \n", - " RGB{U8}(0.0,0.871,0.902) \n", - " RGB{U8}(1.0,0.663,0.965) \n", - " RGB{U8}(1.0,0.541,0.788) \n", - " RGB{U8}(0.91,0.51,0.388) \n", - " RGB{U8}(1.0,0.573,0.545) \n", - " RGB{U8}(0.0,0.733,0.788) \n", - " RGB{U8}(0.243,0.871,0.722)\n", - " RGB{U8}(0.831,0.788,0.408)\n", - " RGB{U8}(0.502,0.604,0.953)\n", - " RGB{U8}(0.443,0.682,0.271)" + "19-element Array{ColorTypes.RGB{T<:Union{AbstractFloat,FixedPointNumbers.FixedPoint}},1}:\n", + " RGB{Float32}(0.36054,0.586185,0.78741) \n", + " RGB{Float32}(0.882227,0.429164,0.424109) \n", + " RGB{Float64}(0.454946,0.614134,0.270629) \n", + " RGB{Float64}(0.734684,0.469738,0.781182) \n", + " RGB{Float64}(0.752053,0.519449,0.23159) \n", + " RGB{Float64}(0.0,0.652812,0.66165) \n", + " RGB{Float64}(0.0835171,0.645183,0.448756)\n", + " RGB{Float64}(0.0,0.636017,0.838055) \n", + " RGB{Float64}(0.876377,0.414925,0.574089) \n", + " RGB{Float64}(0.666258,0.556796,0.203266) \n", + " RGB{Float64}(0.820953,0.47993,0.292192) \n", + " RGB{Float64}(0.608867,0.511555,0.853633) \n", + " RGB{Float64}(0.567174,0.588777,0.217339) \n", + " RGB{Float64}(0.0,0.65181,0.555117) \n", + " RGB{Float64}(0.822141,0.434907,0.689089) \n", + " RGB{Float64}(0.320218,0.632785,0.351159) \n", + " RGB{Float64}(0.43774,0.552775,0.898806) \n", + " RGB{Float64}(0.0,0.647822,0.759042) \n", + " RGB{Float64}(0.0,0.616438,0.890754) " ] }, - "execution_count": 6, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "distinguishable_colors(20, colorant\"white\", transform=c -> deuteranopic(c, 0.5),\n", - " lchoices=Float64[65, 70, 75, 80],\n", - " cchoices=Float64[0, 50, 60, 70],\n", - " hchoices=linspace(0, 330, 24))[2:end]" + "bgcolor = colorant\"red\"\n", + "color_bases = [colorant\"steelblue\", colorant\"indianred\"]\n", + "lightness = 60\n", + "function adjust_lightness(c, l)\n", + " lch = LCHab(c)\n", + " RGB(LCHab(l, lch.c, lch.h))\n", + "end\n", + "\n", + "seed_colors = vcat(bgcolor, map(c -> adjust_lightness(c,lightness), color_bases))\n", + "distinguishable_colors(20, seed_colors,\n", + "# transform=c -> deuteranopic(c, 0.5),\n", + " lchoices=Float64[lightness],\n", + " cchoices=Float64[50],\n", + " hchoices=linspace(0, 340, 20))[2:end]" ] }, { @@ -4666,6 +4676,1617 @@ ], "source": [] }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "generate_palette_and_show (generic function with 2 methods)" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Plots\n", + "function adjust_lch(color, l, c)\n", + " lch = LCHab(color)\n", + " convert(RGB, LCHab(l, c, lch.h))\n", + "end\n", + "\n", + "function lightness_from_background(bgcolor)\n", + " bglight = LCHab(bgcolor).l\n", + " 0.45bglight + 55.0 * (bglight < 50.0)\n", + "end\n", + "\n", + "function gradient_from_list(cs)\n", + " zvalues = Plots.get_zvalues(length(cs))\n", + " indices = sortperm(zvalues)\n", + " sorted_colors = map(RGB, cs[indices])\n", + " sorted_zvalues = zvalues[indices]\n", + " ColorGradient(sorted_colors, sorted_zvalues)\n", + "end\n", + "\n", + "function generate_palette(bgcolor = colorant\"white\";\n", + " color_bases = [colorant\"steelblue\", colorant\"indianred\"],\n", + " lightness = lightness_from_background(bgcolor),\n", + " n = 20)\n", + " seed_colors = map(c -> adjust_lch(c,lightness,50), vcat(bgcolor, color_bases))\n", + " colors = distinguishable_colors(20,\n", + " seed_colors,\n", + " lchoices=Float64[lightness],\n", + " cchoices=Float64[50],\n", + " hchoices=linspace(0, 340, 20)\n", + " )[2:end]\n", + " gradient_from_list(colors)\n", + "end\n", + "\n", + "function show_gradient(grad)\n", + " display(RGB[getColorZ(grad,z) for z in linspace(0,1,1000)])\n", + "end\n", + "\n", + "function show_palette(grad)\n", + " display(RGB[getColorZ(grad,z) for z in Plots.get_zvalues(20)])\n", + "end\n", + "\n", + "function generate_palette_and_show(bgcolor, n=9)\n", + " grad = generate_palette(bgcolor, n=9)\n", + "# show_gradient(grad)\n", + " show_palette(grad)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "20-element Array{ColorTypes.RGB{T<:Union{AbstractFloat,FixedPointNumbers.FixedPoint}},1}:\n", + " RGB{Float64}(0.0,0.448194,0.742557) \n", + " RGB{Float64}(0.705544,0.274374,0.282973) \n", + " RGB{Float64}(0.501365,0.408751,0.0288239)\n", + " RGB{Float64}(0.57262,0.319397,0.620542) \n", + " RGB{Float64}(0.0,0.491045,0.600014) \n", + " RGB{Float64}(0.645938,0.331527,0.152689) \n", + " RGB{Float64}(0.302258,0.461118,0.123656) \n", + " RGB{Float64}(0.703226,0.256544,0.424501) \n", + " RGB{Float64}(0.0,0.464593,0.725451) \n", + " RGB{Float64}(0.581148,0.37233,0.0799225) \n", + " RGB{Float64}(0.0,0.493476,0.406492) \n", + " RGB{Float64}(0.449798,0.363808,0.689648) \n", + " RGB{Float64}(0.409271,0.438484,0.051499) \n", + " RGB{Float64}(0.0,0.494703,0.507527) \n", + " RGB{Float64}(0.263058,0.405169,0.732908) \n", + " RGB{Float64}(0.654477,0.280082,0.533106) \n", + " RGB{Float64}(0.0,0.481467,0.675223) \n", + " RGB{Float64}(0.154115,0.477232,0.209644) \n", + " RGB{Float64}(0.691176,0.29184,0.235208) \n", + " RGB{Float64}(0.511209,0.341602,0.655095) " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generate_palette_and_show(colorant\"white\");" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "20-element Array{ColorTypes.RGB{T<:Union{AbstractFloat,FixedPointNumbers.FixedPoint}},1}:\n", + " RGB{Float64}(0.0,0.341335,0.621623) \n", + " RGB{Float64}(0.575186,0.155586,0.183943) \n", + " RGB{Float64}(0.0,0.37388,0.203452) \n", + " RGB{Float64}(0.454754,0.209719,0.504248) \n", + " RGB{Float64}(0.0,0.377822,0.485126) \n", + " RGB{Float64}(0.294688,0.33114,0.0) \n", + " RGB{Float64}(0.0,0.35601,0.605244) \n", + " RGB{Float64}(0.575948,0.129392,0.317863) \n", + " RGB{Float64}(0.517086,0.224613,0.0458439)\n", + " RGB{Float64}(0.381426,0.303443,0.0) \n", + " RGB{Float64}(0.333212,0.258475,0.570532) \n", + " RGB{Float64}(0.189595,0.351274,0.0) \n", + " RGB{Float64}(0.0,0.378786,0.300686) \n", + " RGB{Float64}(0.0,0.380232,0.396887) \n", + " RGB{Float64}(0.531909,0.161681,0.420814) \n", + " RGB{Float64}(0.0,0.365066,0.106736) \n", + " RGB{Float64}(0.0,0.333102,0.624291) \n", + " RGB{Float64}(0.0,0.370333,0.557095) \n", + " RGB{Float64}(0.560781,0.178257,0.137558) \n", + " RGB{Float64}(0.322174,0.280497,0.252124) " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generate_palette_and_show(colorant\"orange\");" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "20-element Array{ColorTypes.RGB{T<:Union{AbstractFloat,FixedPointNumbers.FixedPoint}},1}:\n", + " RGB{Float64}(0.0,0.547295,0.852693) \n", + " RGB{Float64}(0.822944,0.377294,0.375972)\n", + " RGB{Float64}(0.40349,0.562307,0.221991) \n", + " RGB{Float64}(0.0,0.599398,0.609452) \n", + " RGB{Float64}(0.694571,0.469479,0.182695)\n", + " RGB{Float64}(0.555274,0.461402,0.798301)\n", + " RGB{Float64}(0.0,0.591983,0.399893) \n", + " RGB{Float64}(0.0,0.583701,0.783089) \n", + " RGB{Float64}(0.380827,0.50261,0.84286) \n", + " RGB{Float64}(0.610703,0.506513,0.151887)\n", + " RGB{Float64}(0.762157,0.42966,0.245054) \n", + " RGB{Float64}(0.680012,0.418946,0.72692) \n", + " RGB{Float64}(0.513882,0.537794,0.166534)\n", + " RGB{Float64}(0.0,0.598328,0.504656) \n", + " RGB{Float64}(0.765678,0.383033,0.636307)\n", + " RGB{Float64}(0.266655,0.580169,0.303173)\n", + " RGB{Float64}(0.0,0.594819,0.705289) \n", + " RGB{Float64}(0.0,0.564955,0.834998) \n", + " RGB{Float64}(0.808612,0.392814,0.32681) \n", + " RGB{Float64}(0.340006,0.509172,0.668186)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generate_palette_and_show(colorant\"black\");" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "20-element Array{ColorTypes.RGB{T<:Union{AbstractFloat,FixedPointNumbers.FixedPoint}},1}:\n", + " RGB{Float64}(0.245515,0.716265,1.0) \n", + " RGB{Float64}(1.0,0.547882,0.536215) \n", + " RGB{Float64}(0.732056,0.62787,0.980907) \n", + " RGB{Float64}(0.883692,0.635427,0.342518)\n", + " RGB{Float64}(0.0,0.775906,0.78232) \n", + " RGB{Float64}(0.95169,0.553815,0.810973) \n", + " RGB{Float64}(0.689857,0.706897,0.330495)\n", + " RGB{Float64}(0.565152,0.669252,1.0) \n", + " RGB{Float64}(0.955384,0.596296,0.40159) \n", + " RGB{Float64}(0.0,0.756888,0.964559) \n", + " RGB{Float64}(0.266914,0.767831,0.562404)\n", + " RGB{Float64}(0.793792,0.673479,0.316654)\n", + " RGB{Float64}(0.0,0.775039,0.672155) \n", + " RGB{Float64}(1.0,0.535021,0.691768) \n", + " RGB{Float64}(0.860436,0.587006,0.906186)\n", + " RGB{Float64}(0.0,0.770082,0.882981) \n", + " RGB{Float64}(1.0,0.561831,0.48483) \n", + " RGB{Float64}(0.57344,0.733975,0.382048) \n", + " RGB{Float64}(0.342905,0.706093,1.0) \n", + " RGB{Float64}(0.838742,0.654453,0.329586)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generate_palette_and_show(colorant\"darkgreen\");" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "using Plots; default(size=(600,200))\n", + "data = Plots.fakedata(50,10);" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/plain": [ + "Compose.SVG(158.73015873015876,52.91005291005292,IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=13382, maxsize=Inf, ptr=13383, mark=-1),nothing,\"fig-36340d6b669d4b2e8f3a688cc9cb4735\",0,Compose.SVGPropertyFrame[],Dict{Type{T},Union{Compose.Property{P<:Compose.PropertyPrimitive},Void}}(Compose.Property{Compose.FillPrimitive}=>nothing),Dict{Compose.ClipPrimitive{P<:Compose.Point{XM<:Compose.Measure{S,T},YM<:Compose.Measure{S,T}}},AbstractString}(Compose.ClipPrimitive{Compose.Point{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}(7.0733333333333235,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(7.0733333333333235,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0))])=>\"fig-36340d6b669d4b2e8f3a688cc9cb4735-element-9\"),Set{AbstractString}(),true,false,nothing,true,\"fig-36340d6b669d4b2e8f3a688cc9cb4735-element-24\",false,24,AbstractString[\"/home/tom/.julia/v0.4/Gadfly/src/gadfly.js\"],Tuple{AbstractString,AbstractString}[(\"Snap.svg\",\"Snap\"),(\"Gadfly\",\"Gadfly\")],AbstractString[\"fig.select(\\\"#fig-36340d6b669d4b2e8f3a688cc9cb4735-element-4\\\")\\n .drag(function() {}, function() {}, function() {});\",\"fig.select(\\\"#fig-36340d6b669d4b2e8f3a688cc9cb4735-element-8\\\")\\n .init_gadfly();\"],false,:none)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [], + "text/plain": [ + "Plot{Plots.ImmersePackage() n=10}" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bgcolor = colorant\"white\"\n", + "plot(data, w=3, bg=bgcolor, palette = generate_palette(bgcolor))" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/plain": [ + "Compose.SVG(158.73015873015876,52.91005291005292,IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=13382, maxsize=Inf, ptr=13383, mark=-1),nothing,\"fig-6cf02273297c4c74814c67b2793af75e\",0,Compose.SVGPropertyFrame[],Dict{Type{T},Union{Compose.Property{P<:Compose.PropertyPrimitive},Void}}(Compose.Property{Compose.FillPrimitive}=>nothing),Dict{Compose.ClipPrimitive{P<:Compose.Point{XM<:Compose.Measure{S,T},YM<:Compose.Measure{S,T}}},AbstractString}(Compose.ClipPrimitive{Compose.Point{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}(7.0733333333333235,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(7.0733333333333235,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0))])=>\"fig-6cf02273297c4c74814c67b2793af75e-element-9\"),Set{AbstractString}(),true,false,nothing,true,\"fig-6cf02273297c4c74814c67b2793af75e-element-24\",false,24,AbstractString[\"/home/tom/.julia/v0.4/Gadfly/src/gadfly.js\"],Tuple{AbstractString,AbstractString}[(\"Snap.svg\",\"Snap\"),(\"Gadfly\",\"Gadfly\")],AbstractString[\"fig.select(\\\"#fig-6cf02273297c4c74814c67b2793af75e-element-4\\\")\\n .drag(function() {}, function() {}, function() {});\",\"fig.select(\\\"#fig-6cf02273297c4c74814c67b2793af75e-element-8\\\")\\n .init_gadfly();\"],false,:none)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [], + "text/plain": [ + "Plot{Plots.ImmersePackage() n=10}" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bgcolor = colorant\"black\"\n", + "plot(data, w=3, bg=bgcolor, palette = generate_palette(bgcolor))" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/plain": [ + "Compose.SVG(158.73015873015876,52.91005291005292,IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=13354, maxsize=Inf, ptr=13355, mark=-1),nothing,\"fig-47211e745c7b472784a59709ca70c4a7\",0,Compose.SVGPropertyFrame[],Dict{Type{T},Union{Compose.Property{P<:Compose.PropertyPrimitive},Void}}(Compose.Property{Compose.FillPrimitive}=>nothing),Dict{Compose.ClipPrimitive{P<:Compose.Point{XM<:Compose.Measure{S,T},YM<:Compose.Measure{S,T}}},AbstractString}(Compose.ClipPrimitive{Compose.Point{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}(7.0733333333333235,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(7.0733333333333235,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0))])=>\"fig-47211e745c7b472784a59709ca70c4a7-element-9\"),Set{AbstractString}(),true,false,nothing,true,\"fig-47211e745c7b472784a59709ca70c4a7-element-24\",false,24,AbstractString[\"/home/tom/.julia/v0.4/Gadfly/src/gadfly.js\"],Tuple{AbstractString,AbstractString}[(\"Snap.svg\",\"Snap\"),(\"Gadfly\",\"Gadfly\")],AbstractString[\"fig.select(\\\"#fig-47211e745c7b472784a59709ca70c4a7-element-4\\\")\\n .drag(function() {}, function() {}, function() {});\",\"fig.select(\\\"#fig-47211e745c7b472784a59709ca70c4a7-element-8\\\")\\n .init_gadfly();\"],false,:none)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [], + "text/plain": [ + "Plot{Plots.ImmersePackage() n=10}" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bgcolor = colorant\"darkblue\"\n", + "plot(Plots.fakedata(50,10), w=3, bg=bgcolor, palette = generate_palette(bgcolor, color_bases=[colorant\"red\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " \n", + " \n", + " \n", + " y1\n", + " y2\n", + " y3\n", + " y4\n", + " y5\n", + " y6\n", + " y7\n", + " y8\n", + " y9\n", + " y10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " 0\n", + " 5\n", + " 10\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/plain": [ + "Compose.SVG(158.73015873015876,52.91005291005292,IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=13222, maxsize=Inf, ptr=13223, mark=-1),nothing,\"fig-04acb26b8e80478185a57c7e05ec5067\",0,Compose.SVGPropertyFrame[],Dict{Type{T},Union{Compose.Property{P<:Compose.PropertyPrimitive},Void}}(Compose.Property{Compose.FillPrimitive}=>nothing),Dict{Compose.ClipPrimitive{P<:Compose.Point{XM<:Compose.Measure{S,T},YM<:Compose.Measure{S,T}}},AbstractString}(Compose.ClipPrimitive{Compose.Point{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}(6.133333333333326,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(149.36682539682542,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(6.133333333333326,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(47.276719576719586,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0))])=>\"fig-04acb26b8e80478185a57c7e05ec5067-element-9\"),Set{AbstractString}(),true,false,nothing,true,\"fig-04acb26b8e80478185a57c7e05ec5067-element-24\",false,24,AbstractString[\"/home/tom/.julia/v0.4/Gadfly/src/gadfly.js\"],Tuple{AbstractString,AbstractString}[(\"Snap.svg\",\"Snap\"),(\"Gadfly\",\"Gadfly\")],AbstractString[\"fig.select(\\\"#fig-04acb26b8e80478185a57c7e05ec5067-element-4\\\")\\n .drag(function() {}, function() {}, function() {});\",\"fig.select(\\\"#fig-04acb26b8e80478185a57c7e05ec5067-element-8\\\")\\n .init_gadfly();\"],false,:none)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [], + "text/plain": [ + "Plot{Plots.ImmersePackage() n=10}" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bgcolor = colorant\"yellow\"\n", + "plot(Plots.fakedata(50,10), w=3, bg=bgcolor, palette = generate_palette(bgcolor, color_bases=[colorant\"blue\"]))" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/colors.jl b/src/colors.jl index 90abdf12..c7ce82aa 100644 --- a/src/colors.jl +++ b/src/colors.jl @@ -104,6 +104,10 @@ colorscheme(v::AVec) = ColorVector(v) colorscheme(m::AMat) = size(m,1) == 1 ? map(colorscheme, m) : [colorscheme(m[:,i]) for i in 1:size(m,2)]' colorscheme(c::Colorant) = ColorWrapper(c) + +# -------------------------------------------------------------- + + const _rainbowColors = [colorant"blue", colorant"purple", colorant"green", colorant"orange", colorant"red"] const _testColors = [colorant"darkblue", colorant"blueviolet", colorant"darkcyan",colorant"green", darken(colorant"yellow",0.3), colorant"orange", darken(colorant"red",0.2)] @@ -121,33 +125,8 @@ const _testColors = [colorant"darkblue", colorant"blueviolet", colorant"darkcya :darkrainbow => map(darken, _rainbowColors), :darktest => _testColors, :lighttest => map(c -> lighten(c, 0.3), _testColors), - :mlab => [RGB(0, 0.4470, 0.7410),RGB(0.4940, 0.1840, 0.5560),RGB(0.9290, 0.6940, 0.1250), - RGB(0.4660, 0.6740, 0.1880),RGB(0.3010, 0.7450, 0.9330),RGB(0.6350, 0.0780, 0.1840), - RGB(0.8500, 0.3250, 0.0980)], - :sb_deep => map(c->parse(Colorant,c), ["#4C72B0", "#55A868", "#C44E52", "#8172B2", "#CCB974", "#64B5CD"]), - :sb_muted => map(c->parse(Colorant,c), ["#4878CF", "#6ACC65", "#D65F5F", "#B47CC7", "#C4AD66", "#77BEDB"]), - :sb_pastl => map(c->parse(Colorant,c), ["#92C6FF", "#97F0AA", "#FF9F9A", "#D0BBFF", "#FFFEA3", "#B0E0E6"]), - :sb_bright => map(c->parse(Colorant,c), ["#003FFF", "#03ED3A", "#E8000B", "#8A2BE2", "#FFC400", "#00D7FF"]), - :sb_dark => map(c->parse(Colorant,c), ["#001C7F", "#017517", "#8C0900", "#7600A1", "#B8860B", "#006374"]), - :sb_colorblind=> map(c->parse(Colorant,c), ["#0072B2", "#009E73", "#D55E00", "#CC79A7", "#F0E442", "#56B4E9"]), ) -# # TODO: maybe try to include: - -# SEABORN_PALETTES = dict( -# deep=["#4C72B0", "#55A868", "#C44E52", -# "#8172B2", "#CCB974", "#64B5CD"], -# muted=["#4878CF", "#6ACC65", "#D65F5F", -# "#B47CC7", "#C4AD66", "#77BEDB"], -# pastel=["#92C6FF", "#97F0AA", "#FF9F9A", -# "#D0BBFF", "#FFFEA3", "#B0E0E6"], -# bright=["#003FFF", "#03ED3A", "#E8000B", -# "#8A2BE2", "#FFC400", "#00D7FF"], -# dark=["#001C7F", "#017517", "#8C0900", -# "#7600A1", "#B8860B", "#006374"], -# colorblind=["#0072B2", "#009E73", "#D55E00", -# "#CC79A7", "#F0E442", "#56B4E9"] -# ) # -------------------------------------------------------------- @@ -229,6 +208,44 @@ function interpolate(v1::Real, v2::Real, w::Real) (1-w) * v1 + w * v2 end + +# -------------------------------------------------------------- + +# Methods to automatically generate gradients for color selection based on +# background color and a short list of seed colors + +function adjust_lch(color, l, c) + lch = LCHab(color) + convert(RGB, LCHab(l, c, lch.h)) +end + +function lightness_from_background(bgcolor) + bglight = LCHab(bgcolor).l + 0.45bglight + 55.0 * (bglight < 50.0) +end + +function gradient_from_list(cs) + zvalues = Plots.get_zvalues(length(cs)) + indices = sortperm(zvalues) + sorted_colors = map(RGB, cs[indices]) + sorted_zvalues = zvalues[indices] + ColorGradient(sorted_colors, sorted_zvalues) +end + +function generate_colorgradient(bgcolor = colorant"white"; + color_bases = [colorant"steelblue", colorant"indianred"], + lightness = lightness_from_background(bgcolor), + n = 9) + seed_colors = map(c -> adjust_lch(c,lightness,50), vcat(bgcolor, color_bases)) + colors = distinguishable_colors(n, + seed_colors, + lchoices=Float64[lightness], + cchoices=Float64[50], + hchoices=linspace(0, 340, 20) + )[2:end] + gradient_from_list(colors) +end + # -------------------------------------------------------------- "Wraps a function, taking an index and returning a Colorant" @@ -304,44 +321,80 @@ const _lightColors = filter(islight, _allColors) const _sortedColorsForDarkBackground = vcat(_lightColors, reverse(_darkColors[2:end])) const _sortedColorsForLightBackground = vcat(_darkColors, reverse(_lightColors[2:end])) -const _defaultNumColors = 20 +const _defaultNumColors = 17 -function getPaletteUsingDistinguishableColors(bgcolor::Colorant, numcolors::Int = _defaultNumColors) - palette = distinguishable_colors(numcolors, bgcolor)[2:end] +# function getPaletteUsingDistinguishableColors(bgcolor::Colorant, numcolors::Int = _defaultNumColors) +# palette = distinguishable_colors(numcolors, bgcolor)[2:end] - # try to adjust lightness away from background color - bg_lab = Lab(bgcolor) - palette = RGB{Float64}[begin - lab = Lab(rgb) - Lab( - adjustAway(lab.l, bg_lab.l, 25, 75), - lab.a, - lab.b - ) - end for rgb in palette] +# # try to adjust lightness away from background color +# bg_lab = Lab(bgcolor) +# palette = RGB{Float64}[begin +# lab = Lab(rgb) +# Lab( +# adjustAway(lab.l, bg_lab.l, 25, 75), +# lab.a, +# lab.b +# ) +# end for rgb in palette] +# end + +# function getPaletteUsingFixedColorList(bgcolor::Colorant, numcolors::Int = _defaultNumColors) +# palette = isdark(bgcolor) ? _sortedColorsForDarkBackground : _sortedColorsForLightBackground +# palette[1:min(numcolors,length(palette))] +# end + +# function getPaletteUsingColorDiffFromBackground(bgcolor::Colorant, numcolors::Int = _defaultNumColors) +# colordiffs = [colordiff(c, bgcolor) for c in _allColors] +# mindiff = colordiffs[reverse(sortperm(colordiffs))[numcolors]] +# filter(c -> colordiff(c, bgcolor) >= mindiff, _allColors) +# end + +# -------------------------------------------------------------- + +# Methods to automatically generate gradients for color selection based on +# background color and a short list of seed colors + +# here are some magic constants that could be changed if you really want +const _bgratio = [0.4] +const _lch_c_const = [50] + +function adjust_lch(color, l, c) + lch = LCHab(color) + convert(RGB, LCHab(l, c, lch.h)) end -function getPaletteUsingFixedColorList(bgcolor::Colorant, numcolors::Int = _defaultNumColors) - palette = isdark(bgcolor) ? _sortedColorsForDarkBackground : _sortedColorsForLightBackground - palette[1:min(numcolors,length(palette))] +function lightness_from_background(bgcolor) + bglight = LCHab(bgcolor).l + _bgratio[1] * bglight + 100.0 * (1 - _bgratio[1]) * (bglight < 50.0) end -function getPaletteUsingColorDiffFromBackground(bgcolor::Colorant, numcolors::Int = _defaultNumColors) - colordiffs = [colordiff(c, bgcolor) for c in _allColors] - mindiff = colordiffs[reverse(sortperm(colordiffs))[numcolors]] - filter(c -> colordiff(c, bgcolor) >= mindiff, _allColors) +function gradient_from_list(cs) + zvalues = Plots.get_zvalues(length(cs)) + indices = sortperm(zvalues) + sorted_colors = map(RGB, cs[indices]) + sorted_zvalues = zvalues[indices] + ColorGradient(sorted_colors, sorted_zvalues) end -function getPaletteUsingGradientSymbol(palette, bgcolor::Colorant, numcolors::Int = _defaultNumColors) #; gradientsym::Symbol = :auto) - # @show gradientsym - if palette == :auto - # grad = ColorGradient(_gradients[isdark(bgcolor) ? :lightrainbow : :darkrainbow]) - # grad = ColorGradient(_gradients[isdark(bgcolor) ? :lighttest : :darktest]) - grad = ColorGradient(:mlab) - # elseif typeof(palette) <: AVec || typeof(palette) <: ColorGradient - # grad = ColorGradient(palette) +function generate_colorgradient(bgcolor = colorant"white"; + color_bases = [colorant"steelblue", colorant"indianred"], + lightness = lightness_from_background(bgcolor), + n = _defaultNumColors) + seed_colors = map(c -> adjust_lch(c,lightness, _lch_c_const[1]), vcat(bgcolor, color_bases)) + colors = distinguishable_colors(n, + seed_colors, + lchoices=Float64[lightness], + cchoices=Float64[_lch_c_const[1]], + hchoices=linspace(0, 340, 20) + )[2:end] + gradient_from_list(colors) +end + +function get_color_palette(palette, bgcolor::Colorant, numcolors::Integer) + grad = if palette == :auto + generate_colorgradient(bgcolor) else - grad = ColorGradient(palette) + ColorGradient(palette) end zrng = get_zvalues(numcolors) RGBA[getColorZ(grad, z) for z in zrng] @@ -396,24 +449,18 @@ function handlePlotColors(::PlottingPackage, d::Dict) end end - # d[:color_palette] = getPaletteUsingDistinguishableColors(bgcolor) - # d[:color_palette] = getPaletteUsingFixedColorList(bgcolor) - # d[:color_palette] = getPaletteUsingColorDiffFromBackground(bgcolor) - d[:color_palette] = getPaletteUsingGradientSymbol(get(d, :color_palette, :auto), bgcolor) + + d[:color_palette] = get_color_palette(get(d, :color_palette, :auto), bgcolor, 100) + # set the foreground color (text, ticks, gridlines) to be white or black depending # on how dark the background is. fgcolor = get(d, :foreground_color, :auto) - if fgcolor == :auto - fgcolor = isdark(bgcolor) ? colorant"white" : colorant"black" + fgcolor = if fgcolor == :auto + isdark(bgcolor) ? colorant"white" : colorant"black" else - fgcolor = convertColor(fgcolor) + convertColor(fgcolor) end - # if !haskey(d, :foreground_color) || d[:foreground_color] == :auto - # d[:foreground_color] = isdark(bgcolor) ? colorant"white" : colorant"black" - # else - # d[:foreground_color] = convertColor(d[:foreground_color]) - # end # bgcolor d[:background_color] = colorscheme(bgcolor)