Add Makie Extension, introduce plotvalues_layout (#158)

* Start Makie extension

* Add QuasiPlot for matrices

* plotgrid for banded

* _grid -> grid_layout, plotvalues_layout

* v0.15

* Update plotting.jl

* Add tests

* increase cov

* Update plotting.jl

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "ContinuumArrays"
 uuid = "7ae1f121-cc2c-504b-ac30-9b923412ae5c"
-version = "0.14.2"
+version = "0.15"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -18,10 +18,12 @@ QuasiArrays = "c4ea9172-b204-11e9-377d-29865faadc5c"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [weakdeps]
+Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 
 [extensions]
 ContinuumArraysRecipesBaseExt = "RecipesBase"
+ContinuumArraysMakieExt = "Makie"
 
 [compat]
 AbstractFFTs = "1.0"
@@ -35,16 +37,18 @@ InfiniteArrays = "0.12, 0.13"
 Infinities = "0.1"
 IntervalSets = "0.7"
 LazyArrays = "1.0"
-QuasiArrays = "0.11"
+Makie = "0.19"
+QuasiArrays = "0.11.1"
 RecipesBase = "1.0"
 StaticArrays = "1.0"
 julia = "1.9"
 
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 FastTransforms = "057dd010-8810-581a-b7be-e3fc3b93f78c"
+Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Base64", "FastTransforms", "RecipesBase", "Test"]
+test = ["Base64", "FastTransforms", "RecipesBase", "Makie", "Test"]

ext/ContinuumArraysMakieExt.jl

@@ -0,0 +1,34 @@
+module ContinuumArraysMakieExt
+
+using ContinuumArrays, Makie
+using ContinuumArrays: plotgridvalues, AbstractQuasiArray, AbstractQuasiMatrix, AbstractQuasiVector, _split_svec
+import Makie: convert_arguments, plot!
+
+
+function Makie.convert_arguments(p::PointBased, g::AbstractQuasiVector)
+    x,v = plotgridvalues(g)
+    convert_arguments(p, _split_svec(x)..., v)
+end
+
+
+@recipe(QuasiPlot, P) do scene
+    Theme(
+    )
+end
+
+Makie.plottype(a::AbstractQuasiVector) = Lines
+Makie.plottype(a::AbstractQuasiMatrix) = QuasiPlot
+
+function Makie.plot!(sc::QuasiPlot)
+    x,v = plotgridvalues(sc[:P][])
+    x2 = _split_svec(x)
+    for j in axes(v,2)
+        lines!(sc, x, v[:,j])
+    end
+    sc
+end
+
+
+
+
+end # module

ext/ContinuumArraysRecipesBaseExt.jl

@@ -1,11 +1,7 @@
 module ContinuumArraysRecipesBaseExt
 
-using ContinuumArrays, RecipesBase, StaticArrays
-using ContinuumArrays: plotgridvalues, AbstractQuasiArray
-
-_split_svec(x) = (x,)
-_split_svec(x::AbstractArray{<:StaticVector{2}}) = (map(first,x), map(last,x))
-
+using ContinuumArrays, RecipesBase
+using ContinuumArrays: plotgridvalues, AbstractQuasiArray, _split_svec
 
 @recipe function f(g::AbstractQuasiArray)
     x,v = plotgridvalues(g)

src/ContinuumArrays.jl

@@ -18,7 +18,7 @@ import QuasiArrays: cardinality, checkindex, QuasiAdjoint, QuasiTranspose, Inclu
                     QuasiDiagonal, MulQuasiArray, MulQuasiMatrix, MulQuasiVector, QuasiMatMulMat, QuasiArrayLayout,
                     ApplyQuasiArray, ApplyQuasiMatrix, LazyQuasiArrayApplyStyle, AbstractQuasiArrayApplyStyle, AbstractQuasiLazyLayout,
                     LazyQuasiArray, LazyQuasiVector, LazyQuasiMatrix, LazyLayout, LazyQuasiArrayStyle, _factorize, _cutdim,
-                    AbstractQuasiFill, UnionDomain, sum_size, sum_layout, _cumsum, cumsum_layout, applylayout, _equals, layout_broadcasted, PolynomialLayout, dot_size,
+                    AbstractQuasiFill, UnionDomain, sum_size, sum_layout, _cumsum, cumsum_layout, applylayout, equals_layout, layout_broadcasted, PolynomialLayout, dot_size,
                     diff_layout, diff_size
 import InfiniteArrays: Infinity, InfAxes
 import AbstractFFTs: Plan

src/bases/bases.jl

@@ -49,14 +49,14 @@ ApplyStyle(::typeof(pinv), ::Type{<:Basis}) = LazyQuasiArrayApplyStyle()
 pinv(J::Basis) = apply(pinv,J)
 
 
-function _equals(::AbstractBasisLayout, ::AbstractBasisLayout, A, B)
+function equals_layout(::AbstractBasisLayout, ::AbstractBasisLayout, A, B)
     axes(A) == axes(B) && throw(ArgumentError("Override == to compare bases of type $(typeof(A)) and $(typeof(B))"))
     false
 end
 
-_equals(::SubBasisLayouts, ::SubBasisLayouts, A::SubQuasiArray, B::SubQuasiArray) = parentindices(A) == parentindices(B) && parent(A) == parent(B)
-_equals(::MappedBasisLayouts, ::MappedBasisLayouts, A::SubQuasiArray, B::SubQuasiArray) = parentindices(A) == parentindices(B) && demap(A) == demap(B)
-_equals(::AbstractWeightedBasisLayout, ::AbstractWeightedBasisLayout, A, B) = weight(A) == weight(B) && unweighted(A) == unweighted(B)
+equals_layout(::SubBasisLayouts, ::SubBasisLayouts, A::SubQuasiArray, B::SubQuasiArray) = parentindices(A) == parentindices(B) && parent(A) == parent(B)
+equals_layout(::MappedBasisLayouts, ::MappedBasisLayouts, A::SubQuasiArray, B::SubQuasiArray) = parentindices(A) == parentindices(B) && demap(A) == demap(B)
+equals_layout(::AbstractWeightedBasisLayout, ::AbstractWeightedBasisLayout, A, B) = weight(A) == weight(B) && unweighted(A) == unweighted(B)
 
 @inline copy(L::Ldiv{<:AbstractBasisLayout,BroadcastLayout{typeof(+)}}) = +(broadcast(\,Ref(L.A),arguments(L.B))...)
 @inline copy(L::Ldiv{<:AbstractBasisLayout,BroadcastLayout{typeof(+)},<:Any,<:AbstractQuasiVector}) =
@@ -154,12 +154,12 @@ copy(L::Ldiv{<:MappedBasisLayouts,BroadcastLayout{typeof(*)},<:Any,<:AbstractQua
 
 
 # expansion
-_grid(_, P, n...) = error("Overload Grid")
+grid_layout(_, P, n...) = error("Overload Grid")
 
-_grid(::MappedBasisLayout, P, n...) = invmap(parentindices(P)[1])[grid(demap(P), n...)]
-_grid(::SubBasisLayout, P::AbstractQuasiMatrix, n) = grid(parent(P), maximum(parentindices(P)[2][n]))
-_grid(::SubBasisLayout, P::AbstractQuasiMatrix) = grid(parent(P), maximum(parentindices(P)[2]))
-_grid(::WeightedBasisLayouts, P, n...) = grid(unweighted(P), n...)
+grid_layout(::MappedBasisLayout, P, n...) = invmap(parentindices(P)[1])[grid(demap(P), n...)]
+grid_layout(::SubBasisLayout, P::AbstractQuasiMatrix, n) = grid(parent(P), maximum(parentindices(P)[2][n]))
+grid_layout(::SubBasisLayout, P::AbstractQuasiMatrix) = grid(parent(P), maximum(parentindices(P)[2]))
+grid_layout(::WeightedBasisLayouts, P, n...) = grid(unweighted(P), n...)
 
 
 """
@@ -170,7 +170,7 @@ be sufficient number of points to determine `size(P,2)`
 coefficients. Otherwise its enough points to determine `n`
 coefficients.
 """
-grid(P, n...) = _grid(MemoryLayout(P), P, n...)
+grid(P, n...) = grid_layout(MemoryLayout(P), P, n...)
 
 
 # values(f) = 
@@ -363,7 +363,7 @@ copy(L::Ldiv{Bas,<:ExpansionLayout}) where Bas<:AbstractBasisLayout = copy(Ldiv{
 copy(L::Mul{<:ExpansionLayout,Lay}) where Lay = copy(Mul{ApplyLayout{typeof(*)},Lay}(L.A, L.B))
 copy(L::Mul{<:ExpansionLayout,Lay}) where Lay<:AbstractLazyLayout = copy(Mul{ApplyLayout{typeof(*)},Lay}(L.A, L.B))
 
-function _broadcastbasis(::typeof(+), _, _, a, b)
+function broadcastbasis_layout(::typeof(+), _, _, a, b)
     try
         a ≠ b && error("Overload broadcastbasis(::typeof(+), ::$(typeof(a)), ::$(typeof(b)))")
     catch
@@ -372,17 +372,17 @@ function _broadcastbasis(::typeof(+), _, _, a, b)
     a
 end
 
-_broadcastbasis(::typeof(+), ::MappedBasisLayouts, ::MappedBasisLayouts, a, b) = broadcastbasis(+, demap(a), demap(b))[basismap(a), :]
-function _broadcastbasis(::typeof(+), ::SubBasisLayout, ::SubBasisLayout, a, b)
+broadcastbasis_layout(::typeof(+), ::MappedBasisLayouts, ::MappedBasisLayouts, a, b) = broadcastbasis(+, demap(a), demap(b))[basismap(a), :]
+function broadcastbasis_layout(::typeof(+), ::SubBasisLayout, ::SubBasisLayout, a, b)
     kr_a,jr_a = parentindices(a)
     kr_b,jr_b = parentindices(b)
     @assert kr_a == kr_b # frist axes must match
     view(broadcastbasis(+, parent(a), parent(b)), kr_a, union(jr_a,jr_b))
 end
-_broadcastbasis(::typeof(+), ::SubBasisLayout, _, a, b) = broadcastbasis(+, parent(a), b)
-_broadcastbasis(::typeof(+), _, ::SubBasisLayout, a, b) = broadcastbasis(+, a, parent(b))
+broadcastbasis_layout(::typeof(+), ::SubBasisLayout, _, a, b) = broadcastbasis(+, parent(a), b)
+broadcastbasis_layout(::typeof(+), _, ::SubBasisLayout, a, b) = broadcastbasis(+, a, parent(b))
 
-broadcastbasis(::typeof(+), a, b) = _broadcastbasis(+, MemoryLayout(a), MemoryLayout(b), a, b)
+broadcastbasis(::typeof(+), a, b) = broadcastbasis_layout(+, MemoryLayout(a), MemoryLayout(b), a, b)
 broadcastbasis(::typeof(+), a, b, c...) = broadcastbasis(+, broadcastbasis(+, a, b), c...)
 
 broadcastbasis(::typeof(-), a, b) = broadcastbasis(+, a, b)
@@ -426,7 +426,7 @@ end
 # end
 
 
-function _equals(::ExpansionLayout, ::ExpansionLayout, f, g)
+function equals_layout(::ExpansionLayout, ::ExpansionLayout, f, g)
     S,c = arguments(f)
     T,d = arguments(g)
     ST = broadcastbasis(+, S, T)

src/maps.jl

@@ -117,6 +117,7 @@ end
 AffineMap(domain::AbstractQuasiVector{T}, range::AbstractQuasiVector{V}) where {T,V} =
     AffineMap{promote_type(T,V), typeof(domain),typeof(range)}(domain,range)
 
+union(d::AffineMap) = d.range
 measure(x::Inclusion{<:Any,<:AbstractInterval}) = last(x)-first(x)
 
 function getproperty(A::AffineMap, d::Symbol)

src/plotting.jl

@@ -12,29 +12,37 @@ the number of coefficients.
 
 plotgrid(P, n...) = plotgrid_layout(MemoryLayout(P), P, n...)
 
-plotgrid_layout(lay, P, n=size(P,2)) = grid(P, min(n,MAX_PLOT_POINTS))
-
+plotgrid_layout(lay, P, n...) = plotgrid_size(size(P), P, n...)
+plotgrid_size(::Tuple{InfiniteCardinal{1}}, P, n...) = plotgrid(expand(P), n...)
+plotgrid_size(sz, P, n=size(P,2)) = grid(P, min(n,MAX_PLOT_POINTS))
 plotgrid_layout(::WeightedBasisLayouts, wP, n...) = plotgrid(unweighted(wP), n...)
 plotgrid_layout(::MappedBasisLayout, P, n...) = invmap(parentindices(P)[1])[plotgrid(demap(P), n...)]
 plotgrid_layout(::SubBasisLayout, P::AbstractQuasiMatrix, n) = plotgrid(parent(P), maximum(parentindices(P)[2][n]))
 plotgrid_layout(::SubBasisLayout, P::AbstractQuasiMatrix) = plotgrid(parent(P), maximum(parentindices(P)[2]))
 
-const _plotgrid = plotgrid_layout # TODO: remove
-
 
 _mul_plotgrid(_, args) = plotgrid_layout(UnknownLayout(), first(args))
-_mul_plotgrid(::Tuple{Any,PaddedLayout}, (P,c)) = plotgrid(P, maximum(colsupport(c)))
+_mul_plotgrid(::Tuple{Any,PaddedLayout}, (P,c)) = plotgrid(P, last(colsupport(c)))
 
 function plotgrid_layout(lay::ExpansionLayout, P)
     args = arguments(lay,P)
     _mul_plotgrid(map(MemoryLayout,args), args)
 end
 
-plotvalues(g::AbstractQuasiVector, x) = g[x]
-plotvalues(g::AbstractQuasiMatrix, x) = g[x,:]
-plotvalues(g::AbstractQuasiArray) = plotvalues(g, plotgrid(g))
+plotvalues_size(::Tuple{InfiniteCardinal{1}}, g, x=plotgrid(g)) = g[x]
+plotvalues_size(::Tuple{InfiniteCardinal{1},Int}, g, x=plotgrid(g)) = g[x,:]
+plotvalues_layout(lay, g, x...) = plotvalues_size(size(g), g, x...)
+# plotvalues_layout(::WeightedBasisLayouts, wP, n...) = plotvalues(unweighted(wP), n...)
+plotvalues_layout(::ExpansionLayout{MappedBasisLayout}, g, x...) = plotvalues(demap(g))
+# plotvalues_layout(::SubBasisLayout, P::AbstractQuasiMatrix, n) = plotvalues(parent(P), maximum(parentindices(P)[2][n]))
+# plotvalues_layout(::SubBasisLayout, P::AbstractQuasiMatrix) = plotvalues(parent(P), maximum(parentindices(P)[2]))
+
+plotvalues(g::AbstractQuasiArray, x...) = plotvalues_layout(MemoryLayout(g), g, x...)
 
 function plotgridvalues(g)
     x = plotgrid(g)
     x, plotvalues(g,x)
 end
+
+_split_svec(x) = (x,)
+_split_svec(x::AbstractArray{<:StaticVector{2}}) = (map(first,x), map(last,x))

test/runtests.jl

@@ -1,7 +1,7 @@
-using ContinuumArrays, QuasiArrays, IntervalSets, DomainSets, FillArrays, LinearAlgebra, BandedMatrices, InfiniteArrays, Test, Base64, RecipesBase
+using ContinuumArrays, QuasiArrays, IntervalSets, DomainSets, FillArrays, LinearAlgebra, BandedMatrices, InfiniteArrays, Test, Base64
 import ContinuumArrays: ℵ₁, materialize, AffineQuasiVector, BasisLayout, AdjointBasisLayout, SubBasisLayout, ℵ₁,
                         MappedBasisLayout, AdjointMappedBasisLayouts, MappedWeightedBasisLayout, TransformFactorization, Weight, WeightedBasisLayout, SubWeightedBasisLayout, WeightLayout,
-                        basis, invmap, Map, checkpoints, plotgrid_layout, mul, plotvalues
+                        basis, invmap, Map, checkpoints, plotgrid, plotgrid_layout, mul, plotvalues
 import QuasiArrays: SubQuasiArray, MulQuasiMatrix, Vec, Inclusion, QuasiDiagonal, LazyQuasiArrayApplyStyle, LazyQuasiArrayStyle
 import LazyArrays: MemoryLayout, ApplyStyle, Applied, colsupport, arguments, ApplyLayout, LdivStyle, MulStyle
 
@@ -85,44 +85,16 @@ include("test_splines.jl")
 include("test_chebyshev.jl")
 include("test_basisconcat.jl")
 
-@testset "Plotting" begin
-    L = LinearSpline(0:5)
-    rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), L)
-    @test rep[1].args == (L.points,L[L.points,:])
-
-    rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), L[:,1:3])
-    @test rep[1].args == (L.points,L[L.points,1:3])
-
-    @test plotgrid(L[:,1:3],3) == grid(L[:,1:3]) == grid(L[:,1:3],3) == L.points
-    
-
-    u = L*randn(6)
-    rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), u)
-    @test rep[1].args == (L.points,u[L.points])
+@testset "Grids/values" begin
+    L = LinearSpline(1:5)
+    c = randn(5)
+    u = L*c
     @test plotvalues(u) == u[plotgrid(u)]
 
