simplify spy plot + fix aliasing

Author: rokke-git

src/sparsematrix.jl

@@ -406,106 +406,46 @@ end
 
 const brailleBlocks = UInt16['⠁', '⠂', '⠄', '⡀', '⠈', '⠐', '⠠', '⢀']
 function _show_with_braille_patterns(io::IO, S::AbstractSparseMatrixCSCInclAdjointAndTranspose)
+    # The maximum number of characters we allow to display the matrix
+    h, w = get(io, :limit, false) ? displaysize(io) .- (4, 2) : (typemax(Int)÷4, typemax(Int)÷2)
     m, n = size(S)
-    (m == 0 || n == 0) && return show(io, MIME("text/plain"), S)
-
-    # The maximal number of characters we allow to display the matrix
-    local maxHeight::Int, maxWidth::Int
-    maxHeight = displaysize(io)[1] - 4 # -4 from [Prompt, header, newline after elements, new prompt]
-    maxWidth = displaysize(io)[2] - 2 # -2 from brackets
 
     warn = false
     try
         zero(eltype(S))
     catch
         warn = true
-        maxHeight -= 1
-    end
-
-    # In the process of generating the braille pattern to display the nonzero
-    # structure of `S`, we need to be able to scale the matrix `S` to a
-    # smaller matrix with the same aspect ratio as `S`, but fits on the
-    # available screen space. The size of that smaller matrix is stored
-    # in the variables `scaleHeight` and `scaleWidth`. If no scaling is needed,
-    # we can use the size `m × n` of `S` directly.
-    # We determine if scaling is needed and set the scaling factors
-    # `scaleHeight` and `scaleWidth` accordingly. Note that each available
-    # character can contain up to 4 braille dots in its height (⡇) and up to
-    # 2 braille dots in its width (⠉).
-    if get(io, :limit, false) && (m > 4maxHeight || n > 2maxWidth)
-        s = min(2maxWidth / n, 4maxHeight / m)
-        scaleHeight = floor(Int, s * m)
-        scaleWidth = floor(Int, s * n)
-    else
-        scaleHeight = m
-        scaleWidth = n
-    end
-
-    # Make sure that the matrix size is big enough to be able to display all
-    # the corner border characters
-    if scaleHeight < 8
-        scaleHeight = 8
-    end
-    if scaleWidth < 4
-        scaleWidth = 4
+        h -= 1
     end
 
-    # `brailleGrid` is used to store the needed braille characters for
-    # the matrix `S`. Each row of the braille pattern to print is stored
-    # in a column of `brailleGrid`.
-    brailleGrid = fill(UInt16(10240), (scaleWidth - 1) ÷ 2 + 4, (scaleHeight - 1) ÷ 4 + 1)
-    brailleGrid[1,:] .= '⎢'
-    brailleGrid[end-1,:] .= '⎥'
-    brailleGrid[1,1] = '⎡'
-    brailleGrid[1,end] = '⎣'
-    brailleGrid[end-1,1] = '⎤'
-    brailleGrid[end-1,end] = '⎦'
-    brailleGrid[end, :] .= '\n'
-
-    rvals = rowvals(parent(S))
-    rowscale = max(1, scaleHeight - 1) / max(1, m - 1)
-    colscale = max(1, scaleWidth - 1) / max(1, n - 1)
+    # In order to prevent aliasing, we only scale down by full integers.
+    # While 1 to 1/2 is a big jump, it's less noticeable as you get bigger.
+    # Note each character has 4 dots of height and 2 dots of width.
+    scale = max(n÷2w, m÷4h) + 1
+    char_h, char_w = fld1(m, 4scale), fld1(n, 2scale)
 
-    if rowscale != 1 || colscale != 1
-        print(io, " (downscaled to fit on screen)")
-    end
+    scale != 1 && print(io, " (displaying at 1/$scale scale)")
     println(io, ":")
     warn && printstyled(stderr, "WARNING: could not find generic zero for given elements. expect errors and wrong results\n", color=:red)
 
