gr: fix text problems

* fix LaTeXStrings support for UnicodePlots and InspectDR

* rename & fix

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.23.2"
+version = "1.23.5"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -31,13 +31,14 @@ Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+UnicodeFun = "1cfade01-22cf-5700-b092-accc4b62d6e1"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
 [compat]
 Contour = "0.5"
 FFMPEG = "0.2 - 0.4"
 FixedPointNumbers = "0.6 - 0.8"
-GR = "0.60 - 0.61"
+GR = "0.62"
 GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14 - 0.15"
@@ -52,6 +53,7 @@ Requires = "1"
 Scratch = "1"
 Showoff = "0.3.1, 1.0"
 StatsBase = "0.32 - 0.33"
+UnicodeFun = "0.4"
 UnicodePlots = "2.4"
 julia = "1.5"
 

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -216,7 +216,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
     Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(yaxis!)),Any,typeof(yaxis!),Any,Any})
     Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64, N} where N})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
@@ -241,11 +240,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.slice_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,Any})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol, Any},Symbol,Any})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,Any})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol, Any},Symbol,Any})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Float64},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Int64},String})
@@ -277,12 +272,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
-    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
     Base.precompile(Tuple{typeof(create_grid),Expr})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
+    Base.precompile(Tuple{typeof(expand_extrema!),Axis,StepRange{Int64, Int64}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
     Base.precompile(Tuple{typeof(fakedata),MersenneTwister,Int64,Vararg{Int64, N} where N})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
@@ -296,11 +291,11 @@ function _precompile_()
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
     Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
@@ -308,15 +303,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_shapes),Series,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
@@ -342,6 +334,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -358,6 +351,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Bool})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Float64})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
@@ -371,17 +365,17 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Tuple{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(push!),Segments{Float64},Float64,Float64,Float64,Float64,Vararg{Float64, N} where N})
-    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Float64, Float64, Float64},Tuple{Float64, Float64, Float64}})
-    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Int64, Int64, Float64},Tuple{Int64, Int64, Float64}})
+    Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
+    Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
+    Base.precompile(Tuple{typeof(set_RGBA_alpha),Int64,RGBA{Float64}})
     Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
@@ -395,6 +389,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Float64, Float64}}})
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Int64, Int64}}})
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Vector{Float64}, Vector{Float64}}}})
+    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true},typeof(ignorenan_extrema)})
     Base.precompile(Tuple{typeof(vline!),Any})
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})

src/Plots.jl

@@ -29,9 +29,10 @@ import RecipesBase: plot, plot!, animate, is_explicit
 using Base.Meta
 @reexport using PlotUtils
 @reexport using PlotThemes
-import Showoff
+import UnicodeFun
 import StatsBase
 import Downloads
+import Showoff
 import JSON
 
 using Requires

src/backends.jl