-    @testset "padded" begin
-        u = L * Vcat(rand(3), Zeros(3))
-        rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), u)
-        @test rep[1].args == (L.points,u[L.points])
-    end
-
-    @testset "Chebyshev and weighted Chebyshev" begin
-        T =  Chebyshev(10)
-        w =  ChebyshevWeight()
-        wT = w .* T
-        x =  axes(T, 1)
-    
-        u = T * Vcat(rand(3), Zeros(7))
-        v = wT * Vcat(rand(3), Zeros(7))
-    
-        rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), u)
-        @test rep[1].args == (grid(T), u[grid(T)])
-        wrep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), v)
-        @test wrep[1].args == (grid(wT), v[grid(wT)])
-    
-        @test plotgrid(v) == plotgrid(u) == grid(T) == grid(wT) == plotgrid_layout(MemoryLayout(v), v) == plotgrid_layout(MemoryLayout(u), u)
-        y = affine(0..1, x)
-        @test plotgrid(T[y,:]) == (plotgrid(T) .+ 1)/2
-    end
+    a = affine(0..1, 1..5)
+    v = L[a,:] * c
+    @test plotvalues(v) == v[plotgrid(v)]
 end
+
+include("test_recipesbaseext.jl")
+include("test_makieext.jl")

test/test_makieext.jl