-    if isa(S, AbstractSparseMatrixCSC)
-        @inbounds for j in axes(S,2)
-            # Scale the column index `j` to the best matching column index
-            # of a matrix of size `scaleHeight × scaleWidth`
-            sj = round(Int, (j - 1) * colscale + 1)
-            for x in nzrange(S, j)
-                # Scale the row index `i` to the best matching row index
-                # of a matrix of size `scaleHeight × scaleWidth`
-                si = round(Int, (rvals[x] - 1) * rowscale + 1)
-
-                # Given the index pair `(si, sj)` of the scaled matrix,
-                # calculate the corresponding triple `(k, l, p)` such that the
-                # element at `(si, sj)` can be found at position `(k, l)` in the
-                # braille grid `brailleGrid` and corresponds to the 1-dot braille
-                # character `brailleBlocks[p]`
-                k = (sj - 1) ÷ 2 + 2
-                l = (si - 1) ÷ 4 + 1
-                p = ((sj - 1) % 2) * 4 + ((si - 1) % 4 + 1)
-
-                brailleGrid[k, l] |= brailleBlocks[p]
-            end
+    # Rows of output are cols of `brailleGrid` since julia is column-major
+    brailleGrid = fill(UInt16(10240), char_w + 3, char_h)
+    brailleGrid[[1,end-1,end],:] .= ['⎢', '⎥', '\n']
+    brailleGrid[[1,end-1],[1,end]] .= ['⎡' '⎣';'⎤' '⎦']
+    char_h == 1 && (brailleGrid[[1,end-1],1] .= ['[', ']'])
+
+    rinds = rowvals(parent(S))
+    cinds = ColumnIndices(parent(S))
+
+    if S isa AbstractSparseMatrixCSC
+        for cords in zip(rinds, cinds)
+            row, col = fld1.(cords, scale) |>x-> fldmod1.(x, (4, 2))
+            brailleGrid[col[1]+1, row[1]] |= brailleBlocks[row[2] + 4(col[2]-1)]
         end
-    else
-        # If `S` is a adjoint or transpose of a sparse matrix we invert the
-        # roles of the indices `i` and `j`
-        @inbounds for i = 1:m
-            si = round(Int, (i - 1) * rowscale + 1)
-            for x in nzrange(parent(S), i)
-                sj = round(Int, (rvals[x] - 1) * colscale + 1)
-                k = (sj - 1) ÷ 2 + 2
-                l = (si - 1) ÷ 4 + 1
-                p = ((sj - 1) % 2) * 4 + ((si - 1) % 4 + 1)
-                brailleGrid[k, l] |= brailleBlocks[p]
-            end
+    else # swap rows / cols for adj and transpose
+        for cords in zip(rinds, cinds)
+            col, row = fld1.(cords, scale) |>x-> fldmod1.(x, (2, 4))
+            brailleGrid[col[1]+1, row[1]] |= brailleBlocks[row[2] + 4(col[2]-1)]
         end
     end
     foreach(c -> print(io, Char(c)), @view brailleGrid[1:end-1])

test/sparsematrix_constructors_indexing.jl

@@ -1529,12 +1529,7 @@ end
         "2×1 $Adjoint{Float64, $SparseMatrixCSC{Float64, Int64}} with 2 stored entries:\n 1.0\n 2.0",
         "2×1 $Transpose{Float64, $SparseMatrixCSC{Float64, Int64}} with 2 stored entries:\n 1.0\n 2.0",
         ),
-        ("⎡⠁⠈⎤\n" *
-         "⎣⠀⠀⎦",
-         "⎡⠁⠀⎤\n" *
-         "⎣⡀⠀⎦",
-         "⎡⠁⠀⎤\n" *
-         "⎣⡀⠀⎦"))
+        ("\n[⠉]", "\n[⠃]", "\n[⠃]"))
         show(io, MIME"text/plain"(), transform(A))
         @test String(take!(io)) == showstring
         _show_with_braille_patterns(convert(IOContext, io), transform(A))
