{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Guerrilla traffic speed monitoring to inform and push for change\n", "\n", "#### *(or: using open source software and readily available tools to see how fast cars move on Forbes Ave)*\n", "\n", "October was a tragic month for the Oakland community in Pittsburgh. Two pedestrians and a cyclist were killed in car crashes within four days of each other. While the collisions are still under investigation, I have a strong suspicion that speed was a major factor in both. The survivability of a crash decreases very dramatically as speed increases from 20 to 40 miles per hour [[1]](http://humantransport.org/sidewalks/SpeedKills.htm).\n", "\n", "There's been a number of calls for traffic calming measures along Forbes Avenue, which is one of the few routes east for both cars and cyclists. I was curious what the current average traffic speed is, and if we could strengthen these calls with some real data. Even though there's no public data and I don't have a RADAR gun, it's possible to collect this myself with just a high vantage point, a cell phone video, and basic computer vision techniques.\n", "\n", "The stretch of Forbes Avenue that I'd like to focus on is between Pitt and CMU:\n", "[![Overview map of Forbes Ave, courtesy of Google Maps](assets/overviewmap.png)](https://www.google.com/maps/dir/40.4432009,-79.9535004/40.4446433,-79.9430188/@40.4421918,-79.9560178,16z/data=!4m2!4m1!3e1)\n", "\n", "It's here that the road and surrounding area \"opens up.\" The previous 8-10 blocks go through the tightly packed Oakland business district, with timed traffic lights (matching the 25MPH speed limit) at every intersection. Once you reach Schenley Plaza, though, the buildings recede away and there's a sense of freedom. I also believe that the timings of lights change at this point, too, allowing you to exceed 25MPH for the first time since the highway exit. Once you get to the Natural History museum, a fourth travel lane is added on the left and the right lane turns into an unmarked, 20ft wide luxury lane. The right side of this lane is intended as a bus stop, but the lack of markings makes it a bit of a free-for-all when there aren't any busses. I believe that all these things contribute to an overall increase in speed.\n", "\n", "I don't have a RADAR gun, but I do have a cell phone and access to the Cathedral of Learning. At 3:30pm on Friday afternoon, I recorded 10 minutes of traffic on Forbes Ave. Here's a snippet of what this looked like:\n", "![Two second snippet of the raw footage](assets/movieclip.gif)\n", "\n", "You can see Dippy the Dino on the top left, with Schenley Plaza on the top right, and the intersection with Schenley Drive Extension in between. Unfortunately the trees obscure the section of the road where I think traffic moves the fastest, but there's a great view of about 300ft of the road. I rotated and cropped the image, used basic image processing techniques to detect objects and their locations, converted pixels to meters, and computed their speeds. The full analysis is documented below. It worked surprisingly well:\n", "![The same two second snippet, but rotated, cropped, and annotated with speeds in MPH](assets/processedclip.gif)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analysis\n", "\n", "I'll use Julia v0.4 and a bunch of Julia packages to do this analysis, but the concepts are applicable in any language. Unless otherwise noted, all code is copyright 2015 Matt Bauman, available for use with attribution under the [MIT license](http://opensource.org/licenses/MIT). All videos and images are similarly copyright 2015 Matt Bauman, available for use with attribution under the Creative Commons Attribution 4.0 International License ([CC-BY](https://creativecommons.org/licenses/by/4.0/)).\n", "\n", "First, there's some setup. I try to make use of as many existing packages as possible. I also define a few helper utilities up front." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false, "scrolled": false }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING: New definition \n", " ./(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " ./(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:55.\n", "To fix, define \n", " ./(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: New definition \n", " +(AbstractArray, DataArrays.DataArray) at /Users/jehiah/.julia/v0.4/DataArrays/src/operators.jl:326\n", "is ambiguous with: \n", " +(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:18.\n", "To fix, define \n", " +(Images.AbstractImageDirect, DataArrays.DataArray)\n", "before the new definition.\n", "WARNING: New definition \n", " +(AbstractArray, DataArrays.AbstractDataArray) at /Users/jehiah/.julia/v0.4/DataArrays/src/operators.jl:349\n", "is ambiguous with: \n", " +(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:18.\n", "To fix, define \n", " +(Images.AbstractImageDirect, DataArrays.AbstractDataArray)\n", "before the new definition.\n", "WARNING: New definition \n", " .-(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " .-(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:40.\n", "To fix, define \n", " .-(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: New definition \n", " .==(AbstractArray{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:330\n", "is ambiguous with: \n", " .==(Images.AbstractImageDirect{Bool, N<:Any}, AbstractArray{Bool, N<:Any}) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:135.\n", "To fix, define \n", " .==(Images.AbstractImageDirect{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}})\n", "before the new definition.\n", "WARNING: New definition \n", " .==(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " .==(Images.AbstractImageDirect{Bool, N<:Any}, AbstractArray{Bool, N<:Any}) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:135.\n", "To fix, define \n", " .==(Images.AbstractImageDirect{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}})\n", "before the new definition.\n", "WARNING: New definition \n", " .==(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " .==(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:136.\n", "To fix, define \n", " .==(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: New definition \n", " .>(AbstractArray{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:330\n", "is ambiguous with: \n", " .>(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:133.\n", "To fix, define \n", " .>(Images.AbstractImageDirect{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}})\n", "before the new definition.\n", "WARNING: New definition \n", " .>(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " .>(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:133.\n", "To fix, define \n", " .>(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: New definition \n", " -(DataArrays.DataArray, AbstractArray) at /Users/jehiah/.julia/v0.4/DataArrays/src/operators.jl:326\n", "is ambiguous with: \n", " -(AbstractArray, Images.AbstractImageDirect) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:37.\n", "To fix, define \n", " -(DataArrays.DataArray, Images.AbstractImageDirect)\n", "before the new definition.\n", "WARNING: New definition \n", " -(AbstractArray, DataArrays.DataArray) at /Users/jehiah/.julia/v0.4/DataArrays/src/operators.jl:326\n", "is ambiguous with: \n", " -(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:35.\n", "To fix, define \n", " -(Images.AbstractImageDirect, DataArrays.DataArray)\n", "before the new definition.\n", "WARNING: New definition \n", " -(DataArrays.AbstractDataArray, AbstractArray) at /Users/jehiah/.julia/v0.4/DataArrays/src/operators.jl:349\n", "is ambiguous with: \n", " -(AbstractArray, Images.AbstractImageDirect) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:37.\n", "To fix, define \n", " -(DataArrays.AbstractDataArray, Images.AbstractImageDirect)\n", "before the new definition.\n", "WARNING: New definition \n", " -(AbstractArray, DataArrays.AbstractDataArray) at /Users/jehiah/.julia/v0.4/DataArrays/src/operators.jl:349\n", "is ambiguous with: \n", " -(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:35.\n", "To fix, define \n", " -(Images.AbstractImageDirect, DataArrays.AbstractDataArray)\n", "before the new definition.\n", "WARNING: New definition \n", " .<(AbstractArray{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:330\n", "is ambiguous with: \n", " .<(Images.AbstractImageDirect{Bool, N<:Any}, AbstractArray{Bool, N<:Any}) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:131.\n", "To fix, define \n", " .<(Images.AbstractImageDirect{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}})\n", "before the new definition.\n", "WARNING: New definition \n", " .<(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " .<(Images.AbstractImageDirect{Bool, N<:Any}, AbstractArray{Bool, N<:Any}) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:131.\n", "To fix, define \n", " .<(Images.AbstractImageDirect{Bool, N<:Any}, Union{DataArrays.DataArray{Bool, N<:Any}, DataArrays.PooledDataArray{Bool, R<:Integer, N<:Any}})\n", "before the new definition.\n", "WARNING: New definition \n", " .<(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:285\n", "is ambiguous with: \n", " .<(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:132.\n", "To fix, define \n", " .<(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: New definition \n", " .+(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}, AbstractArray...) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:297\n", "is ambiguous with: \n", " .+(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:22.\n", "To fix, define \n", " .+(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: New definition \n", " .*(Union{DataArrays.DataArray, DataArrays.PooledDataArray}, AbstractArray...) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:295\n", "is ambiguous with: \n", " .*(AbstractArray, Images.AbstractImageDirect) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:52.\n", "To fix, define \n", " .*(Union{DataArrays.DataArray, DataArrays.PooledDataArray}, Images.AbstractImageDirect)\n", "before the new definition.\n", "WARNING: New definition \n", " .*(AbstractArray, Union{DataArrays.DataArray, DataArrays.PooledDataArray}, AbstractArray...) at /Users/jehiah/.julia/v0.4/DataArrays/src/broadcast.jl:295\n", "is ambiguous with: \n", " .*(Images.AbstractImageDirect, AbstractArray) at /Users/jehiah/.julia/v0.4/Images/src/algorithms.jl:51.\n", "To fix, define \n", " .*(Images.AbstractImageDirect, Union{DataArrays.DataArray, DataArrays.PooledDataArray})\n", "before the new definition.\n", "WARNING: FixedPointNumbers.Ufixed8 is deprecated, use FixedPointNumbers.UFixed{UInt8, 8} instead.\n", " likely near /Users/jehiah/.julia/v0.4/VideoIO/src/avio.jl:18\n", "WARNING: FixedPointNumbers.Ufixed8 is deprecated, use FixedPointNumbers.UFixed{UInt8, 8} instead.\n", " likely near /Users/jehiah/.julia/v0.4/VideoIO/src/avio.jl:18\n" ] } ], "source": [ "using Images, FixedPointNumbers, ImageMagick, Colors, Gadfly, DataFrames, ProgressMeter\n", "import VideoIO" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "write (generic function with 71 methods)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Let's create a GIF to display a snippet of the raw footage. There aren't any (to my knowledge) native\n", "# Julia libraries to work with GIFs, but we have ImageMagick installed through BinDeps, which uses Homebrew\n", "# since I'm on a Mac. So let's just create a simple helper function to shell out to the `convert` binary.\n", "\n", "# Inspired by Tom Breloff's animated plots: https://github.com/tbreloff/Plots.jl/blob/master/src/animation.jl\n", "immutable GIF\n", " data::Vector{UInt8}\n", "end\n", "import Homebrew\n", "\"\"\"\n", " animate(f, n; fps=20, width)\n", "\n", "Call function `f` repeatedly, `n` times. The function `f` must take one argument (the frame number),\n", "and it must return an Image for that frame. Optionally specify the number of frames per second\n", "and a width for proportional scaling (defaults to the actual width).\n", "\"\"\"\n", "function animate(f, n; fps = 20, width=0)\n", " mktempdir() do dir\n", " for i=1:n\n", " img = f(i)\n", " frame = width > 0 ? Images.imresize(img, (width, floor(Int, width/size(img, 1) * size(img, 2)))) : img\n", " Images.save(@sprintf(\"%s/%06d.png\", dir, i), frame)\n", " end\n", " speed = round(Int, 100 / fps)\n", " run(`$(Homebrew.brew_prefix)/bin/convert -delay $speed -loop 0 $dir/*.png $dir/result.gif`)\n", " return GIF(open(readbytes, \"$dir/result.gif\"))\n", " end\n", "end\n", "Base.writemime(io::IO, ::MIME\"text/html\", g::GIF) = write(io, \"\")\n", "Base.write(io::IO, g::GIF) = write(io, g.data)" ] }, { "cell_type": "code", "execution_count": 160, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "length (generic function with 133 methods)" ] }, "execution_count": 160, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# The VideoIO library is really great, but it's missing a random access seeking API.\n", "# This should eventually be pushed upstream (https://github.com/kmsquire/VideoIO.jl/issues/30)\n", "function Base.seek(s::VideoIO.VideoReader, time, video_stream=1)\n", " pCodecContext = s.pVideoCodecContext\n", " seek(s.avin, time, video_stream)\n", " VideoIO.avcodec_flush_buffers(pCodecContext)\n", " s\n", "end\n", "\n", "function Base.seek(avin::VideoIO.AVInput, time, video_stream = 1)\n", " # AVFormatContext\n", " fc = avin.apFormatContext[1]\n", "\n", " # Get stream information\n", " stream_info = avin.video_info[video_stream]\n", " seek_stream_index = stream_info.stream_index0\n", " stream = stream_info.stream\n", " time_base = stream_info.codec_ctx.time_base\n", " ticks_per_frame = stream_info.codec_ctx.ticks_per_frame\n", "\n", " pos = Int(div(time*time_base.den, time_base.num*ticks_per_frame))\n", " # println(\"seek $pos in $video_stream time_base:$time_base ticks_per_frame:$ticks_per_frame seek_stream_index:$seek_stream_index\")\n", " # Seek\n", " ret = VideoIO.av_seek_frame(fc, seek_stream_index, pos, VideoIO.AVSEEK_FLAG_ANY)\n", "\n", " ret < 0 && throw(ErrorException(\"Could not seek to start of stream\"))\n", "\n", " return avin\n", "end\n", "\n", "# While we're at it, It's very handy to know how many frames there are:\n", "Base.length(s::VideoIO.VideoReader) = s.avin.video_info[1].stream.nb_frames" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# So now we can load our video, seek to a spot with some nice action, and create a GIF for display\n", "io = VideoIO.open(\"IMG_2399.MOV\")\n", "f = VideoIO.openvideo(io)\n", "\n", "seek(f, 5*60+18)\n", "gif = animate(60, fps=30, width=450) do _\n", " read(f, Image)\n", "end\n", "open(\"movieclip.gif\", \"w\") do f\n", " write(f, gif)\n", "end\n", "gif\n", "\n", "# While it's handy to embed gifs into the notebook when working interactively,\n", "# it makes the notebook too big to render online. So instead, just point to the saved file.\n", "display(\"text/html\", \"\"\"\"\"\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Selecting the region of interest\n", "\n", "The very first step in image processing is to define the region of interest. This is often done just by cropping and manually selecting the pixels you're interested in looking at. But in our case we can make life a lot easier if we also rotate the image so the cars just travel along one axis.\n", "\n", "Rotating an image is inherently an interpolation-like process. The naive way to rotate an image is to move the locations of each pixel, but the new locations won't end up at integer coordinates. In order to display the image on the screen, you need to interpolate the value of each new pixel from the nearby rotated pixels. This is hard and requires lots of bookkeeping. The easy way to rotate an image is to tilt your head the opposite direction. Or less facetiously, you can instead rotate the *indices* into the image the opposite direction. This is the approach that AffineTransforms.jl takes, with support for all sorts of transformations. Coupled with Interpolations.jl, this allows for fast and robust lazy transformations." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "rotate_and_crop (generic function with 4 methods)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Interpolations, AffineTransforms\n", "\n", "\"\"\"\n", "Rotate and crop a matrix by the angle θ.\n", "\n", "Optional arguments:\n", "* region - a tuple of two arrays that specify the section of the rotated image to return; defaults to the unrotated viewport\n", "* fill - the value to use for regions that fall outside the rotated image; defaults to zero(T)\n", "\"\"\"\n", "function rotate_and_crop{T}(A::AbstractMatrix{T}, θ, region=(1:size(A, 1), 1:size(A, 2)), fill=zero(T))\n", " etp = extrapolate(interpolate(A, BSpline(Linear()), OnGrid()), fill)\n", " R = TransformedArray(etp, tformrotate(θ))\n", " Base.unsafe_getindex(R, region[1], region[2]) # Extrapolations can ignore bounds checks\n", "end\n", "\n", "# While the above will work for images, it may iterate through them inefficiently depending on the storage order\n", "rotate_and_crop(A::Image, θ, region) = shareproperties(A, rotate_and_crop(A.data, θ, region))" ] }, { "cell_type": "code", "execution_count": 213, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# This is what we actually want: A rotated and cropped image that just shows the unobstructed section of Forbes Ave:\n", "seekstart(f)\n", "img = read(f, Image)\n", "# Images.save(\"temp-frame-before.png\", img)\n", "# display(\"text/html\", \"\"\"\"\"\")\n", "# original (721:1821,24:201)\n", "cropped = rotate_and_crop(img, 0.321, (250:615, 0:65))\n", "Images.save(\"cropped-frame.png\", cropped)\n", "display(\"text/html\", \"\"\"\"\"\")\n" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING: redefining constant _buffer\n" ] }, { "data": { "text/plain": [ "readroi (generic function with 2 methods)" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# This gets called often, so let's optimize it a little bit. Instead of just \n", "# using read, I use the internal `retrieve!` with a pre-allocated buffer.\n", "# This is safe since I know it's getting rotated and discarded immediately\n", "const _buffer = Array{UInt8}(3, size(img.data, 1), size(img.data, 2))\n", "function readroi(f::VideoIO.VideoReader, region=(1:size(A, 1), 1:size(A, 2)))\n", " VideoIO.retrieve!(f, _buffer)\n", " # _buffer is a 3-dimensional array (color x width x height), but by reinterpreting\n", " # it as RGB{UFixed8}, it becomes a matrix of colors that we can rotate\n", " Image(rotate_and_crop(reinterpret(RGB{UFixed8}, _buffer), 0.321, region), Dict(\"spatialorder\"=>[\"x\",\"y\"]))\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Object detection\n", "\n", "Now that we have our region of interest, we want to identify the vehicles. The first step is to find a frame without any vehicles — this will define the background. We just want to discard everything in the background." ] }, { "cell_type": "code", "execution_count": 214, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# println(f)\n", "# original index: 2*60+40.5\n", "# should be 20s, but 30*650 works\n", "seekstart(f)\n", "seek(f, (30*34*20))\n", "# original (721:1821,24:201)\n", "background = readroi(f, (250:615, 0:65))\n", "Images.save(\"temp-bg.png\", background)\n", "display(\"text/html\", \"\"\"\"\"\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Great! We can now go back to the beginning of the movie, and *subtract* the background from it! Pixels that are close in color to the background will be black, whereas new objects in the frame will have a different color value from the background and therefore be brighter (or maybe negative, which is rather non-sensical for a color)." ] }, { "cell_type": "code", "execution_count": 227, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "RGB Images.Image with:\n", " data: 366x66 Array{ColorTypes.RGB{Float32},2}\n", " properties:\n", " spatialorder: x y" ] }, "execution_count": 227, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# To subtract the background, first convert both to RGB{Float32} images. Subtracting RGB{UFixed8}s\n", "# is problematic because they are just unsigned 8-bit integers. So instead of going negative, they\n", "# *wrap around* to the maximum value. Using floating point numbers to represent the colors fixes this:\n", "seekstart(f)\n", "img = readroi(f, (250:615, 0:65))\n", "Images.save(\"temp.png\", img)\n", "display(\"text/html\", \"\"\"\"\"\")\n", "convert(Image{RGB{Float32}}, img) - convert(Image{RGB{Float32}}, background)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can somewhat see the four cars here. This is a \"color\" image, but we don't really care what colors the things are -- we just want the maximum deviation from the background. To do this, we can take the absolute value of each color and sum them all together:" ] }, { "cell_type": "code", "execution_count": 217, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Gray Images.Image with:\n", " data: 366x66 Array{Float32,2}\n", " properties:\n", " colorspace: Gray\n", " spatialorder: x y" ] }, "execution_count": 217, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Absolute value is defined for RGB colors, but it's a little wonky -- it's the *sum* of the absolute values\n", "# of the components. It is exactly what we want, but it's not defined for arrays of RGBs, so we add that definition here:\n", "@vectorize_1arg AbstractRGB Base.abs\n", "grayim(abs(convert(Image{RGB{Float32}}, img) - convert(Image{RGB{Float32}}, background)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now they really pop! You can also clearly see a few pedestrians waiting to cross at the crosswalk. The key to image processing is often just figuring out how to simplify your images as much as possible. The next step is to make things even simpler. Let's define a threshold value and make this image black and white, and square it to make big differences even bigger:" ] }, { "cell_type": "code", "execution_count": 218, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAABCAQAAAABfwAHbAAAABGdBTUEAALGPC/xhBQAAAAJiS0dEAAHdihOkAAAA20lEQVRIx2NgQANsDNgAOwMOgF05I8MoGBrAYTApH+oggSTVhytIUc18iiTl7LdIU364hiTlD1hIUv6DJOXMfz+QopzBgSTTGX/MIcn0YQDKFUhRzfj/A02V/yBFOTOScjbCytmRlLMTo/wDacofkOIYhn8IJhMpnh7cgLn9GUnKlz8nRTn7dtKUNxIRb0jK55NmevwHkoKm/h8+WfRWEfN/vMoxtH9PIMkxgwcIk5TlGW6TFiyTf5GinPkzaeXPgQ0kKT/+gCSv8n8gyasEEwwHCq+eUKXOQ0AeANVpNd+F7dvtAAAAAElFTkSuQmCC", "text/plain": [ "Gray Images.Image with:\n", " data: 366x66 Array{FixedPointNumbers.UFixed{UInt8,8},2}\n", " properties:\n", " colorspace: Gray\n", " spatialorder: x y" ] }, "execution_count": 218, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import Base: .^\n", "function (.^)(img::Image{RGB{Float32}}, pow::Integer)\n", " copy!(similar(img), reinterpret(RGB{Float32}, reinterpret(Float32, img).^pow))\n", "end\n", "grayim(map(UFixed8, grayim(abs((convert(Image{RGB{Float32}}, img) - convert(Image{RGB{Float32}}, background)).^2)) .> .06))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That works, but it's a little noisy. Let's add a bit of a blur to smooth things out a bit. One other difficulty we run into is that these car areas can bleed into each other from different lanes. The cars in the far lanes cast a shadow on the ground, extending their detected area into the nearer lanes. And we have some perspective difficulties, where tall vehicles in the near lanes can end up overlapping with the farther lanes. When two of these blobs touch they merge into one object, which can cause strange effects in the resulting speeds. By explicitly ignoring the areas between the lanes, we can prevent this from happening." ] }, { "cell_type": "code", "execution_count": 225, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAABCAQAAAABfwAHbAAAABGdBTUEAALGPC/xhBQAAAAJiS0dEAAHdihOkAAAAZUlEQVRIx+3SwQnAIAxG4QQPHrNAR+nwjtIR7K0HMc7woEJo884f8iuKZFn2SifB2gbh9WbcEbe9fLLt4yC8dKJFL8T/V/FOePUnDretp3+10hA39GjqE21xj8TRdnhVyd+XhW4BY4IqsNmbmHEAAAAASUVORK5CYII=", "text/plain": [ "Gray Images.Image with:\n", " data: 366x66 Array{FixedPointNumbers.UFixed{UInt8,8},2}\n", " properties:\n", " colorspace: Gray\n", " spatialorder: x y" ] }, "execution_count": 225, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mask = imfilter_gaussian(grayim(abs((convert(Image{RGB{Float32}}, img) - convert(Image{RGB{Float32}}, background)).^2)),[3,3]) .> .06\n", "# mask[:,61:69] = false\n", "# mask[:,97:105] = false\n", "# mask[:,129:137] = false\n", "\n", "# 13, 24, 36, 49\n", "mask[:,13:14] = false\n", "mask[:,29:33] = false\n", "mask[:,40:43] = false\n", "mask[:,53:66] = false\n", "\n", "grayim(map(UFixed8, mask))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we have a black and white image that we can pass to one of the core algorithms in image processing: labeling connected components. Basically, the algorithm goes through and finds each connected white area, filling it with a unique identifier. I think of it as acting like photo editing software's paint bucket, coloring inside the lines with a new color for each section:" ] }, { "cell_type": "code", "execution_count": 228, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found 3 connected areas\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAABCBAMAAACFlSFFAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAD1BMVEUAAAD/AAD//wAAgAD///+nSwrFAAAAAWJLR0QEj2jZUQAAAIpJREFUaN7t1IEJhEAMRNGNNmA6ECsQ0n9vx7lnASty48h/FXxCktYAAAAA4I0y1QWjIo9st+74Jodn90EdMijp/n/34tcdfdbh1m34ArvIRZ0A4OW2Tp0xavp1r+oQuh9tM+12nTeAG1WpCy5mV+3qiFFzdW7hdVKH0P1oZbrfrnfZTLMBAACg9wFemhdKInqe+AAAAABJRU5ErkJggg==", "text/plain": [ "RGB Images.Image with:\n", " data: 66x366 Array{ColorTypes.RGB{FixedPointNumbers.UFixed{UInt8,8}},2}\n", " properties:" ] }, "execution_count": 228, "metadata": {}, "output_type": "execute_result" } ], "source": [ "labels = label_components(mask) # This is like MATLAB's bwlabel\n", "println(\"Found $(maximum(labels)) connected areas\")\n", "# Demonstrate how it works by assigning each label to a different color and displaying the colored identifications:\n", "colors = [colorant\"black\", colorant\"red\", colorant\"yellow\", colorant\"green\", colorant\"blue\", colorant\"orange\", colorant\"purple\", colorant\"gray\", colorant\"brown\"]\n", "Image(map(x->colors[x+1], labels'))" ] }, { "cell_type": "code", "execution_count": 241, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "labelimg (generic function with 3 methods)" ] }, "execution_count": 241, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Let's put this all together into a function:\n", "function labelimg(img, background, blur=[3,3], tolerance=0.06)\n", " mask = imfilter_gaussian(grayim(abs((convert(Image{RGB{Float32}}, img) - convert(Image{RGB{Float32}}, background)).^2)),blur) .> tolerance\n", " mask::BitMatrix # Converting images isn't type stable, so giving inference a hint here helps speed things up\n", "# mask[:,61:69] = false\n", "# mask[:,97:105] = false\n", "# mask[:,129:137] = false\n", " mask[:,11:14] = false\n", " mask[:,27:29] = false\n", " mask[:,41:43] = false\n", " mask[:,53:66] = false\n", "\n", " label_components(mask)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tracking the cars over time\n", "\n", "So now that we can find the vehicles in each frame, we must track them over time across multiple images. I define a custom aggregate type to help keep track of the centers of mass, extents of each area, and the total number of pixels. Now we can convert our labelled image into a vector of Positions. By filtering out the areas smaller than a car, we end up with the four vehicles we expect!" ] }, { "cell_type": "code", "execution_count": 245, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3-element Array{Position,1}:\n", " Position(357.6218487394958,22.369747899159663,349:366,18:27,119) \n", " Position(37.410526315789475,36.56842105263158,29:45,34:39,95) \n", " Position(255.51937984496124,48.457364341085274,247:264,44:52,129)" ] }, "execution_count": 245, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using StatsBase\n", "immutable Position\n", " x::Float64\n", " y::Float64\n", " xspan::UnitRange{Int}\n", " yspan::UnitRange{Int}\n", " mass::Int\n", "end\n", "function positions(labels)\n", " N = maximum(labels)\n", " ps = Vector{Position}(N)\n", " for i=1:N\n", " mask = labels .== i\n", " xs = sum(mask, 2)\n", " ys = sum(mask, 1)\n", " ps[i] = Position(mean(1:length(xs), weights(xs)), mean(1:length(ys), weights(ys)),\n", " findfirst(xs):findlast(xs), findfirst(ys):findlast(ys),\n", " sum(xs))\n", " end\n", " ps\n", "end\n", "\n", "ps = positions(labels)\n", "filter(p->p.mass > 75, ps)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I put this all together, loop through each frame, and use a simple heuristic to see if the objects detected within that frame match any from the previous frames. Cars won't be crashing into each other, so we can find cars in the new frame that overlap with those in the previous one. I store this into a \"tall\" DataFrame, where each column is an independent variable (position, ID, and time) and each row is just one observation." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Progress: 13%|█████ | ETA: 0:02:03" ] } ], "source": [ "# One position *contains* another if its span contains the other's center\n", "Base.in(a::Position, b::Position) = round(a.x) in b.xspan && round(a.y) in b.yspan\n", "\n", "function identifyvehicles(f, background, max_frames = length(f))\n", " # These three vectors are where the end result goes\n", " vehicle_pos = Position[]\n", " vehicle_ids = Int[]\n", " vehicle_time = Int[]\n", "\n", " # We also keep a list of active positions from the previous frame\n", " active_pos = Position[]\n", " active_ids = Int[]\n", "\n", " seekstart(f)\n", " next_id = 1 # This will be the ID of the next \"new\" vehicle that enters the frame\n", " @showprogress for frame=1:max_frames\n", " eof(f) && break\n", "\n", " img = readroi(f, (250:615, 0:65))\n", " labels = labelimg(img, background)\n", " ps = filter(p->p.mass > 75, positions(labels))\n", " isactive = falses(length(active_pos))\n", " for p in ps\n", " id = 0;\n", " # Look to see if this vehicle is already active\n", " for i=1:length(active_pos)\n", " if p in active_pos[i] && active_pos[i] in p\n", " id = active_ids[i]\n", " active_pos[i] = p\n", " isactive[i] = true\n", " break\n", " end\n", " end\n", " if id == 0\n", " # We didn't find a matching active vehicle; use a new id\n", " id = next_id\n", " next_id += 1\n", " # And store it as an active vehicle\n", " push!(active_pos, p)\n", " push!(active_ids, id)\n", " push!(isactive, true)\n", " end\n", "\n", " push!(vehicle_pos, p)\n", " push!(vehicle_ids, id)\n", " push!(vehicle_time, frame)\n", " end\n", " active_pos = active_pos[isactive]\n", " active_ids = active_ids[isactive]\n", " end\n", " DataFrame(Any[vehicle_time, vehicle_pos, vehicle_ids], [:frame, :pos, :id])\n", "end\n", "seekstart(f)\n", "df = identifyvehicles(f, background)\n", "display(head(df, 10))\n" ] }, { "cell_type": "code", "execution_count": 233, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " frame\n", " \n", " \n", " 0\n", " 5.0×10³\n", " 1.0×10⁴\n", " 1.5×10⁴\n", " 2.0×10⁴\n", " \n", " \n", " \n", " 1000\n", " 1\n", " 500\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " id\n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " 0\n", " 100\n", " 200\n", " 300\n", " 400\n", " \n", " \n", " y\n", " \n", "\n", "\n", " \n", " \n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " frame\n", " \n", " \n", " -2.5×10⁴\n", " -2.0×10⁴\n", " -1.5×10⁴\n", " -1.0×10⁴\n", " -5.0×10³\n", " 0\n", " 5.0×10³\n", " 1.0×10⁴\n", " 1.5×10⁴\n", " 2.0×10⁴\n", " 2.5×10⁴\n", " 3.0×10⁴\n", " 3.5×10⁴\n", " 4.0×10⁴\n", " 4.5×10⁴\n", " -2.0×10⁴\n", " -1.9×10⁴\n", " -1.8×10⁴\n", " -1.7×10⁴\n", " -1.6×10⁴\n", " -1.5×10⁴\n", " -1.4×10⁴\n", " -1.3×10⁴\n", " -1.2×10⁴\n", " -1.1×10⁴\n", " -1.0×10⁴\n", " -9.0×10³\n", " -8.0×10³\n", " -7.0×10³\n", " -6.0×10³\n", " -5.0×10³\n", " -4.0×10³\n", " -3.0×10³\n", " -2.0×10³\n", " -1.0×10³\n", " 0\n", " 1.0×10³\n", " 2.0×10³\n", " 3.0×10³\n", " 4.0×10³\n", " 5.0×10³\n", " 6.0×10³\n", " 7.0×10³\n", " 8.0×10³\n", " 9.0×10³\n", " 1.0×10⁴\n", " 1.1×10⁴\n", " 1.2×10⁴\n", " 1.3×10⁴\n", " 1.4×10⁴\n", " 1.5×10⁴\n", " 1.6×10⁴\n", " 1.7×10⁴\n", " 1.8×10⁴\n", " 1.9×10⁴\n", " 2.0×10⁴\n", " 2.1×10⁴\n", " 2.2×10⁴\n", " 2.3×10⁴\n", " 2.4×10⁴\n", " 2.5×10⁴\n", " 2.6×10⁴\n", " 2.7×10⁴\n", " 2.8×10⁴\n", " 2.9×10⁴\n", " 3.0×10⁴\n", " 3.1×10⁴\n", " 3.2×10⁴\n", " 3.3×10⁴\n", " 3.4×10⁴\n", " 3.5×10⁴\n", " 3.6×10⁴\n", " 3.7×10⁴\n", " 3.8×10⁴\n", " 3.9×10⁴\n", " 4.0×10⁴\n", " -2×10⁴\n", " 0\n", " 2×10⁴\n", " 4×10⁴\n", " -2.0×10⁴\n", " -1.8×10⁴\n", " -1.6×10⁴\n", " -1.4×10⁴\n", " -1.2×10⁴\n", " -1.0×10⁴\n", " -8.0×10³\n", " -6.0×10³\n", " -4.0×10³\n", " -2.0×10³\n", " 0\n", " 2.0×10³\n", " 4.0×10³\n", " 6.0×10³\n", " 8.0×10³\n", " 1.0×10⁴\n", " 1.2×10⁴\n", " 1.4×10⁴\n", " 1.6×10⁴\n", " 1.8×10⁴\n", " 2.0×10⁴\n", " 2.2×10⁴\n", " 2.4×10⁴\n", " 2.6×10⁴\n", " 2.8×10⁴\n", " 3.0×10⁴\n", " 3.2×10⁴\n", " 3.4×10⁴\n", " 3.6×10⁴\n", " 3.8×10⁴\n", " 4.0×10⁴\n", " \n", " \n", " \n", " 1000\n", " 1\n", " 500\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " id\n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " -500\n", " -400\n", " -300\n", " -200\n", " -100\n", " 0\n", " 100\n", " 200\n", " 300\n", " 400\n", " 500\n", " 600\n", " 700\n", " 800\n", " 900\n", " -400\n", " -380\n", " -360\n", " -340\n", " -320\n", " -300\n", " -280\n", " -260\n", " -240\n", " -220\n", " -200\n", " -180\n", " -160\n", " -140\n", " -120\n", " -100\n", " -80\n", " -60\n", " -40\n", " -20\n", " 0\n", " 20\n", " 40\n", " 60\n", " 80\n", " 100\n", " 120\n", " 140\n", " 160\n", " 180\n", " 200\n", " 220\n", " 240\n", " 260\n", " 280\n", " 300\n", " 320\n", " 340\n", " 360\n", " 380\n", " 400\n", " 420\n", " 440\n", " 460\n", " 480\n", " 500\n", " 520\n", " 540\n", " 560\n", " 580\n", " 600\n", " 620\n", " 640\n", " 660\n", " 680\n", " 700\n", " 720\n", " 740\n", " 760\n", " 780\n", " 800\n", " -500\n", " 0\n", " 500\n", " 1000\n", " -400\n", " -350\n", " -300\n", " -250\n", " -200\n", " -150\n", " -100\n", " -50\n", " 0\n", " 50\n", " 100\n", " 150\n", " 200\n", " 250\n", " 300\n", " 350\n", " 400\n", " 450\n", " 500\n", " 550\n", " 600\n", " 650\n", " 700\n", " 750\n", " 800\n", " \n", " \n", " y\n", " \n", "\n", "\n", " \n", " \n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "Plot(...)" ] }, "execution_count": 233, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Let's look at the position of the cars over time:\n", "plot(df, x=:frame, y=map(p->p.x, df[:pos]), color=:id, Geom.line()) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Converting pixels to meters\n", "\n", "While it's pretty cool that we have identified cars and can track them across the video, we still don't know how fast they're going because we don't know how to convert from pixels to a real unit like meters. This ended up being much more difficult than I anticipated. Not only do I need to find a conversion between pixels to meters, but this conversion factor varies across the video due to the perspective! So I needed to find multiple reference points in order to put a scale bar (or bars) on this video.\n", "\n", "**Busses to the rescue.** Most of the Pittsburgh Port Authority's bus fleet is comprised of [40' Gillig Low Floor (or Advantage)](https://en.wikipedia.org/wiki/Gillig_Low_Floor) and 60' articulating busses. Unfortunately no 60 footers went past in the ten minute video, but several 40' busses go by. At first I tried measuring the bus itself, but this proved difficult. The edges were fuzzy and tough to mark in the video, and I also had a hard time finding the exact measurements here because it seems many agencies customize bumpers or add bike racks. The wheelbase, however, is much more precise, both in its specification (279 inches) and my ability to mark the centers of the wheels. So I grabbed snippets from both the right and left lanes and marked the wheels on the image directly. This allowed me to estimate the pixel density along the x-axis at 10 different points." ] }, { "cell_type": "code", "execution_count": 173, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# let's find some busses\n", "function peek_img(i, t)\n", " seekstart(f)\n", " seek(f, t)\n", " Images.save(\"peek-bus-$i.png\", readroi(f, (250:615, 0:65)))\n", " display(\"text/html\", \"\"\"\"\"\")\n", "end\n", "\n", "peek_img(1, 34*30*(5*60+55))\n", "peek_img(2, 34*30*(6*60+4))\n", "peek_img(3, 34*30*(6*60+10))\n", "peek_img(4, 34*30*(6*60+13))\n", "\n", "peek_img(5, 34*30*(2*60+39))\n", "peek_img(6, 34*30*(2*60+40))\n", "peek_img(7, 34*30*(2*60+42))\n", "peek_img(8, 34*30*(2*60+44))\n", "\n" ] }, { "cell_type": "code", "execution_count": 180, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "RGB Images.Image with:\n", " data: 366x66 Array{ColorTypes.RGB{Float64},2}\n", " properties:\n", " spatialorder: x y" ] }, "execution_count": 180, "metadata": {}, "output_type": "execute_result" } ], "source": [ "density = Vector{Float64}(0) # The pixel density\n", "density_x = Vector{Float64}(0) # The locations of a specific density measurement\n", "density_y = Vector{Float64}(0)\n", "wheelbase = 7.087 # 279 inches in meters\n", "\n", "img = copy(background)\n", "function draw_and_store_density!(img, f, t, burnframes, x1, x2, y)\n", " # Go to the specified frame\n", " seek(f, 30*34*t)\n", " # Sometimes seeking isn't precise enough, and we need to burn a few frames:\n", " for i=1:burnframes; readroi(f, (250:615, 0:65)); end\n", " # Grab the image\n", " frame = readroi(f, (250:615, 0:65))\n", " # Store the bus into the passed image\n", " img[x1-20:x2+10, minimum(y)-10:maximum(y)+10] = frame[x1-20:x2+10, minimum(y)-10:maximum(y)+10]\n", " img[x1, y] = colorant\"red\"\n", " img[x2, y] = colorant\"red\"\n", " # And store \n", " push!(density, wheelbase/(x2-x1))\n", " push!(density_x, mean([x1,x2]))\n", " push!(density_y, mean(y))\n", "end\n", "\n", "# Bus in the right lane at 6:00 - 6:30:\n", "# draw_and_store_density!(img, f, 6*60+1, 0, 953, 1046, 54:64)\n", "# draw_and_store_density!(img, f, 6*60+4, 0, 722, 808, 54:64)\n", "# draw_and_store_density!(img, f, 6*60+16, 0, 465, 546, 54:64)\n", "# draw_and_store_density!(img, f, 6*60+20, 0, 205, 280, 47:57)\n", "# draw_and_store_density!(img, f, 6*60+22, 0, 60, 132, 42:52)\n", "\n", "draw_and_store_density!(img, f, 5*60+55, 0, 271, 301, 24:28)\n", "draw_and_store_density!(img, f, 6*60+4, 0, 175, 203, 24:28)\n", "draw_and_store_density!(img, f, 6*60+10, 0, 120, 147, 24:27)\n", "draw_and_store_density!(img, f, 6*60+13, 0, 26, 52, 20:24)\n", "\n", "\n", "# Bus in the left lane at 2:40 - 2:50:\n", "# draw_and_store_density!(img, f, 2*60+42, 12, 929, 1023, 120:130)\n", "# draw_and_store_density!(img, f, 2*60+44, 0, 672, 759, 120:130)\n", "# draw_and_store_density!(img, f, 2*60+46, 0, 372, 453, 120:130)\n", "# draw_and_store_density!(img, f, 2*60+47, 0, 227, 306, 120:130)\n", "# draw_and_store_density!(img, f, 2*60+48, 8, 52, 127, 120:130)\n", "\n", "draw_and_store_density!(img, f, 2*60+39, 0, 314, 349, 45:50)\n", "draw_and_store_density!(img, f, 2*60+40, 0, 205, 235, 45:50)\n", "draw_and_store_density!(img, f, 2*60+42, 0, 155, 183, 45:50)\n", "draw_and_store_density!(img, f, 2*60+44, 0, 58, 88, 45:50)\n", "\n", "img" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This gives us 10 point estimates, but it'd be nice to get a mesh across the image that will allow us to compute speeds anywhere. Assuming the ground is flat (it's not, but it's pretty close) and the cell phone lens doesn't distort things (it does, but not by much), I'd expect the pixel density to be roughly linear across the image. So let's use GLM.jl and fit a linear model:" ] }, { "cell_type": "code", "execution_count": 181, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "DataFrames.DataFrameRegressionModel{GLM.LinearModel{GLM.DensePredQR{Float64}},Float64}:\n", "\n", "Coefficients:\n", " Estimate Std.Error t value Pr(>|t|)\n", "(Intercept) 0.299214 0.0143561 20.8423 <1e-5\n", "X -0.000139779 4.51034e-5 -3.09907 0.0269\n", "Y -0.000828424 0.000369558 -2.24166 0.0751\n" ] }, "execution_count": 181, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using GLM\n", "# D ~ X+Y is a \"Formula\" expression. It means that from the dataframe, the D column is a function of X + Y multiplied by some coefficients\n", "m = lm(D ~ X+Y, DataFrame(Any[density, density_x, density_y], [:D, :X, :Y]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's see what this mesh looks like. The densities vary from 10cm/pixel to 7.5cm/pixel, which is a surprisingly large amount! It's a bit tough to tell how well the colored dots match the contour lines, but by looking at the residuals you can see that the linear model fits the data to within 1mm/pixel." ] }, { "cell_type": "code", "execution_count": 183, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " -500\n", " -400\n", " -300\n", " -200\n", " -100\n", " 0\n", " 100\n", " 200\n", " 300\n", " 400\n", " 500\n", " 600\n", " 700\n", " 800\n", " 900\n", " -380\n", " -360\n", " -340\n", " -320\n", " -300\n", " -280\n", " -260\n", " -240\n", " -220\n", " -200\n", " -180\n", " -160\n", " -140\n", " -120\n", " -100\n", " -80\n", " -60\n", " -40\n", " -20\n", " 0\n", " 20\n", " 40\n", " 60\n", " 80\n", " 100\n", " 120\n", " 140\n", " 160\n", " 180\n", " 200\n", " 220\n", " 240\n", " 260\n", " 280\n", " 300\n", " 320\n", " 340\n", " 360\n", " 380\n", " 400\n", " 420\n", " 440\n", " 460\n", " 480\n", " 500\n", " 520\n", " 540\n", " 560\n", " 580\n", " 600\n", " 620\n", " 640\n", " 660\n", " 680\n", " 700\n", " 720\n", " 740\n", " -500\n", " 0\n", " 500\n", " 1000\n", " -400\n", " -350\n", " -300\n", " -250\n", " -200\n", " -150\n", " -100\n", " -50\n", " 0\n", " 50\n", " 100\n", " 150\n", " 200\n", " 250\n", " 300\n", " 350\n", " 400\n", " 450\n", " 500\n", " 550\n", " 600\n", " 650\n", " 700\n", " 750\n", " \n", " \n", " \n", " \n", " 0.22\n", " 0.28\n", " \n", " 0.26\n", " 0.24\n", " 0.20\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " Color\n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " -100\n", " -80\n", " -60\n", " -40\n", " -20\n", " 0\n", " 20\n", " 40\n", " 60\n", " 80\n", " 100\n", " 120\n", " 140\n", " 160\n", " 180\n", " -64\n", " -62\n", " -60\n", " -58\n", " -56\n", " -54\n", " -52\n", " -50\n", " -48\n", " -46\n", " -44\n", " -42\n", " -40\n", " -38\n", " -36\n", " -34\n", " -32\n", " -30\n", " -28\n", " -26\n", " -24\n", " -22\n", " -20\n", " -18\n", " -16\n", " -14\n", " -12\n", " -10\n", " -8\n", " -6\n", " -4\n", " -2\n", " 0\n", " 2\n", " 4\n", " 6\n", " 8\n", " 10\n", " 12\n", " 14\n", " 16\n", " 18\n", " 20\n", " 22\n", " 24\n", " 26\n", " 28\n", " 30\n", " 32\n", " 34\n", " 36\n", " 38\n", " 40\n", " 42\n", " 44\n", " 46\n", " 48\n", " 50\n", " 52\n", " 54\n", " 56\n", " 58\n", " 60\n", " 62\n", " 64\n", " 66\n", " 68\n", " 70\n", " 72\n", " 74\n", " 76\n", " 78\n", " 80\n", " 82\n", " 84\n", " 86\n", " 88\n", " 90\n", " 92\n", " 94\n", " 96\n", " 98\n", " 100\n", " 102\n", " 104\n", " 106\n", " 108\n", " 110\n", " 112\n", " 114\n", " 116\n", " 118\n", " 120\n", " 122\n", " 124\n", " 126\n", " 128\n", " 130\n", " 132\n", " -100\n", " 0\n", " 100\n", " 200\n", " -65\n", " -60\n", " -55\n", " -50\n", " -45\n", " -40\n", " -35\n", " -30\n", " -25\n", " -20\n", " -15\n", " -10\n", " -5\n", " 0\n", " 5\n", " 10\n", " 15\n", " 20\n", " 25\n", " 30\n", " 35\n", " 40\n", " 45\n", " 50\n", " 55\n", " 60\n", " 65\n", " 70\n", " 75\n", " 80\n", " 85\n", " 90\n", " 95\n", " 100\n", " 105\n", " 110\n", " 115\n", " 120\n", " 125\n", " 130\n", " 135\n", " \n", " \n", " y\n", " \n", "\n", "\n", " \n", " \n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Residuals: [-0.001464,0.001851,0.003053,-0.00296,-0.011041,0.007121,0.016866,-0.013426]\n" ] } ], "source": [ "# Column 1 is the intercept, 2 & 3 are the X and Y coefficients\n", "b, mx, my = coef(m)\n", "img = readroi(f, (250:615, 0:65))\n", "# Now let's use the model to construct density estimates for the entire grid\n", "density_grid = [b+mx*x+my*y for x in 1:size(img, 1), y in 1:size(img, 2)]\n", "is, js, vals = findnz(density_grid)\n", "display(plot(layer(x=density_x, y=density_y, color=density, Geom.point()), \n", " layer(x=1:size(img, 1), y=1:size(img, 2), z=density_grid, Geom.contour()),\n", " Coord.cartesian(yflip=true, xmax=366, ymax=66)))\n", "\n", "println(\"Residuals: $(round(residuals(m), 6))\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, I convert the mesh of pixel densities to actual distances. Note that these aren't the actual positions — this doesn't account for the very different pixel density along the y dimension nor the skew across the image. But we're only measuring the velocity along the x-axis, and since we restrict detections to within single lanes, we know that the vehicles aren't moving significantly along our un-calibrated axis.\n", "\n", "It'd be really nice to validate this measurement against some other distances in the image. There are some faded marks on the pavement that are separate from the intersection markings. My hunch is that they might be old [VASCAR](https://en.wikipedia.org/wiki/VASCAR) lines, and may be exactly 100ft or some other even multiple apart.\n", "\n", "I can also compare this against satellite imagery, but it's a little tougher to come up with good landmarks that line up well with scale bars. Using imagery from Apple's Maps, I managed to get a measurement on the solid white lines leading up to the intersection: 75feet.\n", "![Apple Maps with scale](assets/mapscale.png)\n", "\n", "Both of these measurements match our coordinate grid nicely." ] }, { "cell_type": "code", "execution_count": 192, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "RGB Images.Image with:\n", " data: 366x66 Array{ColorTypes.RGB{Float64},2}\n", " properties:\n", " spatialorder: x y" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Approximately 29.42 meters, or 96.5 feet\n" ] }, { "data": { "image/png": "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", "text/plain": [ "RGB Images.Image with:\n", " data: 366x66 Array{ColorTypes.RGB{Float64},2}\n", " properties:\n", " spatialorder: x y" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Approximately 21.94 meters, or 71.98 feet\n" ] } ], "source": [ "coord_xs = cumsum(density_grid, 1)\n", "\n", "# Mark and compute the distance between the faded lines, using the bottom of the mark:\n", "img = copy(background)\n", "img[(x1=75), 25:35] = colorant\"red\"\n", "img[(x2=192), 25:35] = colorant\"red\"\n", "display(img)\n", "dist = coord_xs[x2, 35]-coord_xs[x1, 35]\n", "println(\"Approximately $(round(dist, 2)) meters, or $(round(dist*3.281, 1)) feet\")\n", "\n", "# And similarly for the solid white line:\n", "img = copy(background)\n", "img[(x1=163), 30:38] = colorant\"red\"\n", "img[(x2=255), 30:38] = colorant\"red\"\n", "display(img)\n", "dist = coord_xs[x2, 38]-coord_xs[x1, 38]\n", "println(\"Approximately $(round(dist, 2)) meters, or $(round(dist*3.281, 2)) feet\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Computing actual speed!\n", "\n", "Finally, we can go back to the dataframe, and compute the actual position in meters and time. Instead of using the center of mass, I found the mean extents of the car to be a bit less noisy." ] }, { "cell_type": "code", "execution_count": 234, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
frameposidxt
11Position(357.6218487394958,22.369747899159663,349:366,18:27,119)191.490949867670250.033366700033366704
21Position(255.51937984496124,48.457364341085274,247:264,44:52,129)261.7039659416660560.033366700033366704
32Position(356.60655737704917,22.459016393442624,348:366,19:27,122)191.079099956326560.06673340006673341
42Position(253.29268292682926,48.552845528455286,245:261,44:52,123)261.144941113089690.06673340006673341
53Position(356.014598540146,22.642335766423358,346:366,19:27,137)190.84751327220980.1001001001001001
63Position(251.175,48.541666666666664,243:259,44:52,120)260.696630976763730.1001001001001001
" ], "text/plain": [ "6x5 DataFrames.DataFrame\n", "| Row | frame |\n", "|-----|-------|\n", "| 1 | 1 |\n", "| 2 | 1 |\n", "| 3 | 2 |\n", "| 4 | 2 |\n", "| 5 | 3 |\n", "| 6 | 3 |\n", "\n", "| Row | pos | id |\n", "|-----|-------------------------------------------------------------------|----|\n", "| 1 | Position(357.6218487394958,22.369747899159663,349:366,18:27,119) | 1 |\n", "| 2 | Position(255.51937984496124,48.457364341085274,247:264,44:52,129) | 2 |\n", "| 3 | Position(356.60655737704917,22.459016393442624,348:366,19:27,122) | 1 |\n", "| 4 | Position(253.29268292682926,48.552845528455286,245:261,44:52,123) | 2 |\n", "| 5 | Position(356.014598540146,22.642335766423358,346:366,19:27,137) | 1 |\n", "| 6 | Position(251.175,48.541666666666664,243:259,44:52,120) | 2 |\n", "\n", "| Row | x | t |\n", "|-----|---------|-----------|\n", "| 1 | 91.4909 | 0.0333667 |\n", "| 2 | 61.704 | 0.0333667 |\n", "| 3 | 91.0791 | 0.0667334 |\n", "| 4 | 61.1449 | 0.0667334 |\n", "| 5 | 90.8475 | 0.1001 |\n", "| 6 | 60.6966 | 0.1001 |" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# PHEW! Now we can go back to the dataframe, computing the actual position in meters and time:\n", "x_min = [coord_xs[minimum(p.xspan), round(Int, mean(p.yspan))] for p in df[:pos]]\n", "x_max = [coord_xs[maximum(p.xspan), round(Int, mean(p.yspan))] for p in df[:pos]]\n", "df[:x] = (x_max+x_min)/2\n", "df[:t] = df[:frame]./29.97 # An accessor for the frame rate from VideoIO would be nice, but just hard code it for now\n", "display(head(df))\n", "display(\"image/png\", plot(df, x=:t, y=:x, color=:id, Geom.line(), Coord.Cartesian(xmin=4*60, xmax=6*60))) # Display as a PNG to keep filesize down" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Computing the speed requires taking the differential of the position vectors. These can be notoriously noisy. A great algorithm for both differentiating and smoothing at the same time is the [Savitzgy-Golay filter](https://en.wikipedia.org/wiki/Savitzky–Golay_filter). In short, it fits a line to a subsection of the data, and then uses the slope of that line as the value of the differential in the middle of that section. Repeat this across the entire dataset, and you have a smoothed differential!" ] }, { "cell_type": "code", "execution_count": 235, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
frameposidxtdx
11Position(357.6218487394958,22.369747899159663,349:366,18:27,119)191.490949867670250.033366700033366704-4.298412026821199
21Position(255.51937984496124,48.457364341085274,247:264,44:52,129)261.7039659416660560.033366700033366704-7.35260753299883
32Position(356.60655737704917,22.459016393442624,348:366,19:27,122)191.079099956326560.06673340006673341-5.534793301235916
42Position(253.29268292682926,48.552845528455286,245:261,44:52,123)261.144941113089690.06673340006673341-8.964463437211883
53Position(356.014598540146,22.642335766423358,346:366,19:27,137)190.84751327220980.1001001001001001-6.741133800953552
63Position(251.175,48.541666666666664,243:259,44:52,120)260.696630976763730.1001001001001001-10.467839979344213
" ], "text/plain": [ "6x6 DataFrames.DataFrame\n", "| Row | frame |\n", "|-----|-------|\n", "| 1 | 1 |\n", "| 2 | 1 |\n", "| 3 | 2 |\n", "| 4 | 2 |\n", "| 5 | 3 |\n", "| 6 | 3 |\n", "\n", "| Row | pos | id |\n", "|-----|-------------------------------------------------------------------|----|\n", "| 1 | Position(357.6218487394958,22.369747899159663,349:366,18:27,119) | 1 |\n", "| 2 | Position(255.51937984496124,48.457364341085274,247:264,44:52,129) | 2 |\n", "| 3 | Position(356.60655737704917,22.459016393442624,348:366,19:27,122) | 1 |\n", "| 4 | Position(253.29268292682926,48.552845528455286,245:261,44:52,123) | 2 |\n", "| 5 | Position(356.014598540146,22.642335766423358,346:366,19:27,137) | 1 |\n", "| 6 | Position(251.175,48.541666666666664,243:259,44:52,120) | 2 |\n", "\n", "| Row | x | t | dx |\n", "|-----|---------|-----------|----------|\n", "| 1 | 91.4909 | 0.0333667 | -4.29841 |\n", "| 2 | 61.704 | 0.0333667 | -7.35261 |\n", "| 3 | 91.0791 | 0.0667334 | -5.53479 |\n", "| 4 | 61.1449 | 0.0667334 | -8.96446 |\n", "| 5 | 90.8475 | 0.1001 | -6.74113 |\n", "| 6 | 60.6966 | 0.1001 | -10.4678 |" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Copyright Colm Ryan, licensed under ASL, from the un-registered QLab.jl:\n", "# https://github.com/BBN-Q/Qlab.jl/blob/27550abfe68e001cba20714ecb5efcab0c5689bb/src/SavitskyGolay.jl\n", "# Slightly modified for 0.4 compatibility.\n", "# For a more efficient implementation (and a demonstration of Julia's staged programming), see:\n", "# https://medium.com/@acidflask/smoothing-data-with-julia-s-generated-functions-c80e240e05f3\n", "function savitsky_golay(x::AbstractVector, windowSize::Integer, polyOrder::Integer, deriv::Integer=0)\n", " #Some error checking\n", " @assert isodd(windowSize) \"Window size must be an odd integer.\"\n", " @assert polyOrder < windowSize \"Polynomial order must me less than window size.\"\n", "\n", " halfWindow = div(windowSize-1, 2)\n", "\n", " #Setup the S matrix of basis vectors. \n", " S = zeros(windowSize, polyOrder+1)\n", " for ct = 0:polyOrder\n", " S[:,ct+1] = collect(-halfWindow:halfWindow).^(ct)\n", " end\n", "\n", " #Compute the filter coefficients for all orders\n", " #From the scipy code it seems pinv(S) and taking rows should be enough\n", " G = S*pinv(S'*S)\n", "\n", " #Slice out the derivative order we want\n", " filterCoeffs = G[:,deriv+1] * factorial(deriv);\n", "\n", " #Pad the signal with the endpoints and convolve with filter\n", " paddedX = [x[1]*ones(halfWindow); x; x[end]*ones(halfWindow)]\n", " y = conv(filterCoeffs[end:-1:1], paddedX)\n", "\n", " #Return the valid midsection\n", " return y[2*halfWindow+1:end-2*halfWindow]\n", "end\n", "\n", "dx = Vector{Float64}(size(df, 1))\n", "groups = unique(df[:id])\n", "for g in groups\n", " mask = df[:id] .== g\n", " x = convert(Array{Float64}, df[:x])[mask]\n", " dx[mask] = savitsky_golay(x, 13, 1, 1)\n", "end\n", "df[:dx] = dx*29.97\n", "display(head(df))\n", "\n", "writetable(\"speeds.csv\", DataFrame(Any[df[:frame], df[:id], df[:x], df[:t], df[:dx]], [:frame, :id, :x, :t, :dx]))\n", "\n", "# plot(df, x=:t, y=:dx, color=:id, Geom.line()) # Plot omitted to reduce filesize" ] }, { "cell_type": "code", "execution_count": 238, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# OK, let's play this video again, this time with speeds annotated!\n", "# The easiest way I know of to print numbers is by punting to Cairo\n", "annotate_frame!(img, frame, df::DataFrame) = annotate_frame!(img, frame, df[:frame], df[:pos], df[:id], df[:dx])\n", "function annotate_frame!(img, frame, frames, pos, ids, dx)\n", " # Draw a box around each car in this frame, with the speed inscribed\n", " idxs = find(frames .== frame)\n", "# println(\"idxs $idxs\")\n", " for idx in idxs\n", " p = pos[idx]\n", " speed = abs(dx[idx])*2.237\n", " \n", " # The box\n", " x1, x2 = extrema(p.xspan)\n", " y1, y2 = extrema(p.yspan)\n", " outline = colorant\"red\"\n", " if speed <= 30\n", " outline = colorant\"yellow\"\n", " end\n", " if speed <= 25\n", " outline = colorant\"green\" \n", " end\n", " img[x1, p.yspan] = outline\n", " img[x2, p.yspan] = outline\n", " img[p.xspan, y1] = outline\n", " img[p.xspan, y2] = outline\n", " # The text\n", " puttext!(img, string(round(Int, speed)), p.xspan, p.yspan)\n", " end\n", " img\n", "end\n", "import Cairo\n", "function puttext!(img, str, xspan, yspan)\n", "# println(\"$xspan $yspan $str\")\n", " # This is a little convoluted - pass a copy of the image to Cairo, write the text, and assign it back.\n", " c = Cairo.CairoImageSurface(reinterpret(UInt32, convert(Image{ARGB32}, img)[xspan, yspan]).', Cairo.FORMAT_ARGB32)\n", " cr = Cairo.CairoContext(c)\n", " Cairo.save(cr)\n", " Cairo.move_to(cr, 3., 5.)\n", " Cairo.set_font_size(cr, 7.)\n", "# set_line_join(cr, Cairo.CAIRO_LINE_JOIN_ROUND);\n", " Cairo.show_text(cr, str)\n", " img[xspan, yspan] = reinterpret(ARGB32, c.data)\n", " img\n", "end\n", "\n", "# crazily, FFMPEG makes it tough (impossible?) to get the current frame number\n", "seekstart(f)\n", "frame_no = floor(Int, (5*60+18)*29.97)\n", "for _=1:frame_no # So we just get there sequentially.\n", " read(f);\n", "end\n", "gif = animate(60, fps=30, width=366) do i\n", " annotate_frame!(readroi(f, (250:615, 0:65)), frame_no+i, df)\n", "end\n", "open(\"processedclip.gif\", \"w\") do f\n", " write(f, gif)\n", "end\n", "gif\n", "\n", "# Again, just point to the clip to keep filesize down\n", "display(\"text/html\", \"\"\"\"\"\")" ] }, { "cell_type": "code", "execution_count": 239, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Progress: 100%|█████████████████████████████████████████| Time: 0:06:24\n" ] } ], "source": [ "# And now output to a sequence of saved files... which we then convert to a movie with FFMPEG\n", "# VideoIO doesn't support writing videos yet, so we simply output each frame to a folder, and\n", "# shell out to ffmpeg... just like we did with animate (but without the nice wrapper function)\n", "seekstart(f)\n", "gen_pngs(f, df::DataFrame) = gen_pngs(f, df[:frame], df[:pos], df[:id], df[:dx])\n", "function gen_pngs(f, frames, pos, ids, dx)\n", " seekstart(f)\n", " isdir(\"images\") || mkdir(\"images\")\n", " @showprogress for frame=1:maximum(frames)\n", " img = readroi(f, (250:615, 0:65))\n", " annotate_frame!(img, frame, frames, pos, ids, dx)\n", " Images.save(\"images/$frame.png\", img)\n", " end\n", "end\n", "\n", "gen_pngs(f, df)\n", "# run(`$(Homebrew.brew_prefix)/bin/ffmpeg -v 0 -framerate 29.97 -i images/%d.png -y forbesspeed.mp4`)\n", "# this following one should be readable by quicktime\n", "run(`$(Homebrew.brew_prefix)/bin/ffmpeg -framerate 29.97 -i images/%d.png -f mp4 -vcodec h264 -pix_fmt yuv420p -s 366x66 forbesspeed.mp4)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Cursory analysis of the traffic speed\n", "\n", "Now, let's put together some summary statistics about the traffic speed. In order to do this, we do a group by operation over each identified vehicle. Let's look at each car's maximum instantaneous speed as well as their speed through the ~100ft pair of faded lines that I think may be old VASCAR markings. This gives us two metrics: one represents the actual maximums of each tracked car, whereas the other is more representative of how a speed trap in this location might perform." ] }, { "cell_type": "code", "execution_count": 240, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
idmax_speedcourse_speedcourse_start_speedcourse_stop_speed
11NANANANA
22NANANANA
3329.853739617439945NANANA
44NANANANA
55NANANANA
6629.934615766259192NANANA
" ], "text/plain": [ "6x5 DataFrames.DataFrame\n", "| Row | id | max_speed | course_speed | course_start_speed | course_stop_speed |\n", "|-----|----|-----------|--------------|--------------------|-------------------|\n", "| 1 | 1 | NA | NA | NA | NA |\n", "| 2 | 2 | NA | NA | NA | NA |\n", "| 3 | 3 | 29.8537 | NA | NA | NA |\n", "| 4 | 4 | NA | NA | NA | NA |\n", "| 5 | 5 | NA | NA | NA | NA |\n", "| 6 | 6 | 29.9346 | NA | NA | NA |" ] }, "execution_count": 240, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Grouped analysis by each detected car. This doesn't need to be very efficient.\n", "by_car = by(df, :id) do car\n", " dx = car[:dx]\n", " # The maximum speed of the car, but only if it's tracked for more than 60 frames (~2 seconds)\n", " # This ignores most of the cars turning from Schenley Drive Ext\n", " max_speed = length(dx) > 60 ? maximum(abs(dx)) .* 2.237 : NA\n", " \n", " # Also compute the \"course\" time, distance, and speed for approximately the VASCAR lines\n", " course_start = 591 # in pixels\n", " course_stop = 245\n", " ps = car[:pos]\n", " # Let's use the front of the car, since I think that's how VASCAR timings generally work\n", " front = map(p->first(p.xspan), ps)\n", " # Find the index where the front of the car is closest to the course boundaries\n", " start_offset, start_idx = findmin(abs(front .- course_start))\n", " stop_offset, stop_idx = findmin(abs(front .- course_stop))\n", " # Now restrict to cars that have datapoints near both course start and stop:\n", " if start_offset < 30 && stop_offset < 30\n", " # Get the average y position over the course for the distance coordinate transform\n", " mean_y = round(Int, mean(map(p->p.y, ps[start_idx:stop_idx])))\n", " course_dist = coord_xs[front[start_idx], mean_y] - coord_xs[front[stop_idx], mean_y]\n", " course_time = (car[:frame][stop_idx] - car[:frame][start_idx])/29.97\n", " course_speed = (course_dist/course_time)*2.237\n", " course_start_speed = abs(dx[start_idx])*2.237\n", " course_stop_speed = abs(dx[stop_idx])*2.237\n", " else\n", " course_speed = NA\n", " course_start_speed = NA\n", " course_stop_speed = NA\n", " end\n", " \n", " DataFrame(Any[[max_speed], [course_speed], [course_start_speed], [course_stop_speed]], \n", " [:max_speed, :course_speed, :course_start_speed, :course_stop_speed])\n", "end\n", "head(by_car, 6)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "p = plot(by_car, x=:max_speed, Geom.histogram(bincount=35))\n", "draw(PNG(\"max_speeds.png\", 6inch, 4inch), p)\n", "display(\"image/png\", p)\n", "println(\"Cars over 40mph: \", sum((by_car[:max_speed] .> 40) & !isna(by_car[:max_speed])))\n", "println(\"Cars between 35-40mph: \", sum((35 .< by_car[:max_speed] .<= 40) & !isna(by_car[:max_speed])))\n", "println(\"Cars between 30-35mph: \", sum((30 .< by_car[:max_speed] .<= 35) & !isna(by_car[:max_speed])))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's just look at the fastest speeds. The 95th percentile is an interesting point, since it represents the speed that one out of every twenty cars is exceeding. Assuming this random 10-minute sample is representative of afternoon traffic (I have no reason to suspect otherwise), we can bootstrap the distribution to get 95% confidence bounds on this statistic." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "using Bootstrap\n", "max_speeds = by_car[:max_speed][!isna(by_car[:max_speed])]\n", "bs = boot_basic(max_speeds, x->quantile(x, .95), 10000)\n", "ci_bca(bs, .95)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The VASCAR course speed is generally slower since the cars tend to accelerate as they pass through the tracked region. It represents the average speed over ~100ft. There are 4 vehicles going over 35 miles per hour in this 10 minute time span." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "display(\"image/png\", plot(by_car, x=:course_speed, Geom.histogram(bincount=35)))\n", "println(\"Cars over 35mph: \", sum((by_car[:course_speed] .> 35) & !isna(by_car[:course_speed])))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exporting data\n", "\n", "As one last step, lets export the tracked car positions as a CSV file (and JLD) so others can take a look at the data, too. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import JLD\n", "# The jld file contains the pixel Position aggregates, too:\n", "JLD.@save \"speeds.jld\" df coord_xs\n", "\n", "writetable(\"speeds.csv\", DataFrame(Any[df[:frame], df[:id], df[:x], df[:t], df[:dx]], [:frame, :id, :x, :t, :dx]))" ] } ], "metadata": { "kernelspec": { "display_name": "Julia 0.4.2", "language": "julia", "name": "julia-0.4" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "0.4.2" } }, "nbformat": 4, "nbformat_minor": 0 }