Merge pull request #3667 from t-bltg/gaston_add

Add new gnuplot capabilities (surface, contour, contour3d, scatter3d, wireframe, heatmap, ...)

src/backends.jl

@@ -623,20 +623,29 @@ const _gaston_attr = merge_with_base_supported([
     # :camera,
     # :contour_labels,
   ])
-const _gaston_seriestype = [:path,
+
-                            # :path3d,
+const _gaston_seriestype = [
+    :path,
+    :path3d,
     :scatter,
     :steppre,
-                            # :stepmid,
+    :stepmid,
     :steppost,
-                            # :histogram2d,
+    :histogram2d,
-                            # :ysticks, :xsticks,
+    :ysticks, :xsticks,
-                            # :contour,
+    :contour,
     :shape,
-                            # :straightline,
+    :straightline,
+    :scatter3d,
+    :contour3d,
+    :wireframe,
+    :heatmap,
+    :surface,
+    :mesh3d,
 ]
 
-const _gaston_style = [:auto,
+const _gaston_style = [
+    :auto,
    :solid,
    :dash,
    :dot,
@@ -644,7 +653,8 @@ const _gaston_style = [:auto,
    :dashdotdot
 ]
 
-const _gaston_marker = [:none,
+const _gaston_marker = [
+    :none,
     # :auto,
     :circle,
     :rect,
@@ -656,7 +666,8 @@ const _gaston_marker = [:none,
     :+
 ] #vcat(_allMarkers, Shape)
 
-const _gaston_scale = [:identity,
+const _gaston_scale = [
+    :identity,
     # :ln,
     # :log2,
     :log10,

src/backends/gaston.jl

@@ -4,11 +4,11 @@ const GastonSubplot = G.Plot
 const GASTON_MARKER_SCALING = 1.3 / 5.0
 const GNUPLOT_DPI = 72  # Compensate for DPI with increased resolution
 
-#
+
 # --------------------------------------------
 # These functions are called by Plots
 # --------------------------------------------
-#
+
 # Create the window/figure for this backend.
 function _create_backend_figure(plt::Plot{GastonBackend})
     xsize, ysize = plt.attr[:size]
@@ -22,31 +22,27 @@ end
 function _before_layout_calcs(plt::Plot{GastonBackend})
     # Initialize all the subplots first
     plt.o.subplots = G.SubPlot[]
-    nr, nc = plt.o.layout = size(plt.layout)
 
-    n = 0
+    n, sps = gaston_get_subplots(plt, 0, plt.layout)
-    sps = Array{Any}(undef, nr, nc)
+    @assert n == length(plt.subplots)
-    for r ∈ 1:nr, c ∈ 1:nc  # NOTE: row major
-        l = plt.layout.grid[r, c]
-        sps[r, c] = get(l.attr, :blank, false) ? nothing : plt.subplots[n += 1]
-    end
 
-    for c ∈ 1:nc, r ∈ 1:nr  # NOTE: col major
+    # FIXME: find a way to support nested layouts
-        gaston_init_subplot(plt, sps[r, c])
+    # e.g. figures spanning multiple rows/cols
-    end
+    plt.o.layout = gaston_init_subplots(plt, sps)
 
     # Then add the series (curves in gaston)
     for series in plt.series_list
         gaston_add_series(plt, series)
     end
+    nothing
 end
 
 function _update_min_padding!(sp::Subplot{GastonBackend})
+    # FIXME: make this more flexible
     sp.minpad = (20mm, 5mm, 2mm, 10mm)
 end
 
-function _update_plot_object(plt::Plot{GastonBackend})
+_update_plot_object(plt::Plot{GastonBackend}) = nothing
-end
 
 for (mime, term) in (
     "application/eps"         => "epscairo",   # NEED fixing TODO
@@ -59,12 +55,10 @@ for (mime, term) in (
     "text/plain"              => "dumb",       # NEED fixing TODO
 )
     @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GastonBackend})
-        xsize = plt.attr[:size][1]
+        xsize, ysize = plt.attr[:size]
-        ysize = plt.attr[:size][2]
         termopts = """size $xsize,$ysize"""
 
         tmpfile = G.tempname() * "." * $term
-
         G.save(
             term=$term,
             output=tmpfile,
@@ -75,21 +69,17 @@ for (mime, term) in (
         write(io, read(tmpfile))
         rm(tmpfile, force=true)
         nothing
-
     end
 end
 
-function _show(io::IO, mime::MIME{Symbol("image/png")},
+function _show(io::IO, mime::MIME{Symbol("image/png")}, plt::Plot{GastonBackend})
-               plt::Plot{GastonBackend},)
     scaling = plt.attr[:dpi] / GNUPLOT_DPI
-    xsize = plt.attr[:size][1] * scaling
+    xsize, ysize = plt.attr[:size] .* scaling
-    ysize = plt.attr[:size][2] * scaling
 
     # Scale all plot elements to match Plots.jl DPI standard
     termopts = """size $xsize,$ysize fontscale $scaling lw $scaling dl $scaling ps $scaling"""
 
     tmpfile = G.tempname()
-
     G.save(
         term="pngcairo",
         output=tmpfile,
@@ -102,26 +92,53 @@ function _show(io::IO, mime::MIME{Symbol("image/png")},
     nothing
 end
 
-
+_display(plt::Plot{GastonBackend}) = display(plt.o)
-function _display(plt::Plot{GastonBackend})
-    display(plt.o)
-end
 
 # --------------------------------------------
 # These functions are gaston specific
 # --------------------------------------------
 
+function gaston_get_subplots(plt, n, layout, level)
+    nr, nc = size(layout)
+    sps = Array{Any}(undef, nr, nc)
+    for r ∈ 1:nr, c ∈ 1:nc  # NOTE: col major
+        l = layout[r, c]
+        if l isa GridLayout
+            n, sub = gaston_get_subplots(plt, n, l)
+            sps[r, c] = size(sub) == (1, 1) ? only(sub) : sub
+        else
+            sps[r, c] = get(l.attr, :blank, false) ? nothing : plt.subplots[n += 1]
+        end
+    end
+    return n, sps
+end
+
+function gaston_init_subplots(plt, sps, level)
+    sz = nr, nc = size(sps)
+    for c ∈ 1:nc, r ∈ 1:nr  # NOTE: row major
+        sp = sps[r, c]
+        if sp isa Subplot || sp === nothing
+            gaston_init_subplot(plt, sp)
+        else
+            gaston_init_subplots(plt, sp, level + 1)
+            sz = max.(sz, size(sp))
+        end
+    end
+    return sz
+end
+
 function gaston_init_subplot(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
     if sp === nothing
         push!(plt.o.subplots, sp)
     else
-        dims = RecipesPipeline.is3d(sp) ? 3 : 2
+        sp.o = GastonSubplot(
-
+            dims=RecipesPipeline.is3d(sp) ? 3 : 2,
-        axesconf = gaston_parse_axes_args(plt, sp)  # Gnuplot string
+            axesconf=gaston_parse_axes_args(plt, sp),  # Gnuplot string
-        sp.o = GastonSubplot(dims=dims, axesconf=axesconf, curves=[])
+            curves=[]
-
+        )
         push!(plt.o.subplots, sp.o)
     end
+    nothing
 end
 
 function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
@@ -129,50 +146,75 @@ function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
     sp = series[:subplot]
     g_sp = sp.o  # Gaston subplot object
 
-    seriesconf = gaston_parse_series_args(series)  # Gnuplot string
+    if series[:seriestype] ∈ (:heatmap, :contour) && g_sp.dims == 2
-    c = G.Curve(series[:x], series[:y], nothing, nothing, seriesconf )
+        g_sp.dims = 3  # FIXME: this is ugly, we need heatmap/contour to use splot, not plot
+    end
+
+    x = series[:x]
+    y = series[:y]
+    z = g_sp.dims == 2 ? nothing : series[:z]
+    if z isa Surface
+        z = z.surf
+    end
+
+    seriesconf = gaston_seriesconf!(sp, series)  # Gnuplot string
+    c = G.Curve(x, y, z, nothing, seriesconf)
 
     isfirst = length(g_sp.curves) == 0 ? true : false
     push!(g_sp.curves, c)
     G.write_data(c, g_sp.dims, g_sp.datafile, append = isfirst ? false : true)
+    nothing
 end
 
-function gaston_parse_series_args(series::Series)
+function gaston_seriesconf!(sp, series::Series)
+    gsp = sp.o
     curveconf = String[]
     st = series[:seriestype]
 
-    if st == :scatter
+    clims = get_clims(sp, series)
-        pt = gaston_marker(series[:markershape])
+    if st ∈ (:scatter, :scatter3d)
-        ps = series[:markersize] * GASTON_MARKER_SCALING
+        pt, ps, lc = gaston_mk_ms_mc(series)
-        lc = gaston_color(series[:markercolor])
-        # alpha = series[:markeralpha] # TODO merge alpha with rgb color
         push!(curveconf, """with points pt $pt ps $ps lc $lc""")
-    elseif st == :path
+    elseif st ∈ (:path, :straightline, :path3d)
-        lc = gaston_color(series[:linecolor])
+        lc, dt, lw = gaston_lc_ls_lw(series)
-        dt = gaston_linestyle(series[:linestyle])
-        lw = series[:linewidth]
-        # alpha = series[:linealpha] # TODO merge alpha with rgb color
         if series[:markershape] == :none # simplepath
             push!(curveconf, """with lines lc $lc dt $dt lw $lw""")
         else
-            pt = gaston_marker(series[:markershape])
+            pt, ps = gaston_mk_ms_mc(series)
-            ps = series[:markersize] * GASTON_MARKER_SCALING
             push!(curveconf, """with lp lc $lc dt $dt lw $lw pt $pt ps $ps""")
         end
     elseif st == :shape
-        fc = gaston_color(series[:fillcolor])
+        fc = gaston_color(series[:fillcolor], series[:fillalpha])
         fs = "solid"
-        lc = gaston_color(series[:linecolor])
+        lc, _ = gaston_lc_ls_lw(series)
         push!(curveconf, """with filledcurves fc $fc fs $fs border lc $lc""")
     elseif st == :steppre
         push!(curveconf, """with steps""")
     elseif st == :steppost
         push!(curveconf, """with fsteps""")  # Not sure if not the other way
+    elseif st ∈ (:contour, :contour3d)
+        push!(curveconf, """with lines""")
+        if st == :contour
+            gsp.axesconf *= """\nset view map\nunset surface"""
+        end
+        levels = join(map(string, collect(contour_levels(series, clims))), ", ")
+        gsp.axesconf *= """\nset contour base\nset cntrparam levels discrete $levels """
+    elseif st ∈ (:surface, :heatmap)
+        palette = gaston_palette(series[:seriescolor])
+        gsp.axesconf *= """\nset palette model RGB defined $palette"""
+        if st == :heatmap
+            gsp.axesconf *= """\nset view map"""
+        end
+        push!(curveconf, """with pm3d""")
+    elseif st == :wireframe
+        lc, dt, lw = gaston_lc_ls_lw(series)
+        push!(curveconf, """with lines lc $lc dt $dt lw $lw""")
+    else
+        @warn "Gaston: $st is not implemented yet"
     end
 
     # label
     push!(curveconf, """title "$(series[:label])" """)
-
     return join(curveconf, " ")
 end
 
@@ -180,8 +222,7 @@ function gaston_parse_axes_args(plt::Plot{GastonBackend}, sp::Subplot{GastonBack
     axesconf = String[]
     # Standard 2d axis
     if !ispolar(sp) && !RecipesPipeline.is3d(sp)
-        # TODO
+        # TODO: configure grid, axis spines, thickness
-        # configure grid, axis spines, thickness
     end
 
     for letter in (:x, :y, :z)
@@ -215,7 +256,14 @@ function gaston_parse_axes_args(plt::Plot{GastonBackend}, sp::Subplot{GastonBack
             ticks = get_ticks(sp, axis_attr)
             gaston_set_ticks!(axesconf, ticks, letter)
         end
-        # set title {"<title-text>"} {offset <offset>} {font "<font>{,<size>}"}{{textcolor | tc} {<colorspec> | default}} {{no}enhanced}1
+
+        ratio = get_aspect_ratio(sp)
+        if ratio != :none
+            if ratio == :equal
+                ratio = -1
+            end
+            push!(axesconf, """set size ratio $ratio""")
+        end
     end
     gaston_set_legend!(axesconf, sp) # Set legend params
 
@@ -228,9 +276,8 @@ function gaston_parse_axes_args(plt::Plot{GastonBackend}, sp::Subplot{GastonBack
 end
 
 function gaston_set_ticks!(axesconf, ticks, letter)
-
     ticks == :auto && return
-    if ticks == :none || ticks === nothing || ticks == false
+    if ticks ∈ (:none, nothing, false)
         push!(axesconf, """unset $(letter)tics """)
         return
     end
@@ -247,7 +294,6 @@ function gaston_set_ticks!(axesconf, ticks, letter)
             axesconf,
             "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
         )
-
     elseif ttype == :ticks_and_labels
         tick_locations = @view ticks[1][:]
         tick_labels = @view ticks[2][:]
@@ -261,10 +307,10 @@ function gaston_set_ticks!(axesconf, ticks, letter)
             axesconf,
             "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
         )
-
     else
         error("Invalid input for $(letter)ticks: $ticks")
     end
+    nothing
 end
 
 function gaston_set_legend!(axesconf, sp)
@@ -297,7 +343,32 @@ function gaston_set_legend!(axesconf, sp)
         push!(axesconf, "set key off")
 
     end
+    nothing
+end
 
+# --------------------------------------------
+# Helpers
+# --------------------------------------------
+
+gaston_lc_ls_lw(series::Series) = (
+    gaston_color(series[:linecolor], series[:linealpha]),
+    gaston_linestyle(series[:linestyle]),
+    series[:linewidth],
+)
+
+gaston_mk_ms_mc(series::Series) = (
+    gaston_marker(series[:markershape]),
+    series[:markersize] * GASTON_MARKER_SCALING,
+    gaston_color(series[:markercolor], series[:markeralpha]),
+)
+
+function gaston_palette(gradient)
+    palette = String[]
+    n = -1
+    for rgba ∈ gradient  # FIXME: naive conversion, inefficient ?
+        push!(palette, "$(n += 1) $(rgba.r) $(rgba.g) $(rgba.b)")
+    end
+    return '(' * join(palette, ", ") * ')'
 end
 
 function gaston_marker(marker)
@@ -317,7 +388,11 @@ function gaston_marker(marker)
     return 1
 end
 
-gaston_color(color) = """rgb "#$(hex(color, :rrggbb))"  """
+function gaston_color(color, alpha=0.)
+    col = single_color(color)  # in case of gradients
+    col = alphacolor(col, alpha == nothing ? 0. : alpha)  # add a default alpha if non existent
+    return """rgb "#$(hex(col, :aarrggbb))" """
+end
 
 function gaston_linestyle(style)
     style == :solid && return "1"

src/examples.jl

@@ -1242,7 +1242,21 @@ _backend_skips = Dict(
     ],
     :inspectdr => [4, 6, 10, 22, 24, 28, 30, 38, 43, 45, 47, 48, 49, 50, 51, 55],
     :unicodeplots => [6, 10, 22, 24, 28, 38, 43, 45, 47, 49, 50, 51, 55],
-    :gaston => [2, 4, 5, 6, 10, 22, 24, 28, 31, 32, 35, 38, 43, 45, 47, 48, 49, 50, 51, 55],
+    :gaston => [
+        2,  # animations
+        4,  # colors/palette issues
+        6,  # TODO: support embedded images
+        16,  # TODO: support nested layouts
+        27,  # TODO: support polar
+        30,  # uses StatsPlots, deprecated ?
+        31,  # animations
+        47,  # TODO: support mesh3d
+        48,  # TODO: vector of shapes, ...
+        49,  # TODO: support polar
+        50,  # TODO: 1D data not supported for pm3d
+        51,  # TODO: support embedded images
+        55,  # TODO: scaling is ugly
+    ],
 )