@@ -1555,9 +1550,9 @@ end
     end
 
     # empty braille pattern Char(10240)
-    A = spzeros(Int64, Int64, 4, 2)
+    A = spzeros(Int64, Int64, 2, 2)
     for transform in (identity, adjoint, transpose)
-        expected = "⎡" * Char(10240)^2 * "⎤\n⎣" * Char(10240)^2 * "⎦"
+        expected = ":\n[" * Char(10240) * "]"
         _show_with_braille_patterns(convert(IOContext, io), transform(A))
         @test contains(String(take!(io)), expected)
     end
@@ -1569,12 +1564,7 @@ end
         "2×4 $Adjoint{Int64, $SparseMatrixCSC{Int64, Int64}} with 5 stored entries:\n 1  1  ⋅  1\n ⋅  1  1  ⋅",
         "2×4 $Transpose{Int64, $SparseMatrixCSC{Int64, Int64}} with 5 stored entries:\n 1  1  ⋅  1\n ⋅  1  1  ⋅",
         ),
-        ("⎡⠅⠠⎤\n" *
-         "⎣⡀⠐⎦",
-         "⎡⠉⠈⎤\n" *
-         "⎣⢀⡀⎦",
-         "⎡⠉⠈⎤\n" *
-         "⎣⢀⡀⎦"))
+        ("\n[⡳]", "\n[⠙⠊]", "\n[⠙⠊]"))
         show(io, MIME"text/plain"(), transform(A))
         @test String(take!(io)) == showstring
         _show_with_braille_patterns(convert(IOContext, io), transform(A))
@@ -1590,10 +1580,8 @@ end
         ),
         ("⎡⢕⠀⎤\n" *
          "⎣⠀⠀⎦",
-         "⎡⢁⢁⠀⠀⎤\n" *
-         "⎣⠀⠀⠀⠀⎦",
-         "⎡⢁⢁⠀⠀⎤\n" *
-         "⎣⠀⠀⠀⠀⎦"))
+         "[⠑⠑⠀⠀]",
+         "[⠑⠑⠀⠀]"))
         show(io, MIME"text/plain"(), transform(A))
         @test String(take!(io)) == showstring
         _show_with_braille_patterns(convert(IOContext, io), transform(A))
@@ -1622,22 +1610,18 @@ end
     # vertical scaling
     ioc = IOContext(io, :displaysize => (5, 80), :limit => true)
     _show_with_braille_patterns(ioc, _filled_sparse(10, 10))
-    @test contains(String(take!(io)), "⎡⣿⣿⎤\n" *
-                                      "⎣⣿⣿⎦")
+    @test contains(String(take!(io)), "\n[⣿⣿]")
 
     _show_with_braille_patterns(ioc, _filled_sparse(20, 10))
-    @test contains(String(take!(io)), "⎡⣿⣿⎤\n" *
-                                      "⎣⣿⣿⎦")
+    @test contains(String(take!(io)), "\n[⣿]")
 
     # horizontal scaling
     ioc = IOContext(io, :displaysize => (80, 4), :limit => true)
     _show_with_braille_patterns(ioc, _filled_sparse(8, 8))
-    @test contains(String(take!(io)), "⎡⣿⣿⎤\n" *
-                                      "⎣⣿⣿⎦")
+    @test contains(String(take!(io)), "\n[⠿⠇]")
 
     _show_with_braille_patterns(ioc, _filled_sparse(8, 16))
-    @test contains(String(take!(io)), "⎡⣿⣿⎤\n" *
-                                      "⎣⣿⣿⎦")
+    @test contains(String(take!(io)), "\n[⠛⠛]")
 
     # respect IOContext while displaying J
     I, J, V = shuffle(1:50), shuffle(1:50), [1:50;]