From 02d893b316b7bd0625d059ff9b62ebe16393de18 Mon Sep 17 00:00:00 2001 From: Thomas Breloff Date: Sun, 12 Jun 2016 12:34:41 -0400 Subject: [PATCH] big cleanup: changed camelcase to underscores; removed supportedAxes; changed pyplot methods to be py_ which matches gr_/plotly_/etc convention --- src/Plots.jl | 120 +-------------- src/args.jl | 32 ++-- src/backends.jl | 28 ++-- src/backends/bokeh.jl | 13 +- src/backends/gadfly.jl | 16 +- src/backends/glvisualize.jl | 13 +- src/backends/gr.jl | 13 +- src/backends/immerse.jl | 13 +- src/backends/pgfplots.jl | 13 +- src/backends/plotly.jl | 22 +-- src/backends/plotlyjs.jl | 19 ++- src/backends/pyplot.jl | 279 +++++++++++++++++------------------ src/backends/qwt.jl | 12 +- src/backends/unicodeplots.jl | 15 +- src/backends/winston.jl | 13 +- src/examples.jl | 4 +- src/plot.jl | 6 +- src/recipes.jl | 2 +- src/series_new.jl | 4 +- src/utils.jl | 2 +- 20 files changed, 259 insertions(+), 380 deletions(-) diff --git a/src/Plots.jl b/src/Plots.jl index 06cf0430..75bf9fa0 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -20,13 +20,9 @@ export grid, EmptyLayout, @layout, - # RowsLayout, - # FlexLayout, AVec, AMat, KW, - # attr, - # attr!, wrap, set_theme, @@ -34,8 +30,6 @@ export plot, plot!, - # subplot, - # subplot!, current, default, @@ -43,53 +37,11 @@ export @userplot, @shorthands, - # scatter, - # scatter!, - # bar, - # bar!, - # barh, - # barh!, - # histogram, - # histogram!, - # histogram2d, - # histogram2d!, - # density, - # density!, - # heatmap, - # heatmap!, - # hexbin, - # hexbin!, - # sticks, - # sticks!, - # hline, - # hline!, - # vline, - # vline!, - # ohlc, - # ohlc!, + pie, pie!, - # contour, - # contour!, - # contour3d, - # contour3d!, - # surface, - # surface!, - # wireframe, - # wireframe!, - # path3d, - # path3d!, plot3d, plot3d!, - # scatter3d, - # scatter3d!, - # abline!, - # boxplot, - # boxplot!, - # violin, - # violin!, - # quiver, - # quiver!, title!, xlabel!, @@ -119,9 +71,6 @@ export text, font, Axis, - # xaxis, - # yaxis, - # zaxis, stroke, brush, Surface, @@ -140,12 +89,11 @@ export debugplots, - supportedArgs, - supportedAxes, - supportedTypes, - supportedStyles, - supportedMarkers, - subplotSupported, + supported_args, + supported_types, + supported_styles, + supported_markers, + is_subplot_supported, Animation, frame, @@ -158,10 +106,6 @@ export arcdiagram, chorddiagram, - # @kw, - # @recipe, - # @plotrecipe, - test_examples, translate, @@ -209,14 +153,11 @@ include("arg_desc.jl") # define and export shorthand plotting method definitions macro shorthands(funcname::Symbol) funcname2 = Symbol(funcname, "!") - ret = esc(quote + esc(quote export $funcname, $funcname2 $funcname(args...; kw...) = plot(args...; kw..., seriestype = $(quot(funcname))) $funcname2(args...; kw...) = plot!(args...; kw..., seriestype = $(quot(funcname))) end) - # dump(ret,20) - # @show ret - ret end @shorthands scatter @@ -231,7 +172,6 @@ end @shorthands hline @shorthands vline @shorthands ohlc -# @shorthands pie @shorthands contour @shorthands contour3d @shorthands surface @@ -242,52 +182,10 @@ end @shorthands violin @shorthands quiver -# scatter(args...; kw...) = plot(args...; kw..., seriestype = :scatter) -# scatter!(args...; kw...) = plot!(args...; kw..., seriestype = :scatter) -# bar(args...; kw...) = plot(args...; kw..., seriestype = :bar) -# bar!(args...; kw...) = plot!(args...; kw..., seriestype = :bar) -# barh(args...; kw...) = plot(args...; kw..., seriestype = :barh, orientation = :h) -# barh!(args...; kw...) = plot!(args...; kw..., seriestype = :barh, orientation = :h) -# histogram(args...; kw...) = plot(args...; kw..., seriestype = :histogram) -# histogram!(args...; kw...) = plot!(args...; kw..., seriestype = :histogram) -# histogram2d(args...; kw...) = plot(args...; kw..., seriestype = :histogram2d) -# histogram2d!(args...; kw...) = plot!(args...; kw..., seriestype = :histogram2d) -# density(args...; kw...) = plot(args...; kw..., seriestype = :density) -# density!(args...; kw...) = plot!(args...; kw..., seriestype = :density) -# heatmap(args...; kw...) = plot(args...; kw..., seriestype = :heatmap) -# heatmap!(args...; kw...) = plot!(args...; kw..., seriestype = :heatmap) -# hexbin(args...; kw...) = plot(args...; kw..., seriestype = :hexbin) -# hexbin!(args...; kw...) = plot!(args...; kw..., seriestype = :hexbin) -# sticks(args...; kw...) = plot(args...; kw..., seriestype = :sticks, marker = :ellipse) -# sticks!(args...; kw...) = plot!(args...; kw..., seriestype = :sticks, marker = :ellipse) -# hline(args...; kw...) = plot(args...; kw..., seriestype = :hline) -# hline!(args...; kw...) = plot!(args...; kw..., seriestype = :hline) -# vline(args...; kw...) = plot(args...; kw..., seriestype = :vline) -# vline!(args...; kw...) = plot!(args...; kw..., seriestype = :vline) -# ohlc(args...; kw...) = plot(args...; kw..., seriestype = :ohlc) -# ohlc!(args...; kw...) = plot!(args...; kw..., seriestype = :ohlc) pie(args...; kw...) = plot(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing) pie!(args...; kw...) = plot!(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing) -# contour(args...; kw...) = plot(args...; kw..., seriestype = :contour) -# contour!(args...; kw...) = plot!(args...; kw..., seriestype = :contour) -# contour3d(args...; kw...) = plot(args...; kw..., seriestype = :contour3d) -# contour3d!(args...; kw...) = plot!(args...; kw..., seriestype = :contour3d) -# surface(args...; kw...) = plot(args...; kw..., seriestype = :surface) -# surface!(args...; kw...) = plot!(args...; kw..., seriestype = :surface) -# wireframe(args...; kw...) = plot(args...; kw..., seriestype = :wireframe) -# wireframe!(args...; kw...) = plot!(args...; kw..., seriestype = :wireframe) -# path3d(args...; kw...) = plot(args...; kw..., seriestype = :path3d) -# path3d!(args...; kw...) = plot!(args...; kw..., seriestype = :path3d) plot3d(args...; kw...) = plot(args...; kw..., seriestype = :path3d) plot3d!(args...; kw...) = plot!(args...; kw..., seriestype = :path3d) -# scatter3d(args...; kw...) = plot(args...; kw..., seriestype = :scatter3d) -# scatter3d!(args...; kw...) = plot!(args...; kw..., seriestype = :scatter3d) -# boxplot(args...; kw...) = plot(args...; kw..., seriestype = :boxplot) -# boxplot!(args...; kw...) = plot!(args...; kw..., seriestype = :boxplot) -# violin(args...; kw...) = plot(args...; kw..., seriestype = :violin) -# violin!(args...; kw...) = plot!(args...; kw..., seriestype = :violin) -# quiver(args...; kw...) = plot(args...; kw..., seriestype = :quiver) -# quiver!(args...; kw...) = plot!(args...; kw..., seriestype = :quiver) title!(s::AbstractString; kw...) = plot!(; title = s, kw...) @@ -340,13 +238,9 @@ yaxis!(plt::Plot, args...; kw...) = plot!(pl const CURRENT_BACKEND = CurrentBackend(:none) -# setup_dataframes() - function __init__() setup_ijulia() - # setup_dataframes() setup_atom() - # add_axis_letter_defaults() end # --------------------------------------------------------- diff --git a/src/args.jl b/src/args.jl index 61f60f6f..706cbfa5 100644 --- a/src/args.jl +++ b/src/args.jl @@ -290,10 +290,10 @@ const _all_defaults = KW[ ] const _all_args = sort(collect(union(map(keys, _all_defaults)...))) -supportedArgs(::AbstractBackend) = error("supportedArgs not defined") #_all_args -supportedArgs() = supportedArgs(backend()) +supported_args(::AbstractBackend) = error("supported_args not defined") #_all_args +supported_args() = supported_args(backend()) -RecipesBase.is_key_supported(k::Symbol) = (k in supportedArgs()) +RecipesBase.is_key_supported(k::Symbol) = (k in supported_args()) # ----------------------------------------------------------------------------- @@ -725,38 +725,38 @@ end # ----------------------------------------------------------------------------- -function warnOnUnsupportedArgs(pkg::AbstractBackend, d::KW) +function warnOnUnsupported_args(pkg::AbstractBackend, d::KW) for k in sortedkeys(d) - k in supportedArgs(pkg) && continue + k in supported_args(pkg) && continue k in _suppress_warnings && continue if d[k] != default(k) - warn("Keyword argument $k not supported with $pkg. Choose from: $(supportedArgs(pkg))") + warn("Keyword argument $k not supported with $pkg. Choose from: $(supported_args(pkg))") end end end -_markershape_supported(pkg::AbstractBackend, shape::Symbol) = shape in supportedMarkers(pkg) -_markershape_supported(pkg::AbstractBackend, shape::Shape) = Shape in supportedMarkers(pkg) +_markershape_supported(pkg::AbstractBackend, shape::Symbol) = shape in supported_markers(pkg) +_markershape_supported(pkg::AbstractBackend, shape::Shape) = Shape in supported_markers(pkg) _markershape_supported(pkg::AbstractBackend, shapes::AVec) = all([_markershape_supported(pkg, shape) for shape in shapes]) function warnOnUnsupported(pkg::AbstractBackend, d::KW) (d[:seriestype] == :none - || d[:seriestype] in supportedTypes(pkg) - || warn("seriestype $(d[:seriestype]) is unsupported with $pkg. Choose from: $(supportedTypes(pkg))")) - (d[:linestyle] in supportedStyles(pkg) - || warn("linestyle $(d[:linestyle]) is unsupported with $pkg. Choose from: $(supportedStyles(pkg))")) + || d[:seriestype] in supported_types(pkg) + || warn("seriestype $(d[:seriestype]) is unsupported with $pkg. Choose from: $(supported_types(pkg))")) + (d[:linestyle] in supported_styles(pkg) + || warn("linestyle $(d[:linestyle]) is unsupported with $pkg. Choose from: $(supported_styles(pkg))")) (d[:markershape] == :none || _markershape_supported(pkg, d[:markershape]) - || warn("markershape $(d[:markershape]) is unsupported with $pkg. Choose from: $(supportedMarkers(pkg))")) + || warn("markershape $(d[:markershape]) is unsupported with $pkg. Choose from: $(supported_markers(pkg))")) end -function warnOnUnsupportedScales(pkg::AbstractBackend, d::KW) +function warnOnUnsupported_scales(pkg::AbstractBackend, d::KW) for k in (:xscale, :yscale, :zscale) if haskey(d, k) v = d[k] v = get(_scaleAliases, v, v) - if !(v in supportedScales(pkg)) - warn("scale $(d[k]) is unsupported with $pkg. Choose from: $(supportedScales(pkg))") + if !(v in supported_scales(pkg)) + warn("scale $(d[k]) is unsupported with $pkg. Choose from: $(supported_scales(pkg))") end end end diff --git a/src/backends.jl b/src/backends.jl index ffeebb09..f2ce6bec 100644 --- a/src/backends.jl +++ b/src/backends.jl @@ -169,22 +169,20 @@ end # --------------------------------------------------------- -supportedAxes(::AbstractBackend) = [:left] -supportedTypes(::AbstractBackend) = [] -supportedStyles(::AbstractBackend) = [:solid] -supportedMarkers(::AbstractBackend) = [:none] -supportedScales(::AbstractBackend) = [:identity] -subplotSupported(::AbstractBackend) = false -stringsSupported(::AbstractBackend) = false -nativeImagesSupported(b::AbstractBackend) = :image in supportedTypes(b) +supported_types(::AbstractBackend) = [] +supported_styles(::AbstractBackend) = [:solid] +supported_markers(::AbstractBackend) = [:none] +supported_scales(::AbstractBackend) = [:identity] +is_subplot_supported(::AbstractBackend) = false +is_string_supported(::AbstractBackend) = false +nativeImagesSupported(b::AbstractBackend) = :image in supported_types(b) -supportedAxes() = supportedAxes(backend()) -supportedTypes() = supportedTypes(backend()) -supportedStyles() = supportedStyles(backend()) -supportedMarkers() = supportedMarkers(backend()) -supportedScales() = supportedScales(backend()) -subplotSupported() = subplotSupported(backend()) -stringsSupported() = stringsSupported(backend()) +supported_types() = supported_types(backend()) +supported_styles() = supported_styles(backend()) +supported_markers() = supported_markers(backend()) +supported_scales() = supported_scales(backend()) +is_subplot_supported() = is_subplot_supported(backend()) +is_string_supported() = is_string_supported(backend()) nativeImagesSupported() = nativeImagesSupported(backend()) # --------------------------------------------------------- diff --git a/src/backends/bokeh.jl b/src/backends/bokeh.jl index 58ea59a1..adad4777 100644 --- a/src/backends/bokeh.jl +++ b/src/backends/bokeh.jl @@ -2,7 +2,7 @@ # https://github.com/bokeh/Bokeh.jl -supportedArgs(::BokehBackend) = [ +supported_args(::BokehBackend) = [ # :annotations, # :axis, # :background_color, @@ -59,12 +59,11 @@ supportedArgs(::BokehBackend) = [ # :surface, # :levels, ] -supportedAxes(::BokehBackend) = [:auto, :left] -supportedTypes(::BokehBackend) = [:none, :path, :scatter] #,:steppre, :steppost, :sticks, :histogram2d, :hexbin, :histogram, :bar, :hline, :vline, :contour] -supportedStyles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] -supportedMarkers(::BokehBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] #vcat(_allMarkers, Shape) -supportedScales(::BokehBackend) = [:identity, :ln] #, :ln, :log2, :log10, :asinh, :sqrt] -subplotSupported(::BokehBackend) = false +supported_types(::BokehBackend) = [:none, :path, :scatter] +supported_styles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] +supported_markers(::BokehBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] +supported_scales(::BokehBackend) = [:identity, :ln] +is_subplot_supported(::BokehBackend) = false # -------------------------------------------------------------------------------------- diff --git a/src/backends/gadfly.jl b/src/backends/gadfly.jl index a28b804c..1d3dcfa8 100644 --- a/src/backends/gadfly.jl +++ b/src/backends/gadfly.jl @@ -2,7 +2,7 @@ # https://github.com/dcjones/Gadfly.jl -supportedArgs(::GadflyBackend) = [ +supported_args(::GadflyBackend) = [ :annotations, :background_color, :foreground_color, :color_palette, :group, :label, :seriestype, @@ -15,7 +15,6 @@ supportedArgs(::GadflyBackend) = [ :title, :window_title, :show, :size, :x, :xguide, :xlims, :xticks, :xscale, :xflip, :y, :yguide, :ylims, :yticks, :yscale, :yflip, - # :z, :zguide, :zlims, :zticks, :zscale, :zflip, :z, :tickfont, :guidefont, :legendfont, :grid, :legend, :colorbar, @@ -24,17 +23,16 @@ supportedArgs(::GadflyBackend) = [ :ribbon, :quiver, :orientation, ] -supportedAxes(::GadflyBackend) = [:auto, :left] -supportedTypes(::GadflyBackend) = [ +supported_types(::GadflyBackend) = [ :none, :line, :path, :steppre, :steppost, :sticks, :scatter, :histogram2d, :hexbin, :histogram, - :bar, #:box, :violin, :quiver, + :bar, :hline, :vline, :contour, :shape ] -supportedStyles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] -supportedMarkers(::GadflyBackend) = vcat(_allMarkers, Shape) -supportedScales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt] -subplotSupported(::GadflyBackend) = true +supported_styles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] +supported_markers(::GadflyBackend) = vcat(_allMarkers, Shape) +supported_scales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt] +is_subplot_supported(::GadflyBackend) = true # -------------------------------------------------------------------------------------- diff --git a/src/backends/glvisualize.jl b/src/backends/glvisualize.jl index 9148eb5b..923fd1b1 100644 --- a/src/backends/glvisualize.jl +++ b/src/backends/glvisualize.jl @@ -2,7 +2,7 @@ # [WEBSITE] -supportedArgs(::GLVisualizeBackend) = [ +supported_args(::GLVisualizeBackend) = [ # :annotations, # :axis, # :background_color, @@ -59,12 +59,11 @@ supportedArgs(::GLVisualizeBackend) = [ # :surface # :levels, ] -supportedAxes(::GLVisualizeBackend) = [:auto, :left] -supportedTypes(::GLVisualizeBackend) = [:surface] #, :path, :scatter ,:steppre, :steppost, :sticks, :heatmap, :hexbin, :histogram, :bar, :hline, :vline, :contour] -supportedStyles(::GLVisualizeBackend) = [:auto, :solid] #, :dash, :dot, :dashdot, :dashdotdot] -supportedMarkers(::GLVisualizeBackend) = [:none, :auto, :ellipse] #, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] #vcat(_allMarkers, Shape) -supportedScales(::GLVisualizeBackend) = [:identity] #, :log, :log2, :log10, :asinh, :sqrt] -subplotSupported(::GLVisualizeBackend) = false +supported_types(::GLVisualizeBackend) = [:surface] +supported_styles(::GLVisualizeBackend) = [:auto, :solid] +supported_markers(::GLVisualizeBackend) = [:none, :auto, :ellipse] +supported_scales(::GLVisualizeBackend) = [:identity] +is_subplot_supported(::GLVisualizeBackend) = false # -------------------------------------------------------------------------------------- diff --git a/src/backends/gr.jl b/src/backends/gr.jl index dbdd1382..249575b5 100644 --- a/src/backends/gr.jl +++ b/src/backends/gr.jl @@ -3,7 +3,7 @@ # significant contributions by @jheinen -supportedArgs(::GRBackend) = [ +supported_args(::GRBackend) = [ :annotations, :background_color, :foreground_color, :color_palette, :background_color_legend, :background_color_inside, :background_color_outside, @@ -36,17 +36,16 @@ supportedArgs(::GRBackend) = [ :aspect_ratio, :normalize, :weights ] -supportedAxes(::GRBackend) = _allAxes -supportedTypes(::GRBackend) = [ +supported_types(::GRBackend) = [ :path, :scatter, :heatmap, :pie, :image, :contour, :path3d, :scatter3d, :surface, :wireframe, :shape ] -supportedStyles(::GRBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] -supportedMarkers(::GRBackend) = vcat(_allMarkers, Shape) -supportedScales(::GRBackend) = [:identity, :log10] -subplotSupported(::GRBackend) = true +supported_styles(::GRBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] +supported_markers(::GRBackend) = vcat(_allMarkers, Shape) +supported_scales(::GRBackend) = [:identity, :log10] +is_subplot_supported(::GRBackend) = true diff --git a/src/backends/immerse.jl b/src/backends/immerse.jl index 267af35e..a82f76a9 100644 --- a/src/backends/immerse.jl +++ b/src/backends/immerse.jl @@ -1,13 +1,12 @@ # https://github.com/JuliaGraphics/Immerse.jl -supportedArgs(::ImmerseBackend) = supportedArgs(GadflyBackend()) -supportedAxes(::ImmerseBackend) = supportedAxes(GadflyBackend()) -supportedTypes(::ImmerseBackend) = supportedTypes(GadflyBackend()) -supportedStyles(::ImmerseBackend) = supportedStyles(GadflyBackend()) -supportedMarkers(::ImmerseBackend) = supportedMarkers(GadflyBackend()) -supportedScales(::ImmerseBackend) = supportedScales(GadflyBackend()) -subplotSupported(::ImmerseBackend) = true +supported_args(::ImmerseBackend) = supported_args(GadflyBackend()) +supported_types(::ImmerseBackend) = supported_types(GadflyBackend()) +supported_styles(::ImmerseBackend) = supported_styles(GadflyBackend()) +supported_markers(::ImmerseBackend) = supported_markers(GadflyBackend()) +supported_scales(::ImmerseBackend) = supported_scales(GadflyBackend()) +is_subplot_supported(::ImmerseBackend) = true # -------------------------------------------------------------------------------------- diff --git a/src/backends/pgfplots.jl b/src/backends/pgfplots.jl index 49059314..f9384eef 100644 --- a/src/backends/pgfplots.jl +++ b/src/backends/pgfplots.jl @@ -2,7 +2,7 @@ # significant contributions by: @pkofod -supportedArgs(::PGFPlotsBackend) = [ +supported_args(::PGFPlotsBackend) = [ # :annotations, :background_color, :foreground_color, :color_palette, @@ -43,12 +43,11 @@ supportedArgs(::PGFPlotsBackend) = [ :aspect_ratio, # :match_dimensions, ] -supportedAxes(::PGFPlotsBackend) = [:auto, :left] -supportedTypes(::PGFPlotsBackend) = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour] -supportedStyles(::PGFPlotsBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] -supportedMarkers(::PGFPlotsBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape) -supportedScales(::PGFPlotsBackend) = [:identity, :ln, :log2, :log10] # :asinh, :sqrt] -subplotSupported(::PGFPlotsBackend) = false +supported_types(::PGFPlotsBackend) = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour] +supported_styles(::PGFPlotsBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot] +supported_markers(::PGFPlotsBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape) +supported_scales(::PGFPlotsBackend) = [:identity, :ln, :log2, :log10] +is_subplot_supported(::PGFPlotsBackend) = false # -------------------------------------------------------------------------------------- diff --git a/src/backends/plotly.jl b/src/backends/plotly.jl index 2f9947f0..c1fc0811 100644 --- a/src/backends/plotly.jl +++ b/src/backends/plotly.jl @@ -1,7 +1,7 @@ # https://plot.ly/javascript/getting-started -supportedArgs(::PlotlyBackend) = [ +supported_args(::PlotlyBackend) = [ :annotations, :background_color, :foreground_color, :color_palette, # :background_color_legend, :background_color_inside, :background_color_outside, @@ -34,16 +34,16 @@ supportedArgs(::PlotlyBackend) = [ # :normalize, :weights, :contours, :aspect_ratio ] -supportedAxes(::PlotlyBackend) = [:auto, :left] -supportedTypes(::PlotlyBackend) = [:none, :line, :path, :scatter, :steppre, :steppost, - :histogram2d, :histogram, :density, :bar, :contour, :surface, :path3d, :scatter3d, - :pie, :heatmap] #,, :sticks, :hexbin, :hline, :vline] -supportedStyles(::PlotlyBackend) = [:auto, :solid, :dash, :dot, :dashdot] -supportedMarkers(::PlotlyBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, - :pentagon, :hexagon, :octagon, :vline, :hline] #vcat(_allMarkers, Shape) -supportedScales(::PlotlyBackend) = [:identity, :log10] #, :ln, :log2, :log10, :asinh, :sqrt] -subplotSupported(::PlotlyBackend) = true -stringsSupported(::PlotlyBackend) = true +supported_types(::PlotlyBackend) = [:none, :line, :path, :scatter, :steppre, :steppost, + :histogram2d, :histogram, :density, :bar, + :contour, :surface, :path3d, :scatter3d, + :pie, :heatmap] +supported_styles(::PlotlyBackend) = [:auto, :solid, :dash, :dot, :dashdot] +supported_markers(::PlotlyBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, + :pentagon, :hexagon, :octagon, :vline, :hline] +supported_scales(::PlotlyBackend) = [:identity, :log10] +is_subplot_supported(::PlotlyBackend) = true +is_string_supported(::PlotlyBackend) = true # -------------------------------------------------------------------------------------- diff --git a/src/backends/plotlyjs.jl b/src/backends/plotlyjs.jl index 420c081b..c341232e 100644 --- a/src/backends/plotlyjs.jl +++ b/src/backends/plotlyjs.jl @@ -1,7 +1,7 @@ # https://github.com/spencerlyon2/PlotlyJS.jl -supportedArgs(::PlotlyJSBackend) = [ +supported_args(::PlotlyJSBackend) = [ :annotation, # :axis, :background_color, @@ -64,16 +64,15 @@ supportedArgs(::PlotlyJSBackend) = [ :orientation, :polar, ] -supportedAxes(::PlotlyJSBackend) = [:auto, :left] -supportedTypes(::PlotlyJSBackend) = [:none, :line, :path, :scatter, :steppre, :steppost, +supported_types(::PlotlyJSBackend) = [:none, :line, :path, :scatter, :steppre, :steppost, :histogram2d, :histogram, :density, :bar, :contour, :surface, :path3d, :scatter3d, - :pie, :heatmap] #,, :sticks, :hexbin, :hline, :vline] -supportedStyles(::PlotlyJSBackend) = [:auto, :solid, :dash, :dot, :dashdot] -supportedMarkers(::PlotlyJSBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, - :pentagon, :hexagon, :octagon, :vline, :hline] #vcat(_allMarkers, Shape) -supportedScales(::PlotlyJSBackend) = [:identity, :log10] #, :ln, :log2, :log10, :asinh, :sqrt] -subplotSupported(::PlotlyJSBackend) = true -stringsSupported(::PlotlyJSBackend) = true + :pie, :heatmap] +supported_styles(::PlotlyJSBackend) = [:auto, :solid, :dash, :dot, :dashdot] +supported_markers(::PlotlyJSBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, + :pentagon, :hexagon, :octagon, :vline, :hline] +supported_scales(::PlotlyJSBackend) = [:identity, :log10] +is_subplot_supported(::PlotlyJSBackend) = true +is_string_supported(::PlotlyJSBackend) = true # -------------------------------------------------------------------------------------- diff --git a/src/backends/pyplot.jl b/src/backends/pyplot.jl index 15d7d21c..67367542 100644 --- a/src/backends/pyplot.jl +++ b/src/backends/pyplot.jl @@ -2,7 +2,7 @@ # https://github.com/stevengj/PyPlot.jl -supportedArgs(::PyPlotBackend) = [ +supported_args(::PyPlotBackend) = [ :annotations, :background_color, :foreground_color, :color_palette, :background_color_legend, :background_color_inside, :background_color_outside, @@ -38,19 +38,17 @@ supportedArgs(::PyPlotBackend) = [ :subplot, :clims, ] -supportedAxes(::PyPlotBackend) = _allAxes -supportedTypes(::PyPlotBackend) = [ +supported_types(::PyPlotBackend) = [ :none, :line, :path, :steppre, :steppost, :shape, - :scatter, :histogram2d, :hexbin, :histogram, #:density, - :bar, :sticks, #:box, :violin, :quiver, + :scatter, :histogram2d, :hexbin, :histogram, + :bar, :sticks, :hline, :vline, :heatmap, :pie, :image, :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe ] -supportedStyles(::PyPlotBackend) = [:auto, :solid, :dash, :dot, :dashdot] -supportedMarkers(::PyPlotBackend) = vcat(_allMarkers, Shape) -supportedScales(::PyPlotBackend) = [:identity, :ln, :log2, :log10] -subplotSupported(::PyPlotBackend) = true -# nativeImagesSupported(::PyPlotBackend) = true +supported_styles(::PyPlotBackend) = [:auto, :solid, :dash, :dot, :dashdot] +supported_markers(::PyPlotBackend) = vcat(_allMarkers, Shape) +supported_scales(::PyPlotBackend) = [:identity, :ln, :log2, :log10] +is_subplot_supported(::PyPlotBackend) = true # -------------------------------------------------------------------------------------- @@ -82,37 +80,34 @@ end # -------------------------------------------------------------------------------------- # convert colorant to 4-tuple RGBA -getPyPlotColor(c::Colorant, α=nothing) = map(f->float(f(convertColor(c,α))), (red, green, blue, alpha)) -getPyPlotColor(cvec::ColorVector, α=nothing) = map(getPyPlotColor, convertColor(cvec, α).v) -getPyPlotColor(grad::ColorGradient, α=nothing) = map(c -> getPyPlotColor(c, α), grad.colors) -getPyPlotColor(scheme::ColorScheme, α=nothing) = getPyPlotColor(convertColor(getColor(scheme), α)) -getPyPlotColor(vec::AVec, α=nothing) = map(c->getPyPlotColor(c,α), vec) -getPyPlotColor(c, α=nothing) = getPyPlotColor(convertColor(c, α)) +py_color(c::Colorant, α=nothing) = map(f->float(f(convertColor(c,α))), (red, green, blue, alpha)) +py_color(cvec::ColorVector, α=nothing) = map(py_color, convertColor(cvec, α).v) +py_color(grad::ColorGradient, α=nothing) = map(c -> py_color(c, α), grad.colors) +py_color(scheme::ColorScheme, α=nothing) = py_color(convertColor(getColor(scheme), α)) +py_color(vec::AVec, α=nothing) = map(c->py_color(c,α), vec) +py_color(c, α=nothing) = py_color(convertColor(c, α)) -function getPyPlotColorMap(c::ColorGradient, α=nothing) - pyvals = [(v, getPyPlotColor(getColorZ(c, v), α)) for v in c.values] +function py_colormap(c::ColorGradient, α=nothing) + pyvals = [(v, py_color(getColorZ(c, v), α)) for v in c.values] pycolors.pymember("LinearSegmentedColormap")[:from_list]("tmp", pyvals) end # convert vectors and ColorVectors to standard ColorGradients # TODO: move this logic to colors.jl and keep a barebones wrapper for pyplot -getPyPlotColorMap(cv::ColorVector, α=nothing) = getPyPlotColorMap(ColorGradient(cv.v), α) -getPyPlotColorMap(v::AVec, α=nothing) = getPyPlotColorMap(ColorGradient(v), α) +py_colormap(cv::ColorVector, α=nothing) = py_colormap(ColorGradient(cv.v), α) +py_colormap(v::AVec, α=nothing) = py_colormap(ColorGradient(v), α) # anything else just gets a bluesred gradient -getPyPlotColorMap(c, α=nothing) = getPyPlotColorMap(default_gradient(), α) +py_colormap(c, α=nothing) = py_colormap(default_gradient(), α) -function getPyPlotCustomShading(c, z, α=nothing) - cmap = getPyPlotColorMap(c, α) - # sm = pycmap.pymember("ScalarMappable")(cmap = cmap) - # sm[:set_array](z) - # sm +function py_shading(c, z, α=nothing) + cmap = py_colormap(c, α) ls = pycolors.pymember("LightSource")(270,45) ls[:shade](z, cmap, vert_exag=0.1, blend_mode="soft") end # get the style (solid, dashed, etc) -function getPyPlotLineStyle(seriestype::Symbol, linestyle::Symbol) +function py_linestyle(seriestype::Symbol, linestyle::Symbol) seriestype == :none && return " " linestyle == :solid && return "-" linestyle == :dash && return "--" @@ -122,7 +117,7 @@ function getPyPlotLineStyle(seriestype::Symbol, linestyle::Symbol) return "-" end -function getPyPlotMarker(marker::Shape) +function py_marker(marker::Shape) x, y = shape_coords(marker) n = length(x) mat = zeros(n+1,2) @@ -140,7 +135,7 @@ const _path_CLOSEPOLY = UInt8(79) # see http://matplotlib.org/users/path_tutorial.html # and http://matplotlib.org/api/path_api.html#matplotlib.path.Path -function buildPyPlotPath(x, y) +function py_path(x, y) n = length(x) mat = zeros(n+1, 2) codes = zeros(UInt8, n+1) @@ -161,7 +156,7 @@ function buildPyPlotPath(x, y) end # get the marker shape -function getPyPlotMarker(marker::Symbol) +function py_marker(marker::Symbol) marker == :none && return " " marker == :ellipse && return "o" marker == :rect && return "s" @@ -174,32 +169,32 @@ function getPyPlotMarker(marker::Symbol) marker == :pentagon && return "p" marker == :hexagon && return "h" marker == :octagon && return "8" - haskey(_shapes, marker) && return getPyPlotMarker(_shapes[marker]) + haskey(_shapes, marker) && return py_marker(_shapes[marker]) warn("Unknown marker $marker") return "o" end -# getPyPlotMarker(markers::AVec) = map(getPyPlotMarker, markers) -function getPyPlotMarker(markers::AVec) +# py_marker(markers::AVec) = map(py_marker, markers) +function py_marker(markers::AVec) warn("Vectors of markers are currently unsupported in PyPlot: $markers") - getPyPlotMarker(markers[1]) + py_marker(markers[1]) end # pass through -function getPyPlotMarker(marker::AbstractString) +function py_marker(marker::AbstractString) @assert length(marker) == 1 marker end -function getPyPlotStepStyle(seriestype::Symbol) +function py_stepstyle(seriestype::Symbol) seriestype == :steppost && return "steps-post" seriestype == :steppre && return "steps-pre" return "default" end # untested... return a FontProperties object from a Plots.Font -function getPyPlotFont(font::Font) +function py_font(font::Font) pyfont.pymember("FontProperties")( family = font.family, size = font.size @@ -215,18 +210,18 @@ function add_pyfixedformatter(cbar, vals::AVec) cbar[:update_ticks]() end -# TODO: smoothing should be moved into the SliceIt method, should not touch backends -function handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Bool) - if smooth - xs, ys = regressionXY(d[:x], d[:y]) - ax[:plot](xs, ys, - # linestyle = getPyPlotLineStyle(:path, :dashdot), - color = getPyPlotColor(d[:linecolor]), - linewidth = 2 - ) - end -end -handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Real) = handleSmooth(plt, ax, d, true) +# # TODO: smoothing should be moved into the SliceIt method, should not touch backends +# function handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Bool) +# if smooth +# xs, ys = regressionXY(d[:x], d[:y]) +# ax[:plot](xs, ys, +# # linestyle = py_linestyle(:path, :dashdot), +# color = py_color(d[:linecolor]), +# linewidth = 2 +# ) +# end +# end +# handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Real) = handleSmooth(plt, ax, d, true) # --------------------------------------------------------------------------- @@ -244,7 +239,7 @@ end # total hack due to PyPlot bug (see issue #145). # hack: duplicate the color vector when the total rgba fields is the same as the series length -function color_fix(c, x) +function py_color_fix(c, x) if (typeof(c) <: AbstractArray && length(c)*4 == length(x)) || (typeof(c) <: Tuple && length(x) == 4) vcat(c, c) @@ -253,49 +248,49 @@ function color_fix(c, x) end end -pylinecolor(d::KW) = getPyPlotColor(d[:linecolor], d[:linealpha]) -pymarkercolor(d::KW) = getPyPlotColor(d[:markercolor], d[:markeralpha]) -pymarkerstrokecolor(d::KW) = getPyPlotColor(d[:markerstrokecolor], d[:markerstrokealpha]) -pyfillcolor(d::KW) = getPyPlotColor(d[:fillcolor], d[:fillalpha]) +py_linecolor(d::KW) = py_color(d[:linecolor], d[:linealpha]) +py_markercolor(d::KW) = py_color(d[:markercolor], d[:markeralpha]) +py_markerstrokecolor(d::KW) = py_color(d[:markerstrokecolor], d[:markerstrokealpha]) +py_fillcolor(d::KW) = py_color(d[:fillcolor], d[:fillalpha]) -pylinecolormap(d::KW) = getPyPlotColorMap(d[:linecolor], d[:linealpha]) -pymarkercolormap(d::KW) = getPyPlotColorMap(d[:markercolor], d[:markeralpha]) -pyfillcolormap(d::KW) = getPyPlotColorMap(d[:fillcolor], d[:fillalpha]) +py_linecolormap(d::KW) = py_colormap(d[:linecolor], d[:linealpha]) +py_markercolormap(d::KW) = py_colormap(d[:markercolor], d[:markeralpha]) +py_fillcolormap(d::KW) = py_colormap(d[:fillcolor], d[:fillalpha]) # --------------------------------------------------------------------------- # TODO: these can probably be removed eventually... right now they're just keeping things working before cleanup -getAxis(sp::Subplot) = sp.o +# getAxis(sp::Subplot) = sp.o -function getAxis(plt::Plot{PyPlotBackend}, series::Series) - sp = get_subplot(plt, get(series.d, :subplot, 1)) - getAxis(sp) -end +# function getAxis(plt::Plot{PyPlotBackend}, series::Series) +# sp = get_subplot(plt, get(series.d, :subplot, 1)) +# getAxis(sp) +# end -getfig(o) = o +# getfig(o) = o # --------------------------------------------------------------------------- # Figure utils -- F*** matplotlib for making me work so hard to figure this crap out # the drawing surface -canvas(fig) = fig[:canvas] +py_canvas(fig) = fig[:canvas] # the object controlling draw commands -renderer(fig) = canvas(fig)[:get_renderer]() +py_renderer(fig) = py_canvas(fig)[:get_renderer]() # draw commands... paint the screen (probably updating internals too) -drawfig(fig) = fig[:draw](renderer(fig)) -drawax(ax) = ax[:draw](renderer(ax[:get_figure]())) +py_drawfig(fig) = fig[:draw](py_renderer(fig)) +# py_drawax(ax) = ax[:draw](py_renderer(ax[:get_figure]())) # get a vector [left, right, bottom, top] in PyPlot coords (origin is bottom-left!) -get_extents(obj) = obj[:get_window_extent]()[:get_points]() +py_extents(obj) = obj[:get_window_extent]()[:get_points]() # compute a bounding box (with origin top-left), however pyplot gives coords with origin bottom-left function py_bbox(obj) - fl, fr, fb, ft = get_extents(obj[:get_figure]()) - l, r, b, t = get_extents(obj) + fl, fr, fb, ft = py_extents(obj[:get_figure]()) + l, r, b, t = py_extents(obj) BoundingBox(l*px, (ft-t)*px, (r-l)*px, (t-b)*px) end @@ -381,15 +376,16 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) d = series.d st = d[:seriestype] sp = d[:subplot] + ax = sp.o - if !(st in supportedTypes(plt.backend)) - error("seriestype $(st) is unsupported in PyPlot. Choose from: $(supportedTypes(plt.backend))") + if !(st in supported_types(plt.backend)) + error("seriestype $(st) is unsupported in PyPlot. Choose from: $(supported_types(plt.backend))") end # PyPlot doesn't handle mismatched x/y fix_xy_lengths!(plt, d) - ax = getAxis(plt, series) + # ax = getAxis(plt, series) x, y, z = d[:x], d[:y], d[:z] xyargs = (st in _3dTypes ? (x,y,z) : (x,y)) @@ -421,12 +417,12 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[:plot](xyargs...; label = d[:label], zorder = plt.n, - color = pylinecolor(d), + color = py_linecolor(d), linewidth = d[:linewidth], - linestyle = getPyPlotLineStyle(st, d[:linestyle]), + linestyle = py_linestyle(st, d[:linestyle]), solid_capstyle = "round", # dash_capstyle = "round", - drawstyle = getPyPlotStepStyle(st) + drawstyle = py_stepstyle(st) )[1] push!(handles, handle) @@ -439,10 +435,10 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) :arrowstyle => "simple,head_length=$(a.headlength),head_width=$(a.headwidth)", :shrinkA => 0, :shrinkB => 0, - :edgecolor => pylinecolor(d), - :facecolor => pylinecolor(d), + :edgecolor => py_linecolor(d), + :facecolor => py_linecolor(d), :linewidth => d[:linewidth], - :linestyle => getPyPlotLineStyle(st, d[:linestyle]), + :linestyle => py_linestyle(st, d[:linestyle]), ) add_arrows(x, y) do xyprev, xy ax[:annotate]("", @@ -471,8 +467,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[isvertical(d) ? :bar : :barh](x, y; label = d[:label], zorder = plt.n, - color = pyfillcolor(d), - edgecolor = pylinecolor(d), + color = py_fillcolor(d), + edgecolor = py_linecolor(d), linewidth = d[:linewidth], align = d[:bar_edges] ? "edge" : "center", extrakw... @@ -485,8 +481,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[isvertical(d) ? :bar : :barh](x, y; label = d[:label], zorder = plt.n, - color = pylinecolor(d), - edgecolor = pylinecolor(d), + color = py_linecolor(d), + edgecolor = py_linecolor(d), linewidth = d[:linewidth], align = "center", extrakw... @@ -500,10 +496,10 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) :bar, :sticks) extrakw = KW() if d[:marker_z] == nothing - extrakw[:c] = color_fix(pymarkercolor(d), x) + extrakw[:c] = py_color_fix(py_markercolor(d), x) else extrakw[:c] = convert(Vector{Float64}, d[:marker_z]) - extrakw[:cmap] = pymarkercolormap(d) + extrakw[:cmap] = py_markercolormap(d) clims = sp[:clims] if isa(clims, Tuple) && length(clims) == 2 isfinite(clims[1]) && (extrakw[:vmin] = clims[1]) @@ -519,9 +515,9 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[:scatter](xyargs...; label = d[:label], zorder = plt.n + 0.5, - marker = getPyPlotMarker(d[:markershape]), + marker = py_marker(d[:markershape]), s = d[:markersize] .^ 2, - edgecolors = pymarkerstrokecolor(d), + edgecolors = py_markerstrokecolor(d), linewidths = d[:markerstrokewidth], extrakw... ) @@ -532,8 +528,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[:hist](y; label = d[:label], zorder = plt.n, - color = pyfillcolor(d), - edgecolor = pylinecolor(d), + color = py_fillcolor(d), + edgecolor = py_linecolor(d), linewidth = d[:linewidth], bins = d[:bins], normed = d[:normalize], @@ -564,7 +560,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) bins = d[:bins], normed = d[:normalize], weights = d[:weights], - cmap = pyfillcolormap(d), # applies to the pcolorfast object + cmap = py_fillcolormap(d), # applies to the pcolorfast object extrakw... )[4] push!(handles, handle) @@ -588,8 +584,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) zorder = plt.n, gridsize = d[:bins], linewidths = d[:linewidth], - edgecolors = pylinecolor(d), - cmap = pyfillcolormap(d), # applies to the pcolorfast object + edgecolors = py_linecolor(d), + cmap = py_fillcolormap(d), # applies to the pcolorfast object extrakw... ) push!(handles, handle) @@ -601,8 +597,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) func = ax[st == :hline ? :axhline : :axvline] handle = func(yi; linewidth=d[:linewidth], - color=pylinecolor(d), - linestyle=getPyPlotLineStyle(st, d[:linestyle]) + color=py_linecolor(d), + linestyle=py_linestyle(st, d[:linestyle]) ) push!(handles, handle) end @@ -628,8 +624,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) label = d[:label], zorder = plt.n, linewidths = d[:linewidth], - linestyles = getPyPlotLineStyle(st, d[:linestyle]), - cmap = pylinecolormap(d), + linestyles = py_linestyle(st, d[:linestyle]), + cmap = py_linecolormap(d), extrakw... ) push!(handles, handle) @@ -639,7 +635,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[:contourf](x, y, z, levelargs...; label = d[:label], zorder = plt.n + 0.5, - cmap = pyfillcolormap(d), + cmap = py_fillcolormap(d), extrakw... ) push!(handles, handle) @@ -657,7 +653,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) z = transpose_z(d, z) if st == :surface if d[:marker_z] != nothing - extrakw[:facecolors] = getPyPlotCustomShading(d[:fillcolor], d[:marker_z], d[:fillalpha]) + extrakw[:facecolors] = py_shading(d[:fillcolor], d[:marker_z], d[:fillalpha]) extrakw[:shade] = false clims = sp[:clims] if isa(clims, Tuple) && length(clims) == 2 @@ -665,7 +661,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) isfinite(clims[2]) && (extrakw[:vmax] = clims[2]) end else - extrakw[:cmap] = pyfillcolormap(d) + extrakw[:cmap] = py_fillcolormap(d) needs_colorbar = true end end @@ -675,7 +671,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) rstride = 1, cstride = 1, linewidth = d[:linewidth], - edgecolor = pylinecolor(d), + edgecolor = py_linecolor(d), extrakw... ) push!(handles, handle) @@ -686,7 +682,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) offset = (zdir == "y" ? maximum : minimum)(mat) handle = ax[:contourf](x, y, z, levelargs...; zdir = zdir, - cmap = pyfillcolormap(d), + cmap = py_fillcolormap(d), offset = (zdir == "y" ? maximum : minimum)(mat) # where to draw the contour plane ) push!(handles, handle) @@ -709,9 +705,9 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[:plot_trisurf](x, y, z; label = d[:label], zorder = plt.n, - cmap = pyfillcolormap(d), + cmap = py_fillcolormap(d), linewidth = d[:linewidth], - edgecolor = pylinecolor(d), + edgecolor = py_linecolor(d), extrakw... ) push!(handles, handle) @@ -733,7 +729,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) end handle = ax[:imshow](z; zorder = plt.n, - cmap = getPyPlotColorMap([:black, :white]), + cmap = py_colormap([:black, :white]), vmin = 0.0, vmax = 1.0 ) @@ -764,8 +760,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[:pcolormesh](x, y, z; label = d[:label], zorder = plt.n, - cmap = pyfillcolormap(d), - edgecolors = (d[:linewidth] > 0 ? pylinecolor(d) : "face"), + cmap = py_fillcolormap(d), + edgecolors = (d[:linewidth] > 0 ? py_linecolor(d) : "face"), extrakw... ) push!(handles, handle) @@ -783,12 +779,12 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) end if st == :shape - path = buildPyPlotPath(x, y) + path = py_path(x, y) patches = pypatches.pymember("PathPatch")(path; label = d[:label], zorder = plt.n, - edgecolor = pymarkerstrokecolor(d), - facecolor = pymarkercolor(d), + edgecolor = py_markerstrokecolor(d), + facecolor = py_markercolor(d), linewidth = d[:markerstrokewidth], fill = true ) @@ -813,8 +809,8 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) d[:serieshandle] = handles - # smoothing - handleSmooth(plt, ax, d, d[:smooth]) + # # smoothing + # handleSmooth(plt, ax, d, d[:smooth]) # add the colorbar legend if needs_colorbar && sp[:colorbar] != :none @@ -854,7 +850,7 @@ function _series_added(plt::Plot{PyPlotBackend}, series::Series) handle = ax[f](args...; zorder = plt.n, - facecolor = pyfillcolor(d), + facecolor = py_fillcolor(d), linewidths = 0 ) push!(handles, handle) @@ -866,7 +862,7 @@ end function update_limits!(sp::Subplot{PyPlotBackend}, series::Series, letters) for letter in letters - setPyPlotLims(sp.o, sp[Symbol(letter, :axis)]) + py_set_lims(sp.o, sp[Symbol(letter, :axis)]) end end @@ -890,13 +886,13 @@ end # -------------------------------------------------------------------------- -function setPyPlotLims(ax, axis::Axis) +function py_set_lims(ax, axis::Axis) letter = axis[:letter] lfrom, lto = axis_limits(axis) ax[Symbol("set_", letter, "lim")](lfrom, lto) end -function addPyPlotTicks(ax, ticks, letter) +function py_set_ticks(ax, ticks, letter) ticks == :auto && return axis = ax[Symbol(letter,"axis")] if ticks == :none || ticks == nothing @@ -919,8 +915,8 @@ function addPyPlotTicks(ax, ticks, letter) end end -function applyPyPlotScale(ax, scaleType::Symbol, letter) - scaleType in supportedScales() || return warn("Unhandled scale value in pyplot: $scaleType") +function py_set_scale(ax, scaleType::Symbol, letter) + scaleType in supported_scales() || return warn("Unhandled scale value in pyplot: $scaleType") func = ax[Symbol("set_", letter, "scale")] kw = KW() arg = if scaleType == :identity @@ -940,16 +936,16 @@ function applyPyPlotScale(ax, scaleType::Symbol, letter) end -function updateAxisColors(ax, a::Axis) +function py_set_axis_colors(ax, a::Axis) for (loc, spine) in ax[:spines] - spine[:set_color](getPyPlotColor(a[:foreground_color_border])) + spine[:set_color](py_color(a[:foreground_color_border])) end axissym = Symbol(a[:letter], :axis) if haskey(ax, axissym) ax[:tick_params](axis=string(a[:letter]), which="both", - colors=getPyPlotColor(a[:foreground_color_axis]), - labelcolor=getPyPlotColor(a[:foreground_color_text])) - ax[axissym][:label][:set_color](getPyPlotColor(a[:foreground_color_guide])) + colors=py_color(a[:foreground_color_axis]), + labelcolor=py_color(a[:foreground_color_text])) + ax[axissym][:label][:set_color](py_color(a[:foreground_color_guide])) end end @@ -962,7 +958,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) w, h = plt[:size] fig = plt.o fig[:set_size_inches](px2inch(w), px2inch(h), forward = true) - fig[:set_facecolor](getPyPlotColor(plt[:background_color_outside])) + fig[:set_facecolor](py_color(plt[:background_color_outside])) fig[:set_dpi](DPI) # resize the window @@ -970,14 +966,15 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) # update subplots for sp in plt.subplots - ax = getAxis(sp) + # ax = getAxis(sp) + ax = sp.o if ax == nothing continue end # add the annotations for ann in sp[:annotations] - createPyPlotAnnotationObject(sp, ann...) + py_add_annotations(sp, ann...) end # title @@ -992,7 +989,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) end ax[field][:set_text](sp[:title]) ax[field][:set_fontsize](sp[:titlefont].pointsize) - ax[field][:set_color](getPyPlotColor(sp[:foreground_color_title])) + ax[field][:set_color](py_color(sp[:foreground_color_title])) # ax[:set_title](sp[:title], loc = loc) end @@ -1001,9 +998,9 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) axissym = Symbol(letter, :axis) axis = sp[axissym] haskey(ax, axissym) || continue - applyPyPlotScale(ax, axis[:scale], letter) - setPyPlotLims(ax, axis) - addPyPlotTicks(ax, get_ticks(axis), letter) + py_set_scale(ax, axis[:scale], letter) + py_set_lims(ax, axis) + py_set_ticks(ax, get_ticks(axis), letter) ax[Symbol("set_", letter, "label")](axis[:guide]) if get(axis.d, :flip, false) ax[Symbol("invert_", letter, "axis")]() @@ -1014,11 +1011,11 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) lab[:set_rotation](axis[:rotation]) end if sp[:grid] - fgcolor = getPyPlotColor(sp[:foreground_color_grid]) + fgcolor = py_color(sp[:foreground_color_grid]) ax[axissym][:grid](true, color = fgcolor) ax[:set_axisbelow](true) end - updateAxisColors(ax, axis) + py_set_axis_colors(ax, axis) end # aspect ratio @@ -1028,12 +1025,12 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) end # legend - addPyPlotLegend(plt, sp, ax) + py_add_legend(plt, sp, ax) # this sets the bg color inside the grid - ax[:set_axis_bgcolor](getPyPlotColor(sp[:background_color_inside])) + ax[:set_axis_bgcolor](py_color(sp[:background_color_inside])) end - drawfig(fig) + py_drawfig(fig) end @@ -1073,18 +1070,18 @@ end # ----------------------------------------------------------------- -function createPyPlotAnnotationObject(sp::Subplot{PyPlotBackend}, x, y, val) +function py_add_annotations(sp::Subplot{PyPlotBackend}, x, y, val) ax = sp.o ax[:annotate](val, xy = (x,y), zorder = 999) end -function createPyPlotAnnotationObject(sp::Subplot{PyPlotBackend}, x, y, val::PlotText) +function py_add_annotations(sp::Subplot{PyPlotBackend}, x, y, val::PlotText) ax = sp.o ax[:annotate](val.str, xy = (x,y), family = val.font.family, - color = getPyPlotColor(val.font.color), + color = py_color(val.font.color), horizontalalignment = val.font.halign == :hcenter ? "center" : string(val.font.halign), verticalalignment = val.font.valign == :vcenter ? "center" : string(val.font.valign), rotation = val.font.rotation * 180 / π, @@ -1121,7 +1118,7 @@ const _pyplot_legend_pos = KW( :topleft => "upper left" ) -function addPyPlotLegend(plt::Plot, sp::Subplot, ax) +function py_add_legend(plt::Plot, sp::Subplot, ax) leg = sp[:legend] if leg != :none # gotta do this to ensure both axes are included @@ -1131,7 +1128,7 @@ function addPyPlotLegend(plt::Plot, sp::Subplot, ax) if should_add_to_legend(series) # add a line/marker and a label push!(handles, if series.d[:seriestype] == :histogram - PyPlot.plt[:Line2D]((0,1),(0,0), color=pyfillcolor(series.d), linewidth=4) + PyPlot.plt[:Line2D]((0,1),(0,0), color=py_fillcolor(series.d), linewidth=4) else series.d[:serieshandle][1] end) @@ -1150,14 +1147,14 @@ function addPyPlotLegend(plt::Plot, sp::Subplot, ax) ) leg[:set_zorder](1000) - fgcolor = getPyPlotColor(sp[:foreground_color_legend]) + fgcolor = py_color(sp[:foreground_color_legend]) for txt in leg[:get_texts]() PyPlot.plt[:setp](txt, color = fgcolor) end # set some legend properties frame = leg[:get_frame]() - frame[:set_facecolor](getPyPlotColor(sp[:background_color_legend])) + frame[:set_facecolor](py_color(sp[:background_color_legend])) frame[:set_edgecolor](fgcolor) end end diff --git a/src/backends/qwt.jl b/src/backends/qwt.jl index 7c01382e..04f6d75d 100644 --- a/src/backends/qwt.jl +++ b/src/backends/qwt.jl @@ -2,7 +2,7 @@ # https://github.com/tbreloff/Qwt.jl -supportedArgs(::QwtBackend) = [ +supported_args(::QwtBackend) = [ :annotations, :axis, :background_color, @@ -44,10 +44,10 @@ supportedArgs(::QwtBackend) = [ :xscale, :yscale, ] -supportedTypes(::QwtBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :histogram2d, :hexbin, :histogram, :bar, :hline, :vline] -supportedMarkers(::QwtBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon] -supportedScales(::QwtBackend) = [:identity, :log10] -subplotSupported(::QwtBackend) = true +supported_types(::QwtBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :histogram2d, :hexbin, :histogram, :bar, :hline, :vline] +supported_markers(::QwtBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon] +supported_scales(::QwtBackend) = [:identity, :log10] +is_subplot_supported(::QwtBackend) = true # -------------------------------------------------------------------------------------- @@ -184,7 +184,7 @@ function updateLimsAndTicks(plt::Plot{QwtBackend}, d::KW, isx::Bool) # scaletype == :log && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(e)) # scaletype == :log2 && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(2)) scaletype == :log10 && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLog10ScaleEngine()) - scaletype in supportedScales() || warn("Unsupported scale type: ", scaletype) + scaletype in supported_scales() || warn("Unsupported scale type: ", scaletype) end end diff --git a/src/backends/unicodeplots.jl b/src/backends/unicodeplots.jl index d2677bdb..0442bcf3 100644 --- a/src/backends/unicodeplots.jl +++ b/src/backends/unicodeplots.jl @@ -1,7 +1,7 @@ # https://github.com/Evizero/UnicodePlots.jl -supportedArgs(::UnicodePlotsBackend) = [ +supported_args(::UnicodePlotsBackend) = [ # :annotations, # :args, # :axis, @@ -51,19 +51,18 @@ supportedArgs(::UnicodePlotsBackend) = [ # :yflip, # :z, ] -supportedAxes(::UnicodePlotsBackend) = [:auto, :left] -supportedTypes(::UnicodePlotsBackend) = [ +supported_types(::UnicodePlotsBackend) = [ :path, :steppre, :steppost, :scatter, :histogram2d, :hline, :vline ] -supportedStyles(::UnicodePlotsBackend) = [:auto, :solid] -supportedMarkers(::UnicodePlotsBackend) = [:none, :auto, :ellipse] -supportedScales(::UnicodePlotsBackend) = [:identity] -subplotSupported(::UnicodePlotsBackend) = true +supported_styles(::UnicodePlotsBackend) = [:auto, :solid] +supported_markers(::UnicodePlotsBackend) = [:none, :auto, :ellipse] +supported_scales(::UnicodePlotsBackend) = [:identity] +is_subplot_supported(::UnicodePlotsBackend) = true # don't warn on unsupported... there's just too many warnings!! -warnOnUnsupportedArgs(pkg::UnicodePlotsBackend, d::KW) = nothing +warnOnUnsupported_args(pkg::UnicodePlotsBackend, d::KW) = nothing # -------------------------------------------------------------------------------------- diff --git a/src/backends/winston.jl b/src/backends/winston.jl index 1b2790a4..ecae13e3 100644 --- a/src/backends/winston.jl +++ b/src/backends/winston.jl @@ -3,7 +3,7 @@ # credit goes to https://github.com/jverzani for contributing to the first draft of this backend implementation -supportedArgs(::WinstonBackend) = [ +supported_args(::WinstonBackend) = [ :annotations, # :args, # :axis, @@ -55,12 +55,11 @@ supportedArgs(::WinstonBackend) = [ # :yflip, # :z, ] -supportedAxes(::WinstonBackend) = [:auto, :left] -supportedTypes(::WinstonBackend) = [:none, :line, :path, :sticks, :scatter, :histogram, :bar] -supportedStyles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot] -supportedMarkers(::WinstonBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] -supportedScales(::WinstonBackend) = [:identity, :log10] -subplotSupported(::WinstonBackend) = false +supported_types(::WinstonBackend) = [:none, :line, :path, :sticks, :scatter, :histogram, :bar] +supported_styles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot] +supported_markers(::WinstonBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] +supported_scales(::WinstonBackend) = [:identity, :log10] +is_subplot_supported(::WinstonBackend) = false # -------------------------------------------------------------------------------------- diff --git a/src/examples.jl b/src/examples.jl index 427cb1e9..6da9b009 100644 --- a/src/examples.jl +++ b/src/examples.jl @@ -115,7 +115,7 @@ PlotExample("Line types", PlotExample("Line styles", "", [:(begin - styles = setdiff(supportedStyles(), [:auto])' + styles = setdiff(supported_styles(), [:auto])' plot(cumsum(randn(20,length(styles)),1), style=:auto, label=map(string,styles), w=5) end)] ), @@ -123,7 +123,7 @@ PlotExample("Line styles", PlotExample("Marker types", "", [:(begin - markers = setdiff(supportedMarkers(), [:none,:auto,Shape])' + markers = setdiff(supported_markers(), [:none,:auto,Shape])' n = length(markers) x = linspace(0,10,n+2)[2:end-1] y = repmat(reverse(x)', n, 1) diff --git a/src/plot.jl b/src/plot.jl index b82a823e..9db85544 100644 --- a/src/plot.jl +++ b/src/plot.jl @@ -161,7 +161,7 @@ end function _apply_series_recipe(plt::Plot, d::KW) st = d[:seriestype] # @show st - if st in supportedTypes() + if st in supported_types() # getting ready to add the series... last update to subplot from anything # that might have been added during series recipes @@ -192,7 +192,7 @@ function _apply_series_recipe(plt::Plot, d::KW) # add the series! - warnOnUnsupportedArgs(plt.backend, d) + warnOnUnsupported_args(plt.backend, d) warnOnUnsupported(plt.backend, d) series = Series(d) push!(plt.series_list, series) @@ -282,7 +282,7 @@ function _plot!(plt::Plot, d::KW, args...) kw[:series_plotindex] = plt.n # check that the backend will support the command and add it to the list - warnOnUnsupportedScales(plt.backend, kw) + warnOnUnsupported_scales(plt.backend, kw) push!(kw_list, kw) # handle error bars by creating new recipedata data... these will have diff --git a/src/recipes.jl b/src/recipes.jl index ad079b85..6ee5a62a 100644 --- a/src/recipes.jl +++ b/src/recipes.jl @@ -800,7 +800,7 @@ end # function apply_series_recipe(d::KW, ::Type{Val{:quiver}}) @recipe function f(::Type{Val{:quiver}}, x, y, z) - if :arrow in supportedArgs() + if :arrow in supported_args() quiver_using_arrows(d) else quiver_using_hack(d) diff --git a/src/series_new.jl b/src/series_new.jl index 203ed749..ad861949 100644 --- a/src/series_new.jl +++ b/src/series_new.jl @@ -17,8 +17,8 @@ function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int) plotIndex += 1 end - aliasesAndAutopick(d, :linestyle, _styleAliases, supportedStyles(pkg), plotIndex) - aliasesAndAutopick(d, :markershape, _markerAliases, supportedMarkers(pkg), plotIndex) + aliasesAndAutopick(d, :linestyle, _styleAliases, supported_styles(pkg), plotIndex) + aliasesAndAutopick(d, :markershape, _markerAliases, supported_markers(pkg), plotIndex) # update color d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], sp, plotIndex) diff --git a/src/utils.jl b/src/utils.jl index 9c1f2665..96e99490 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -131,7 +131,7 @@ function replace_image_with_heatmap{T<:Colorant}(z::Array{T}) end function imageHack(d::KW) - :heatmap in supportedTypes() || error("Neither :image or :heatmap are supported!") + :heatmap in supported_types() || error("Neither :image or :heatmap are supported!") d[:seriestype] = :heatmap d[:z], d[:fillcolor] = replace_image_with_heatmap(d[:z].surf) end