drop StaticArrays

Author: sjkelly

src/Contour.jl

@@ -1,7 +1,5 @@
 module Contour
 
-using StaticArrays
-
 include("interpolate.jl")
 
 export
@@ -17,17 +15,17 @@ export
 import Base: push!, length, eltype, show
 
 struct Curve2{T}
-    vertices::Vector{NTuple{2,T}}
+    vertices::Vector{T}
 end
-Curve2(::Type{T}) where {T} = Curve2(SVector{2,T}[])
+Curve2(::Type{T}) where {T} = Curve2(T[])
 show(io::IO, ::MIME"text/plain", c2::Curve2) = write(io, "$(typeof(c2))\n  with $(length(c2.vertices)-1) vertices")
 show(io::IO, ::MIME"text/plain", c2s::Vector{Curve2{T}}) where {T} = write(io, "$(typeof(c2s))\n  $(length(c2s)) contour line(s)")
 
-struct ContourLevel{T}
-    level::T
+struct ContourLevel{T, L}
+    level::L
     lines::Vector{Curve2{T}}
 end
-ContourLevel(h::T) where {T <: AbstractFloat} = ContourLevel(h, Curve2{T}[])
+ContourLevel(h::T) where {T <: AbstractFloat} = ContourLevel(h, Curve2{NTuple{2,T}}[])
 ContourLevel(h::T) where {T} = ContourLevel(Float64(h))
 show(io::IO, ::MIME"text/plain", cl::ContourLevel) = write(io, "$(typeof(cl))\n  at $(level(cl)) with $(length(lines(cl))) line(s)")
 show(io::IO, ::MIME"text/plain", cls::Vector{ContourLevel{T}}) where {T} = write(io, "$(typeof(cls))\n  $(length(cls)) contour level(s)")
@@ -62,11 +60,12 @@ argument `level`.
 You'll usually call [`lines`](@ref) on the output of `contour`, and then iterate
 over the result.
 """
-function contour(x, y, z, level::Number)
+function contour(x, y, z, level::Number; VT=nothing)
     if !(axes(x) == (axes(z,1),) && axes(y) == (axes(z,2),) || axes(x) == axes(y) == axes(z))
         throw(ArgumentError("Incompatible input axes in `Contour.contour`."))
     end
-    trace_contour(x, y, z, level, get_level_cells(z, level))
+    VT = VT === nothing ? NTuple{2,promote_type(map(eltype, (x, y, z))...)} : VT
+    trace_contour(x, y, z, level, get_level_cells(z, level), VT)
 end
 
 """
@@ -111,8 +110,9 @@ a tuple of lists.
 """
 function coordinates(c::Curve2{T}) where {T}
     N = length(c.vertices)
-    xlist = Vector{T}(undef, N)
-    ylist = Vector{T}(undef, N)
+    E = eltype(T)
+    xlist = Vector{E}(undef, N)
+    ylist = Vector{E}(undef, N)
 
     for (i, v) in enumerate(c.vertices)
         xlist[i] = v[1]
@@ -264,17 +264,15 @@ function chase!(cells, curve, x, y, z, h, start, entry_edge, xi_range, yi_range,
 end
 
 
-function trace_contour(x, y, z, h::Number, cells::Dict)
+function trace_contour(x, y, z, h::Number, cells::Dict, VT)
 
-    contours = ContourLevel(h)
+    contours = ContourLevel(h, Curve2{VT}[])
 
     x_ax, y_ax = axes(z)
     xi_range = first(x_ax):last(x_ax)-1
     yi_range = first(y_ax):last(y_ax)-1
 
 
-    VT = NTuple{2,promote_type(map(eltype, (x, y, z))...)}
-
     # When tracing out contours, this algorithm picks an arbitrary
     # starting cell, then first follows the contour in one direction
     # until it either ends up where it started # or at one of the boundaries.

test/runtests.jl

@@ -3,7 +3,7 @@ using Contour, Test
 include("verify_vertices.jl")
 include("interface.jl")
 
-@test length(detect_ambiguities(Base, Contour)) <= 4 # should be zero but there are a few stragglers in the imports
+#@test length(detect_ambiguities(Base, Contour)) <= 4 # should be zero but there are a few stragglers in the imports
 
 #issue 59
 @inferred collect(())

test/verify_vertices.jl

@@ -21,7 +21,7 @@ Y = collect(0:Δ:3) .+ φ
 Z = [(x^2 + y^2)::Float64 for x in X, y in Y]
 h = rand() * (maximum(Z) - minimum(Z)) + minimum(Z)
 
-contourlevels = Contour.contour(X, Y, Z, h)
+contourlevels = Contour.contour(X, Y, Z, h; VT=SVector{2,Float64})
 for line in contourlevels.lines
     # Contour vertices lie on a circle around the origin
     for v in line.vertices
@@ -42,7 +42,7 @@ h = 1
 x0, y0 = (.5, -1.5)
 Z = Float64[(x - x0)^2 + (y - y0)^2 for x in X, y in Y]
 
-contourlevels = Contour.contour(X, Y, Z, h)
+contourlevels = Contour.contour(X, Y, Z, h, VT=SVector{2,Float64})
 for line in contourlevels.lines
     for v in line.vertices
         @test isapprox((v[1] - x0)^2 + (v[2] - y0)^2, h, atol=0.01Δ)
@@ -104,7 +104,7 @@ Z = float([0 1;
            1 0])
 h = 0.9
 
-lines = Contour.contour(X, Y, Z, h).lines
+lines = Contour.contour(X, Y, Z, h, VT=SVector{2, Float64}).lines
 @test length(lines) == 2
 
 for line in lines
@@ -120,7 +120,7 @@ R = range(1.0, stop=2.0, length=100)
 x, y, z = real.(ζ), imag.(ζ), abs.(ζ)
 
 h = 1 + rand()
-xs, ys = coordinates(contour(x, y, z, h).lines[1])
+xs, ys = coordinates(contour(x, y, z, h, VT=SVector{2, Float64}).lines[1])
 @test all(xs.^2 + ys.^2 .≈ h^2)
 
 
@@ -131,8 +131,8 @@ zoff = OffsetArray(z, offset_x, offset_y)
 
 x, y = axes(z)
 xoff, yoff = axes(zoff)
-curves = Contour.contour(x,y,z,0.5)
-curves_off = Contour.contour(xoff, yoff, zoff, 0.5)
+curves = Contour.contour(x,y,z,0.5, VT=SVector{2, Float64})
+curves_off = Contour.contour(xoff, yoff, zoff, 0.5,VT=SVector{2, Float64})
 
 # sort offset and non-offset curves to the same order
 offset = SVector(offset_x, offset_y)
@@ -172,7 +172,7 @@ Y = collect(-3:Δ:3)
 Z = [(x^2 - y^2)::Float64 for x in X, y in Y]
 h = rand() * (maximum(Z) - minimum(Z)) + minimum(Z)
 
-contourlevels = Contour.contour(X, Y, Z, h)
+contourlevels = Contour.contour(X, Y, Z, h) #, VT=SVector{2, Float64})
 for line in contourlevels.lines
     # Contour vertices lie on a circle around the origin
     for v in line.vertices