@@ -377,6 +377,8 @@ const _gr_attr = merge_with_base_supported([
     :colorbar,
     :colorbar_title,
     :colorbar_entry,
+    :colorbar_scale,
+    :clims,
     :fill_z,
     :line_z,
     :marker_z,

src/backends/gaston.jl

@@ -290,7 +290,7 @@ function gaston_seriesconf!(
     ps: pointscale
     pt: pointtype
     tc: textcolor
-    w: with 
+    w: with
     =#
     gsp = sp.o
     st = series[:seriestype]
@@ -307,7 +307,7 @@ function gaston_seriesconf!(
         fr = series[:fillrange]
         fc = gaston_color(get_fillcolor(series, i), get_fillalpha(series, i))
         lc, dt, lw = gaston_lc_ls_lw(series, clims, i)
-        if fr !== nothing # filled curves, but not filled curves with markers 
+        if fr !== nothing # filled curves, but not filled curves with markers
             push!(
                 curveconf,
                 "w filledcurves fc $fc fs solid border lc $lc lw $lw dt $dt,'' w lines lc $lc lw $lw dt $dt",
@@ -505,8 +505,8 @@ function gaston_set_ticks!(axesconf, ticks, letter, maj_min, add)
 end
 
 function gaston_set_legend!(axesconf, sp, any_label)
-    leg = sp[:legend]
-    if sp[:legend] ∉ (:none, :inline) && any_label
+    leg = sp[:legend_position]
+    if sp[:legend_position] ∉ (:none, :inline) && any_label
         leg == :best && (leg = :topright)
 
         push!(
@@ -517,9 +517,9 @@ function gaston_set_legend!(axesconf, sp, any_label)
             occursin(position, string(leg)) && push!(axesconf, "set key $position")
         end
         push!(axesconf, "set key $(gaston_font(legendfont(sp), rot=false, align=false))")
-        if sp[:legendtitle] !== nothing
+        if sp[:legend_title] !== nothing
             # NOTE: cannot use legendtitlefont(sp) as it will override legendfont
-            push!(axesconf, "set key title '$(sp[:legendtitle])'")
+            push!(axesconf, "set key title '$(sp[:legend_title])'")
         end
         push!(axesconf, "set key box lw 1 opaque")
         push!(axesconf, "set border back")

src/backends/gr.jl

@@ -228,9 +228,7 @@ end
 gr_inqtext(x, y, s) = gr_inqtext(x, y, string(s))
 
 function gr_inqtext(x, y, s::AbstractString)
-    if length(s) >= 2 && s[1] == '$' && s[end] == '$'
-        GR.inqmathtex(x, y, s[2:(end - 1)])
-    elseif occursin('\\', s) || occursin("10^{", s)
+    if (occursin('\\', s) || occursin("10^{", s)) && match(r".*\$[^\$]+?\$.*", String(s)) == nothing
         GR.inqtextext(x, y, s)
     else
         GR.inqtext(x, y, s)
@@ -240,9 +238,7 @@ end
 gr_text(x, y, s) = gr_text(x, y, string(s))
 
 function gr_text(x, y, s::AbstractString)
-    if length(s) >= 2 && s[1] == '$' && s[end] == '$'
-        GR.mathtex(x, y, s[2:(end - 1)])
-    elseif occursin('\\', s) || occursin("10^{", s)
+    if (occursin('\\', s) || occursin("10^{", s)) && match(r".*\$[^\$]+?\$.*", String(s)) == nothing
         GR.textext(x, y, s)
     else
         GR.text(x, y, s)
@@ -573,8 +569,11 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims, viewport_plotare
 
     ztick = 0.5 * GR.tick(zmin, zmax)
     gr_set_line(1, :solid, plot_color(:black), sp)
+    if sp[:colorbar_scale] == :log10
+        GR.setscale(2)
+    end
     GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
-
+    
     title = if isa(sp[:colorbar_title], PlotText)
         sp[:colorbar_title]
     else
@@ -953,6 +952,9 @@ function get_z_normalized(z, clims...)
 end
 
 function gr_clims(args...)
+    if args[1][:clims] != :auto
+        return args[1][:clims]
+    end
     lo, hi = get_clims(args...)
     if lo == hi
         if lo == 0
@@ -996,7 +998,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     # init the colorbar
     cbar = GRColorbar()
-
+    
     for series in series_list(sp)
         gr_add_series(sp, series)
         gr_update_colorbar!(cbar, series)
@@ -1241,21 +1243,26 @@ function gr_get_legend_geometry(viewport_plotarea, sp)
     if sp[:legend_position] != :none
         GR.savestate()
         GR.selntran(0)
+        GR.setcharup(0, 1)
         GR.setscale(0)
         if sp[:legend_title] !== nothing
             gr_set_font(legendtitlefont(sp), sp)
             legendn += 1
             tbx, tby = gr_inqtext(0, 0, string(sp[:legend_title]))
-            legendw = tbx[3] - tbx[1]
-            dy = tby[3] - tby[1]
+            l, r = extrema(tbx)
+            b, t = extrema(tby)
+            legendw = r - l
+            dy = t - b
         end
         gr_set_font(legendfont(sp), sp)
         for series in series_list(sp)
             should_add_to_legend(series) || continue
             legendn += 1
             tbx, tby = gr_inqtext(0, 0, string(series[:label]))
-            legendw = max(legendw, tbx[3] - tbx[1]) # Holds text width right now
-            dy = max(dy, tby[3] - tby[1])
+            l, r = extrema(tbx)
+            b, t = extrema(tby)
+            legendw = max(legendw, r - l) # Holds text width right now
+            dy = max(dy, t - b)
         end
 
         GR.setscale(1)
@@ -2089,15 +2096,37 @@ function gr_draw_heatmap(series, x, y, z, clims)
         # pdf output, and also supports alpha values.
         # Note that drawimage draws uniformly spaced data correctly
         # even on log scales, where it is visually non-uniform.
-        colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
+        colors, _z = if series[:subplot][:colorbar_scale] == :identity
+            plot_color.(get(fillgrad, z, clims), series[:fillalpha]), z
+        elseif series[:subplot][:colorbar_scale] == :log10
+            z_log = replace(x -> isinf(x) ? NaN : x, log10.(z))
+            z_normalized = get_z_normalized.(z_log, log10.(clims)...)
+            plot_color.(map(z -> get(fillgrad, z), z_normalized), series[:fillalpha]), z_log
+        end
+        for i in eachindex(colors)
+            if isnan(_z[i])
+                colors[i] = set_RGBA_alpha(0, colors[i])
+            end
+        end
         rgba = gr_color.(colors)
         GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
     else
         if something(series[:fillalpha], 1) < 1
             @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
         end
-        z_normalized = get_z_normalized.(z, clims...)
+        z_normalized, _z = if series[:subplot][:colorbar_scale] == :identity
+            get_z_normalized.(z, clims...), z
+        elseif series[:subplot][:colorbar_scale] == :log10
+            z_log = replace(x -> isinf(x) ? NaN : x, log10.(z))
+            get_z_normalized.(z_log, log10.(clims)...), z_log
+        end
         rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
+        background_color_ind = gr_getcolorind(plot_color(series[:subplot][:background_color_inside]))
+        for i in eachindex(rgba)
+            if isnan(_z[i])
+                rgba[i] = background_color_ind 
+            end
+        end
         if !ispolar(series)
             GR.nonuniformcellarray(x, y, w, h, rgba)
         else

src/backends/inspectdr.jl

@@ -70,7 +70,7 @@ function _inspectdr_add_annotations(plot, x, y, val::PlotText)
         color = _inspectdr_mapcolor(val.font.color),
     )
     ann = InspectDR.atext(
-        val.str,
+        texmath2unicode(val.str),
         x = x,
         y = y,
         font = fnt,
@@ -384,9 +384,9 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
     _inspectdr_setticks(sp, plot, strip, xaxis, yaxis)
 
     a = plot.annotation
-    a.title = sp[:title]
-    a.xlabel = xaxis[:guide]
-    a.ylabels = [yaxis[:guide]]
+    a.title = texmath2unicode(sp[:title])
+    a.xlabel = texmath2unicode(xaxis[:guide])
+    a.ylabels = [texmath2unicode(yaxis[:guide])]
 
     #Modify base layout of new object:
     l = plot.layout.defaults = deepcopy(InspectDR.defaults.plotlayout)

src/backends/pyplot.jl

@@ -1635,7 +1635,10 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                         dash_capstyle = "butt",
                         dash_joinstyle = "miter",
                         marker = py_marker(_cycle(series[:markershape], 1)),
-                        markersize = py_thickness_scale(plt, 0.8 * sp[:legend_font_pointsize]),
+                        markersize = py_thickness_scale(
+                            plt,
+                            0.8 * sp[:legend_font_pointsize],
+                        ),
                         markeredgecolor = py_color(
                             single_color(get_markerstrokecolor(series)),
                             get_markerstrokealpha(series),
@@ -1646,8 +1649,9 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                         ),
                         markeredgewidth = py_thickness_scale(
                             plt,
-                            0.8 * get_markerstrokewidth(series) * sp[:legend_font_pointsize] /
-                            first(series[:markersize]),
+                            0.8 *
+                            get_markerstrokewidth(series) *
+                            sp[:legend_font_pointsize] / first(series[:markersize]),
                         ),   # retain the markersize/markerstroke ratio from the markers on the plot
                     )
                     push!(handles, handle)

src/backends/unicodeplots.jl

@@ -42,9 +42,9 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
 
         kw = (
             compact = true,
-            title = sp[:title],
-            xlabel = xaxis[:guide],
-            ylabel = yaxis[:guide],
+            title = texmath2unicode(sp[:title]),
+            xlabel = texmath2unicode(xaxis[:guide]),
+            ylabel = texmath2unicode(yaxis[:guide]),
             xscale = xaxis[:scale],
             yscale = yaxis[:scale],
             border = isijulia() ? :ascii : :solid,
@@ -63,7 +63,7 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
                 o,
                 x,
                 y,
-                val.str;
+                texmath2unicode(val.str);
                 color = up_color(val.font.color),
                 halign = val.font.halign,
                 valign = val.font.valign,

src/colorbars.jl

@@ -9,7 +9,7 @@ get_clims(sp::Subplot)::Tuple{Float64,Float64} =
     haskey(sp.attr, :clims_calculated) ? sp[:clims_calculated] : update_clims(sp)
 get_clims(series::Series)::Tuple{Float64,Float64} =
     haskey(series.plotattributes, :clims_calculated) ?
-        series[:clims_calculated]::Tuple{Float64,Float64} : update_clims(series)
+    series[:clims_calculated]::Tuple{Float64,Float64} : update_clims(series)
 get_clims(sp::Subplot, series::Series)::Tuple{Float64,Float64} =
     series[:colorbar_entry] ? get_clims(sp) : get_clims(series)
 

src/recipes.jl

@@ -1037,14 +1037,14 @@ export lens!
         throw(ArgumentError("Inset bounding box needs to in relative coordinates."))
     end
     sp = plt.subplots[sp_index]
-    xl1, xl2 = xlims(plt.subplots[sp_index])
+    xl1, xl2 = xlims(sp)
     bbx1 = xl1 + left(inset_bbox).value * (xl2 - xl1)
     bbx2 = bbx1 + width(inset_bbox).value * (xl2 - xl1)
-    yl1, yl2 = ylims(plt.subplots[sp_index])
+    yl1, yl2 = ylims(sp)
     bby1 = yl1 + (1 - bottom(inset_bbox).value) * (yl2 - yl1)
     bby2 = bby1 + height(inset_bbox).value * (yl2 - yl1)
-    bbx = bbx1 + width(inset_bbox).value * (xl2 - xl1) / 2
-    bby = bby1 + height(inset_bbox).value * (yl2 - yl1) / 2
+    bbx = bbx1 + width(inset_bbox).value * (xl2 - xl1) / 2 * (sp[:xaxis][:flip] ? -1 : 1)
+    bby = bby1 + height(inset_bbox).value * (yl2 - yl1) / 2 * (sp[:yaxis][:flip] ? -1 : 1)
     lens_index = last(plt.subplots)[:subplot_index] + 1
     x1, x2 = plotattributes[:x]
     y1, y2 = plotattributes[:y]

src/utils.jl

@@ -1221,6 +1221,7 @@ function mesh3d_triangles(x, y, z, cns::Tuple{Array,Array,Array})
     end
     return X, Y, Z
 end
+
 function mesh3d_triangles(x, y, z, cns::AbstractVector{NTuple{3,Int}})
     X = zeros(eltype(x), 4length(cns))
     Y = zeros(eltype(y), 4length(cns))
@@ -1251,3 +1252,5 @@ const _attrsymbolcache = Dict{Symbol,Dict{Symbol,Symbol}}()
 
 get_attr_symbol(letter::Symbol, keyword::String) = get_attr_symbol(letter, Symbol(keyword))
 get_attr_symbol(letter::Symbol, keyword::Symbol) = _attrsymbolcache[letter][keyword]
+
+texmath2unicode(s::AbstractString, pat=r"\$([^$]+)\$") = replace(s, pat => m->UnicodeFun.to_latex(m[2:(length(m)-1)]))

test/runtests.jl

@@ -199,6 +199,11 @@ end
     @test Plots.process_clims(nothing) ==
           Plots.process_clims(missing) ==
           Plots.process_clims(:auto)
+
+    @test (==)(
+        Plots.texmath2unicode(raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$"),
+        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²"
+    )
 end
 
 @testset "Backends" begin