@@ -0,0 +1,15 @@
+using ContinuumArrays, Test
+import Makie
+import Makie: Point
+
+@testset "Plotting" begin
+    L = LinearSpline(0:5)
+    u = L*(2:7)
+
+    fig = Makie.lines(u);
+    @test fig.plot.positions[] == Point.(0:5, 2:7)
+    fig = Makie.plot(u);
+    @test fig.plot.positions[] == Point.(0:5, 2:7)
+    fig = Makie.plot(L);
+    @test fig.plot.P[] == L
+end

test/test_recipesbaseext.jl

@@ -0,0 +1,43 @@
+using ContinuumArrays, Test
+import RecipesBase
+
+@testset "Plotting" begin
+    L = LinearSpline(0:5)
+    rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), L)
+    @test rep[1].args == (L.points,L[L.points,:])
+
+    rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), L[:,1:3])
+    @test rep[1].args == (L.points,L[L.points,1:3])
+
+    @test plotgrid(L[:,1:3],3) == grid(L[:,1:3]) == grid(L[:,1:3],3) == L.points
+    
+
+    u = L*randn(6)
+    rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), u)
+    @test rep[1].args == (L.points,u[L.points])
+
+    @testset "padded" begin
+        u = L * Vcat(rand(3), Zeros(3))
+        rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), u)
+        @test rep[1].args == (L.points,u[L.points])
+    end
+
+    @testset "Chebyshev and weighted Chebyshev" begin
+        T =  Chebyshev(10)
+        w =  ChebyshevWeight()
+        wT = w .* T
+        x =  axes(T, 1)
+    
+        u = T * Vcat(rand(3), Zeros(7))
+        v = wT * Vcat(rand(3), Zeros(7))
+    
+        rep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), u)
+        @test rep[1].args == (grid(T), u[grid(T)])
+        wrep = RecipesBase.apply_recipe(Dict{Symbol, Any}(), v)
+        @test wrep[1].args == (grid(wT), v[grid(wT)])
+    
+        @test plotgrid(v) == plotgrid(u) == grid(T) == grid(wT) == plotgrid_layout(MemoryLayout(v), v) == plotgrid_layout(MemoryLayout(u), u)
+        y = affine(0..1, x)
+        @test plotgrid(T[y,:]) == (plotgrid(T) .+ 1)/2
+    end
+end