diff --git a/examples/playground.ipynb b/examples/playground.ipynb index 5d745a6d..99532464 100644 --- a/examples/playground.ipynb +++ b/examples/playground.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 15, + "execution_count": 26, "metadata": { "collapsed": false }, @@ -11,53 +11,52 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Plots.jl] Switched to backend: qwt" + "[Plots.jl] Switched to backend: gadfly" ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "Plot{Plots.QwtPackage() n=2}" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" + "ename": "LoadError", + "evalue": "LoadError: MethodError: `convert` has no method matching convert(::Type{ColorTypes.Color{T,N}}, ::Array{ColorTypes.RGB{FixedPointNumbers.UfixedBase{UInt8,8}},1})\nThis may have arisen from a call to the constructor ColorTypes.Color{T,N}(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n call{T}(::Type{T}, ::Any)\n convert{C<:ColorTypes.Colorant{T,N}}(::Type{C<:ColorTypes.Colorant{T,N}}, !Matched::ColorTypes.Colorant{T,N})\n convert{T}(::Type{T}, !Matched::T)\nwhile loading In[26], in expression starting on line 6", + "output_type": "error", + "traceback": [ + "LoadError: MethodError: `convert` has no method matching convert(::Type{ColorTypes.Color{T,N}}, ::Array{ColorTypes.RGB{FixedPointNumbers.UfixedBase{UInt8,8}},1})\nThis may have arisen from a call to the constructor ColorTypes.Color{T,N}(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n call{T}(::Type{T}, ::Any)\n convert{C<:ColorTypes.Colorant{T,N}}(::Type{C<:ColorTypes.Colorant{T,N}}, !Matched::ColorTypes.Colorant{T,N})\n convert{T}(::Type{T}, !Matched::T)\nwhile loading In[26], in expression starting on line 6", + "", + " in push! at array.jl:429", + " in addGadflySeries! at /home/tom/.julia/v0.4/Plots/src/backends/gadfly.jl:219", + " in plot! at /home/tom/.julia/v0.4/Plots/src/plot.jl:109", + " in plot at /home/tom/.julia/v0.4/Plots/src/plot.jl:58" + ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n", + "(cs,d[:x],d[:y]) = ([1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9],[0.400094521067053,0.16406446065812408,0.16406446065812408,0.9974519887147355,0.9974519887147355,0.07289322336328041,0.07289322336328041,0.8501439104781459,0.8501439104781459,0.44400664654624156,0.44400664654624156,0.208710808170248,0.208710808170248,0.10343086090249787,0.10343086090249787,0.6952138344567846,0.6952138344567846],[0.9879804797098521,0.4417137233363506,0.4417137233363506,0.7992773388653871,0.7992773388653871,0.4724928670878745,0.4724928670878745,0.7400062576174942,0.7400062576174942,0.9667002537131115,0.9667002537131115,0.6812304895553498,0.6812304895553498,0.6332230779375905,0.6332230779375905,0.19484023252140936,0.19484023252140936])\n" ] } ], "source": [ - "using Plots; qwt!()\n", - "p = plot(rand(10,2), size=(400,300))" + "using Plots; gadfly!(); plotDefault!(:size,(400,300))\n", + "n = 9\n", + "cs = distinguishable_colors(n)\n", + "#cs = [colorant\"red\",colorant\"blue\",colorant\"yellow\"]\n", + "#cs = vec(repmat(cs2,round(Int,n/length(cs2)),1))\n", + "plot(rand(n),rand(n), c=Any[cs], w=5, t=:scatter)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "collapsed": false }, - "outputs": [ - { - "data": { - "text/plain": [ - "Series{axis=left label=y1 idx=1 npoints=10}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "p.o.lines[1]" + "using Gadfly\n", + "xs = linspace(0,8π,100); ys = map(sin,xs); cs = rand(length(xs))\n", + "#plot(x=xs, y=ys, color=cs, Geom.path)\n", + "plot(x=vcat(xs,xs[2:end]), y=vcat(ys,ys[2:end]), color=vcat(cs,cs[1:end-1]), Geom.line)" ] }, { @@ -277,6 +276,76 @@ "plot!(rand(1,10)*10, style=:auto, t=[:hline,:vline])" ] }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "search: " + ] + }, + { + "data": { + "text/latex": [ + "\\begin{verbatim}\n", + "sort(A, dim, [alg=,] [by=,] [lt=,] [rev=false])\n", + "\\end{verbatim}\n", + "Sort a multidimensional array \\texttt{A} along the given dimension.\n", + "\\begin{verbatim}\n", + "sort(v, [alg=,] [by=,] [lt=,] [rev=false])\n", + "\\end{verbatim}\n", + "Variant of \\texttt{sort!} that returns a sorted copy of \\texttt{v} leaving \\texttt{v} itself unmodified.\n" + ], + "text/markdown": [ + "```\n", + "sort(A, dim, [alg=,] [by=,] [lt=,] [rev=false])\n", + "```\n", + "\n", + "Sort a multidimensional array `A` along the given dimension.\n", + "\n", + "```\n", + "sort(v, [alg=,] [by=,] [lt=,] [rev=false])\n", + "```\n", + "\n", + "Variant of `sort!` that returns a sorted copy of `v` leaving `v` itself unmodified.\n" + ], + "text/plain": [ + "```\n", + "sort(A, dim, [alg=,] [by=,] [lt=,] [rev=false])\n", + "```\n", + "\n", + "Sort a multidimensional array `A` along the given dimension.\n", + "\n", + "```\n", + "sort(v, [alg=,] [by=,] [lt=,] [rev=false])\n", + "```\n", + "\n", + "Variant of `sort!` that returns a sorted copy of `v` leaving `v` itself unmodified.\n" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sort sort! sortrows sortcols sortperm sortperm! SortingAlgorithms Cshort\n", + "\n" + ] + } + ], + "source": [ + "?sort" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/backends/gadfly.jl b/src/backends/gadfly.jl index 5409586e..11518c15 100644 --- a/src/backends/gadfly.jl +++ b/src/backends/gadfly.jl @@ -102,7 +102,8 @@ end # error("unsupported linestyle: ", linestyle) # end - +createSegments(z) = collect(repmat(z',2,1))[2:end] +Base.first(c::Colorant) = c function addGadflySeries!(gplt, d::Dict, initargs::Dict) @@ -121,8 +122,9 @@ function addGadflySeries!(gplt, d::Dict, initargs::Dict) # set theme: color, line width, and point size line_width = d[:width] * (d[:linetype] in (:none, :ohlc, :scatter) ? 0 : 1) * Gadfly.px # 0 width when we don't show a line + line_color = isa(d[:color], AbstractVector) ? colorant"black" : d[:color] # fg = initargs[:foreground_color] - theme = Gadfly.Theme(; default_color = d[:color], + theme = Gadfly.Theme(; default_color = line_color, line_width = line_width, default_point_size = 0.5 * d[:markersize] * Gadfly.px, # grid_color = fg, @@ -159,6 +161,22 @@ function addGadflySeries!(gplt, d::Dict, initargs::Dict) # add the Geoms append!(gfargs, getLineGeoms(d)) + # colorgroup + if isa(d[:color], AbstractVector) + # create a color scale, and set the color group to the index of the color + push!(gplt.scales, Gadfly.Scale.color_discrete_manual(d[:color]...)) + + # this is super weird, but... oh well... for some reason this creates n separate line segments... + # create a list of vertices that go: [x1,x2,x2,x3,x3, ... ,xi,xi, ... xn,xn] (same for y) + # then the vector passed to the "color" keyword should be a vector: [1,1,2,2,3,3,4,4, ..., i,i, ... , n,n] + csindices = Int[mod1(i,length(d[:color])) for i in 1:length(d[:y])] + cs = collect(repmat(csindices', 2, 1))[1:end-1] + d[:x], d[:y] = map(createSegments, (d[:x], d[:y])) + colorgroup = [(:color, cs)] + else + colorgroup = [] + end + # fillto if d[:fillto] == nothing yminmax = [] @@ -190,7 +208,7 @@ function addGadflySeries!(gplt, d::Dict, initargs::Dict) # Should ensure from this side that colors which are the same are merged together push!(gplt.guides[1].labels, d[:label]) - push!(gplt.guides[1].colors, d[:marker] == :none ? d[:color] : d[:markercolor]) + push!(gplt.guides[1].colors, d[:marker] == :none ? first(d[:color]) : d[:markercolor]) # println("updated legend: ", gplt.guides) end @@ -204,7 +222,7 @@ function addGadflySeries!(gplt, d::Dict, initargs::Dict) # add the layer to the Gadfly.Plot # prepend!(gplt.layers, Gadfly.layer(unique(gfargs)..., d[:args]...; x = x, y = d[:y], d[:kwargs]...)) - prepend!(gplt.layers, Gadfly.layer(unique(gfargs)...; x = x, y = d[:y], yminmax...)) + prepend!(gplt.layers, Gadfly.layer(unique(gfargs)...; x = x, y = d[:y], colorgroup..., yminmax...)) nothing end