ColorGradient fixes; allow default keywords in backend calls

src/backends/pyplot.jl

@@ -12,7 +12,9 @@ getPyPlotColor(c, α=nothing) = getPyPlotColor(convertColor(c, α))
 function getPyPlotColorMap(c::ColorGradient, α=nothing)
   # c = ColorGradient(c.colors, c.values, alpha=α)
   # pycolors.pymember("LinearSegmentedColormap")[:from_list]("tmp", map(getPyPlotColor, getColorVector(c)))
-  pyvals = [(c.values[i], getPyPlotColor(c.colors[i], α)) for i in 1:length(c.colors)]
+  # pyvals = [(c.values[i], getPyPlotColor(c.colors[i], α)) for i in 1:length(c.colors)]
+  pyvals = [(v, getPyPlotColor(getColorZ(c, v), α)) for v in c.values]
+  # @show c α pyvals
   pycolors.pymember("LinearSegmentedColormap")[:from_list]("tmp", pyvals)
 end
 

src/colors.jl

@@ -75,28 +75,34 @@ immutable ColorGradient <: ColorScheme
   colors::Vector{Colorant}
   values::Vector{Float64}
 
-  function ColorGradient{T<:Colorant,S<:Real}(cs::AVec{T}, vals::AVec{S} = 0:1; alpha = nothing)
+  function ColorGradient{T<:Colorant,S<:Real}(cs::AVec{T}, vals::AVec{S} = linspace(0, 1, length(cs)); alpha = nothing)
     if length(cs) == length(vals)
       return new(convertColor(cs,alpha), collect(vals))
     end
     
-    # otherwise interpolate evenly between the minval and maxval
-    minval, maxval = minimum(vals), maximum(vals)
-    vs = Float64[interpolate(minval, maxval, w) for w in linspace(0, 1, length(cs))]
-    new(convertColor(cs,alpha), vs)
+    # # otherwise interpolate evenly between the minval and maxval
+    # minval, maxval = minimum(vals), maximum(vals)
+    # vs = Float64[interpolate(minval, maxval, w) for w in linspace(0, 1, length(cs))]
+    # new(convertColor(cs,alpha), vs)
+
+    # interpolate the colors for each value
+    grad = ColorGradient(cs)
+    cs = [getColorZ(grad, z) for z in linspace(0, 1, length(vals))]
+    new(convertColor(cs, alpha), collect(vals)) #collect(linspace(0, 1, length(cs))))
   end
 end
 
 # create a gradient from a symbol (blues, reds, etc) and vector of boundary values
-function ColorGradient{T<:Real}(s::Symbol, vals::AVec{T} = 0:1; kw...)
+function ColorGradient{T<:Real}(s::Symbol, vals::AVec{T} = 0:0; kw...)
   haskey(_gradients, s) || error("Invalid gradient symbol.  Choose from: ", sort(collect(keys(_gradients))))
-
-  # if we passed in the right number of values, create the gradient directly
   cs = _gradients[s]
+  if vals == 0:0
+    vals = linspace(0, 1, length(cs))
+  end
   ColorGradient(cs, vals; kw...)
 end
 
-function ColorGradient{T<:Real}(cs::AVec{Symbol}, vals::AVec{T} = 0:1; kw...)
+function ColorGradient{T<:Real}(cs::AVec{Symbol}, vals::AVec{T} = linspace(0, 1, length(cs)); kw...)
   ColorGradient(map(convertColor, cs), vals; kw...)
 end
 

src/plotter.jl

@@ -26,16 +26,16 @@ export
   glvisualize
   # winston
 
-gadfly()        = backend(:gadfly)
-immerse()       = backend(:immerse)
-pyplot()        = backend(:pyplot)
-qwt()           = backend(:qwt)
-unicodeplots()  = backend(:unicodeplots)
-bokeh()         = backend(:bokeh)
-plotly()        = backend(:plotly)
-gr()            = backend(:gr)
-glvisualize()   = backend(:glvisualize)
-# winston()       = backend(:winston)
+gadfly(; kw...)        = (default(; kw...); backend(:gadfly))
+immerse(; kw...)       = (default(; kw...); backend(:immerse))
+pyplot(; kw...)        = (default(; kw...); backend(:pyplot))
+qwt(; kw...)           = (default(; kw...); backend(:qwt))
+unicodeplots(; kw...)  = (default(; kw...); backend(:unicodeplots))
+bokeh(; kw...)         = (default(; kw...); backend(:bokeh))
+plotly(; kw...)        = (default(; kw...); backend(:plotly))
+gr(; kw...)            = (default(; kw...); backend(:gr))
+glvisualize(; kw...)   = (default(; kw...); backend(:glvisualize))
+# winston(; kw...)       = (default(; kw...); backend(:winston))
 
 backend_name(::GadflyPackage)       = :gadfly
 backend_name(::ImmersePackage)      = :immerse