10秒钟内可获得27亿积分

struct MMapString{T} 
    # using Type parameter to not write out the result type of mmap
    # but I also don't want to loose performance
    x::T 
end

# Constructor from a path
MMapString(path::String) = MMapString(Mmap.mmap(open(path), Vector{UInt8}))
# we only need to overload the iteration protocol for TextParse to work!
Base.getindex(x::MMapString, i) = Char(x.x[i])
Base.next(x::MMapString, i) = Char(x.x[i]), i + 1
Base.done(x::MMapString, i) = i > length(x.x)
Base.start(x::MMapString, i) = 1
Base.length(x::MMapString) = length(x.x)

using TextParse
using TextParse: Record, Field, Numeric, tryparsenext

function uuwrite(io, ptr::T) where T
    Int(ccall(
       :ios_write, 
       Csize_t, (Ptr{Void}, Ptr{T}, Csize_t), 
       io.ios, &ptr, sizeof(T))
    )
end

function save2bin(path, n = typemax(Int))
    str = MMapString(path)
    # Descriptor of 'num,num\n' which is the format in the csv
    rec = Record((
            Field(Numeric(Float32), delim = ','), 
            Field(Numeric(Float32), eoldelim = true)
    ))
    # skip the header! Nice is, that Julia's findfirst works with 
    # any iterator
    pos = findfirst(str, '\n') + 1 
    io = open(homedir()*"/gpspoints.bin", "w")
    i = 0
    while !done(str, pos) && i <= n
        # tryparsenext takes roughly 35ns so it's fairly optimal  
        p_or_null, pos = tryparsenext(
            rec, str, pos, length(str)
        )
        isnull(p_or_null) && continue # continue when parsing fails
        p = get(p_or_null)
        uuwrite(io, p)
        i += 1
    end
    close(io)
    i
end
tic()
@time save2bin(homedir() * "/Downloads/gps-points.csv");
toc()

"""
Transforms from longitude/latitude to pixel on screen, with `dims` refering to 
the dimensions of the screen in pixel
"""
@inline function gps2pixel(point, dims)
    lon, lat = point[1], point[2]
    x = ((dims[1] / 180.0) * (90.0 + (lon / 10^7)))
    y = ((dims[2] / 360.0) * (180.0 - (lat / 10^7)))
    (x, y)
end

function to_image_inner!(img, points, start, stop)
    dims = size(img)
    for i = start:stop
        # don't check bounds when indexing into an array
@inbounds begin 
            p0 = gps2pixel(points[i], dims)
            idx = Int.(round.(p0))
            xidx, yidx = dims[1] - idx[1], dims[2] - idx[2]
            if checkbounds(Bool, img, xidx, yidx)
                # we should give each point a radius and then add
                # the coverage to each pixel for a smoother image
                # But this does well enough for this short example:
                img[xidx, yidx] += 0.001f0 # accumulate
            end
        end
    end
end
function to_image!(img, points, range)
    N = length(range)
    # Number of threads Julia has available
    # Use the environment variable JULIA_NUM_THREADS=8 to start
    # Julia with 8 threads
    NT = Threads.nthreads() 
    slices = floor(Int, N / NT)
    offset = minimum(range)
    Threads. @threads for i = 1:NT
        # @threads creates a closure, which sometimes 
        # confuses type inference leading to slow code.
        # this is why it's a good practice to move the loop body 
        # behind a function barrier
        # ( https://docs.julialang.org/en/latest/manual/performance-tips/#kernal-functions-1 )
        to_image_inner!(
            img, points, 
            offset + ((i-1) * slices + 1), offset + (i * slices)
        )
    end
    return img
end

img = zeros(Float32, 600, 960)
io = open(homedir() * "/gpspoints.bin")
points = Mmap.mmap(io, Vector{NTuple{2, Float32}})
tic()
to_image!(img, points, 1:length(points))
toc()
using FileIO, Colors # save it with FileIO as a Gray image
FileIO.save("gps.png", Gray.(clamp.(1f0 .- img, 0, 1)))

Gray.(clamp.(1f0 .- img, 0, 1)))

using MakiE

resolution = (600, 960)
scene = Scene(resolution = reverse(resolution))
img = zeros(Float32, resolution)
imviz = heatmap(img, colornorm = (0, 1))
center!(scene)
# slice `points` into multiple batches which we will update
slice = 10^7
range = slice:slice:length(points)
stop = 1
vio = VideoStream(scene, homedir()*"/Desktop/", "gps")
while true
    start = stop
    stop = min(stop + slice, length(points))
    to_image!(img, points, start:stop)
    imviz[:heatmap] = img # update heatmap plot
    recordframe!(vio) # add frame to stream
    stop == length(points) && break
end
finish(vio, "gif") # finish streaming and export as gif!