{
"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",
"[](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",
"\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",
"\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": "iVBORw0KGgoAAAANSUhEUgAAAW4AAABCCAAAAABS0GOqAAAABGdBTUEAALGPC/xhBQAAAAJiS0dEAP+Hj8y/AAA5FElEQVR42lX8S89tW5IlCA0zm3Outfbj+853zrlPvx7ufj0e7pGVRBVJFZFBpqqyskAkkFkqxKMBBaoeiBbVoEGPLhI/gAYtEKJTAgFSVQllCSqFUEIGlZlBEOGe7hkv93v93PP8vv1Yaz7MBo19A8Ruby2tZdNs2pzDxhgyGXzqg9AFMfo8hkADIcsaUMV961Stn6a/2K0qAVCEAAgAAZEB0ITTtnQcz/bZuwvK/NYgVu34JKN4aUf12F0uilkvul+JIYoCo87n+cef/MH/IP+D/8uYVm4+dlt2CoWCMHioJFwFhAAUhKiCpVJCRElRaFDSXJ59cw0QQQCiGQBl0BeK9d2v767H8s3l64ohAQEIwoYIoYG//ByIEBAKAgZlkiBACggINQdE6Hf/6t/4+E/+vT9dUwNw9z65Dg8TKvHte0JVktBKGpdwJjhEDEGbYrAzJOijMbeACsKDChelpmhxV6b2WpAo4hSB9MhKkBBBWgCRrM8fpu+VuY3l+fd3+tkuP7e9flxWFX3xcVyKHyfNBt+VLQwQmICo28S/+PkPprdffajb+eq6dJGwgEACEaQ4hwKiKhTKLcadgEAGFKKqYXS/BkMZBEQVCqGIZsmHOqzLw+fj9dOpBgUQiHz7NKD47VmAQA0iEhAQoiJyWwMAIkJATVUkJ/vqz/NP3/e7TnCbAkERFaFSCAGpChJUH3ACVBFTQCAzSRJyW0IFKURQwMSynOIZT3vR3M4iSuEgIls3OAGIQDW6UlNTHC4Ixy5d/NgiAlNMfsnwfT552NSJpUc8+wDDENckgh6H+vI3X15/uV0uNUJN+5hTDYIA6IDR930IhQiNb3MRhEAooaoqCICSIBjsVKHgFjkwXGBRZHlxvH64DvfgLYK0TqB0iLsIBFSqkgRv/2AGaIQgbhlLUU2AYkLO8/7N27aPCkIHNRhGFwtlQAhRQJKIgGSQRooBcDMIRRX//z/LjmXIfBVBbb1eI0xuFegCzTYCAig5RigRWYaVnHpeNoGOOqIQ2rv1EG/Q4im7dCZZofQEIcIdwlZ+GH/+6rQO0MtuvqDXuH0yEEBgf03xlxEGcctOKAUUqJgKISGgwekBAgIkUQmBLbELE473b1ZKBOTbhCXEpiVZwYBAoCYgCYAiIpBwUoROUEAnRf2WYbFFvD6lkHCI7K+aqwgcQHKBEBARAYQAUxGIyK2AYEqoiigJkP+/sJNjkhNk1Lu6S88uGRHhHFSIsBMiIgIqEoQyfI7FLKIrB4cQmnvh1O90IDxGHl1dJIQiIcYAXQARtPH6/aV6RKgT3uP2ZgqIQwA1BghQNeUJMtOBXQ5QVZBSyACcanELtYlAxASQCFdU056cWxgHgQgRQEwCsvvBWNstFFT5/0b7th8BcYs8YAMCBkXBaAEmQGofAETbgzoJJWkUTAGjmAo04ElUYV0pVBBmAhEApDBUELc+QtVyb2WCGT+quZvWkjtE7rLuRgdEcMuGpC5T2Yz0XiniA0kp5NTDBzpJSLIBmCsZoWZdAAHFIQot10swghCptYnw1m3EKSoqMGEIkyQqll5M7p9/nBNyCAHRgBE6zVldUk8UAKoKbwPKnuBdBqBCdyYERFRE0pCop/fN4tsuqQRFFGKmEBBqJhAlbnG+lXMAfZgHR08KsmTYmiOrEupQ8VCz47Qsy07HlLOp0IeQStL0VnvhknjrChSahnJSyiWyynmf12vpA5SpD9WVKhAFAZuWj57KEk4XgWSBM8hxCxKyiktKogOUW/mL8Ei1DuZILkiJjdUJIAJDkti3lUgRioiITEMl31+m48F90fgiv5/fNKKIminA0HlWkVwZkW77hXFQs1BSHmkEJCRFaJgmJgEYpAXSXb+1RUDEIZSUikaQhEJEVECqKSRgwtu2oDG8DRHY83rcXXujiAizFlNVWz66f9+fHfa7/PDx8lHaugezg/FtdhsQMEAEFBVz8xlaa2u7VGbTi7XjNR9HaItZNlOQouCCPeQVRnTXUJE8VTpoxRMMjlI6oDaMEikHFTCx8G1WBgxiQqBcZQBBZXhSiFHhIESCClEIBUnPE7etX9etv32qW+soUpKphysenmNaSAQf5lVshEySgpKyjBjjYNC5zCY1NDdnuGqEUJ9//2qVJqBMHEihMmcZw3DbgyFgaI4DCaqoNQBKFTcvz+6XOKek9wUumc6RMO2fpUvaHqFrq+vldH50f/nU4UYhRUxF4CSyqVKUUAlTSnB6Ma/t7mnd9pfOiN0u9VGOKoPiEDDlHa9YhRKcp6kpZAPBaWDGfkIKze7gSNFVOXvyCQIq9r7NUFBUcp6HlQpLEiEUAeVh1wcsiRAoZaSIwX3NwSEEBIkRkn/9tffgoEp6Jl+7mp/rQQ8vXvtdY7JFesq7jLBxv2ONc5NrDYTf3V9i2ibPNs8hcVVARDEOOpUhYJ+vzHGL96QN1keuIaoTnq+WfA5XT0sv5SrwXRuv73tNNB0z5P75ekopUNLSaQLL58Ny7WX/nfu3u482NVXcYnArXipU7MAxB8s8H57U9aoyNebTmhDNiXKwSqYXHz3t/oWx3LfjokuJ/adJP93Hp8/9s8/n+QubXlzkxS6OaS6xO6rVnWJX9HiY9+4RNF1UreTN7q5uz4Qu0+xJxPpVpkxR6hJ+t7nI8YW4TB1OEBKAQPdPVAlC+93xfYo2zkuKltbLw6c9H9NDvi73F7nvd9PD9enLdJXxbJ53XUrbaRTJH/W4u7w78PJ8We6fXz/GdRxiep59zO5MaYfdHuOzg+ymlLPc7dMF3eXA4+D9oraibUVEH3fXeT6el781vzG/toZQhYpbDBJ2ePOr9ttf29cbwNSsKHHbI0mASYUWnbIgnWHvIo8lwua7sK7ZVSDSzgF8mt6+9ss3jxfHpfl1zU+PY6u6bvNo5/frL96f37i+v7S+7xed23DKdcTW10s7hSS9r9Srl/xU6sUnN09fxPTdhkNwt+9d9OHlM3Y53M9Xm+MyXfebQgAQmo38SCfVhyuLaFkRoXNHb/ZovV3klD95+kbaFSIa+ssYH1qI9evugxyHPTES+qnHWlK5BPT99dQuVexgKx9H1Pg0benSu/pcnq7psb9IVfURSMv8Yaj1ytbYd3zQ+eHTj/00PekP/q3x01JiWmqBadjL5f7uqeyPfsXdbjzl1eBe7QFWDGJ5wI6J+7Y7Rr6jHpb91GJ3xA+W6zEnvjhRsbyQki96/6L5ZS3315dfPNvKF/mLH9f2xY/j5fO7F7uyvCjy8eH5X53S5yl9525/X+yw6G6/f/GC+f5Qfk110x7aI+LjL7aO2O+ata7nkNO0k3KybVPwejmvGK3PT5/efVPI6RyOrDHt9sf70Pnp7OF697Tkq7hJ2i/Pv/vgLef+/Crb+ytVZULr03zHu++8wYun4ru9witme0HcvZhY0rWhlMSDVJG5XrRyqUucgGoosvrjJkJ5WqGrSfO6PG+4ik21SfYvi9/N6xaubf9b/73f/2l4jBFCzs51vHsj+6/XbezfvQmpSwlLTfayYMXk0gJiI8lqtMO5i949yRBrKE0gKqKTPkFSldQUQvFDSnyklpp9YBxQvQydzha2G9aGL01E9nGW9GJbe1p8MPJwcWvYrVM0+eS978uWj+2cd9LtUnje7p6dpFxKRu1yzbx+0rd8Tj0Rv/Y8v/qz5a/4l+UffE1O+2tE1tMyPR7ApjV//MtUPGST0lLXVGRkjN9+PP/un73Zr2+HVxz7+N6ba8yu4Qx1qM90FrJO0+oWGgV1wuAwiHQRBTCSDgo1hHwxXZ5EDfsv+PZRhILLMsZnOf/t3/0//v11KGG/9atr0lV7frac06/9yasX57GcMWhUMcToKK11qOahS3db5gXarWXeWXqYrhOkSHI2RSDLojk5phxKeJtqT8NpubuEDJROpUy9clIYotZ5v35o3WK7DJ3aQOhn52Pbx9DRuixxWp+uEf28fp6O97L261rPbXs89ybDLedL9VDg4zGtb+RsH169vT6d72tylzY6X9bjyvtnb/kvvp6+eMMpsWzJuSPaca7ny6v1V2+u2/x8jGn44PWqiBsEgVCmNiOFNEH1UHB4F48IUS283X0gdDMTQnT3NNJQRSr1ddvuDom9R2FKy/zNT1796Bv76PrsK4wt7042nV5fzn9++fzr+1MtrnmYZpOcm1mnFbd+v7yPWbbxWEcc6NzayE/WVO4vNWLaBNFz9m1AvBMpx9QjRwwDg4HAQpeI4AjRgTgeroetcQlCIhDhwL6O+9auA0DKIz+lEAnpwDpqe1fpIcplnqsMMHat4ZP76UFPd+3d5f3D/jq/ubQX392/r8hy3+xf+oWNfto/xJ8v7Vdl6an7Xc/y/OX3u2bRB6t930/5fH044a7k467DSTpHaOFgY4NHOKhBMYqBIMhAiJK3zwoyNERS6yMml0POsWPa0O1wkLpO9Z99dRmh47dECruf5k++KQ/3D/1l+nSuQ0iaLCYl5RVK6dljZxcpudIJ5gJsEukQdqqcGyetAU1iTVwQIPIe6RLVwlmgEUWizj0A2afHBXYB1PbjLAQjAQ1IIvsWTKwQG4uvH31wARIBFQZIDXKSDRSB2qAUrB9/N3/z8S9+UXYw7LjNE6/vYtZ1Ysvxct2aomxCyhHX+fKsDYe4ouokVab17jrt3k6fXb6S3VLPhBIUCik3NEosArDEESImpCvgAgnJHAiBJEdYigALxzDoF73NDHimjjSAxymfMZWnY0K825/v07Di3gsK9XqmQ234vouK6MI1UpdncpbO7Fys1Vy69iQifRDp7h0DJSRVSeKgTD0cdx8SNSRgIEhR310sa4t7vwqLT3L/6auvNagtWXCEKvaD0kQ4g31Yv187hKIwMHWlKKuGDgC6o4/UBG7H5XVgrndM73Pp426Ot7v9m8gi7fhJR5pe6QCxmU3psXqg3C/p1Hm/v77ZvwzXcHv/1gFhGVTxlDbbtyvFUidE4aITBylzVFKkmzIogjKc6oCJdtEMW7P6fDw/zgFkM1+C25ZHqLnS91yO443POZRnla6KeQit9/rR7vLOUtIonRLIZQNTccspXUTzpqBzatOhlH3d7Uqoix6yD+Q7VAOgDgqA8AgCZRoUOER6hAxv7frq8a47LSvkdqcs2nKNyBbohdGoiynTYTBCkNl9KhRJE5FWoeckMZ9t9+Jhl6t+OuP4cr1/MXW5dBU41M5xrbxsYVvZzfH+LK6F55A7jjePHnXtG7Zf7Z5GVlJDVYWwEb1rAV1FkhBURiQZrg4oLKc5CEELQWg2YlfCfeAZfd+3s41geHjU6xbuClqDYAhTGn3UNdvzU4jtP3v9+eHw7PN/5b/1V34tvra7y8Jz0NOy+zBi2iI8AGklNQVMber35+tTjrrvsauGaZdqrDFJt5RHYQoBIaKafAiAxVSrMKncZR2zyBQ9gjqooj7a0VuZ2F24pKrK4ZQlJ0A9Io8RPhDD1CRZ3svFhdNB+8hFt/Oltgvbh+v5DNEpZNn4obTLVnvZGtrrc5QmktI4+xataXjUS3+89vdhUlMZSUREGxSqcTzesEcBoAEJB0KAZAleb/gRxUwAqHdXIF2G7ysWv8Ee3pvIEAQw1Chs1xNWD5Y+eJbf/lf/q7/x+PM35d+d//R/+F/Sh/9zWjXSvsdU4pxVrkI1qdt0Xz0PKct5pHjNT9sT0gculzyfqBul+FWLpYnBw6Mm76IZgeA0gBpIEO14FMRIcfCAjQEKmZxn1RChdFnn3fxeAdE+BkEU3yAOS+7Iw9mnswkQPHfPg+eulI689YTDGGNNo6d12p0HdjtHdEwiIZLENa3NQrpbBLcQaAy1dgONg1OJOt+/6t+OxggyNNEVKoPsQRP+JXDNgABBXTJcyxBMvQ0UgW0MUPQ2ajEidvVB3jIBjdLmv/lf/M3PX/9v/9Zv/s8f/hfbL3782/k/k47v1/2koeDOPjCPJJhY+ybVaLp5dIa4RGL27dAumbu7N+6Slb0MDtaDw7pEM6A0vXvC/bl3QYPoNNx8/pBydipDLOmIYeBqFOE45ysBwRicyWAjICB9yGAgAzm10IRrjvE0FBIUtnREv1IJgXHOT08s22o0oYiycowiaiNEoOahGjSBSs8KVyII77ENq0qIgiHqjA6qRKhCfIRAqGSyGCAFshSFx8ppbmdRLcO13xaLAgXNQ3U/nKJIQ6D4rb/9n7f48vRb35vT39gO/vk3X5hnS1RZNdDSbkUiV7VRJIF0V0NoPl2X3HugEzFYm8iYrMrzdO5l1WvzaagOsYK6DfbQg4honnv3tBCmcJKiOoZTPIkEg5O5DB6CFElmCg8IkGWE5jLnOcvo2pMgA4EAhUkgeSomKQWjZ1eMayldiNEbZY7mgKc0q/htiGjZVcxEKSWjgaRM6hYONjGHyA16DiSPPGcREdEkpiAsGSgQSYv10auoT5sNu5tTEkso0GCaqTIMYORVyyy3h/6V//YX0xH/yevHf/Rv/Fe+/vF3/9FjS9Nh2HrBtGJ3JkI2CF1gEs558rxCdyMlqzp3hwZky4cRs1aRq+UI6yboKi4RXSUwNLUmmiStUeqIeeKI24wkREJo6gkjbLioYw0DoWrRIVSX1ERJumUAFsJlS6spRQywEB3oFB8Bk370671XhZgCacP725hN6SMsbNY67DbzUDLn+aqg7o79mhwSwEhQTYNeiAAMdA6HhHWJBIprOJSMiIsblaGXeRWLKV3Mp8XaZkUBh3oa2nC09UQpnXL3tn/kHP+1f/se//2/+Qf/60+3L/+msbqocErwEXROymlHfd7HkruiBhna5+NqveP43No81Ua22NWpxnUmZEpTrumQQ3k/ZpuKzuJsvXqaQKs+ghCV20wk7duhTi0CNubNZIGDs0G88lvAT4PeWmClInIoaxZLIohw9044xyARhG4ySJ1n68MLhohkDZTq3VnU67eNHImWslY6zKS1NvJx05B916wh7i5xG4p3hxiIWUkl4G7ZXQTDoUWVkTdCrF3XEMvtxIC3GuojAULtY6jQLO9/+tf/msJ2f++/eSn/ePtrf10//9fkPs3rNXb5nYY+G6v1VCGx+/T6Og5th628fLvTx0UvXaw9//RN68MWbNMSZbusxS4h5c4DZ+dCmy/XnJg4WDzXNL3jPvWg9qG7Hqq9lPfLCJfinclN0jaRaQQ1QiERChg7Mt1ErGydhYoYEAipzOzgDcUEjOaLb1ksDW6SPQ8PgIQQwqzSb1MnQEBQRm5T8sHA0ktTtyyCMUItXG4gtwkBWArvpk2lcJOsoEeIwDB4OAtu5Bp1UsPEBcpgFmgwZOlbKVbud7/x7/78l/Lm+MVX//SHn7z6vv+f/m/y2Yf0rJzL02R2mt4t1zxieXnB87cnlEGmVCnSn/PS8piSsrtEl/ku1qo+splX1SEhkqa0irr4AE0iAKjwMEbD3IMlUiQfYTaCuwugQzRHYV1iSxEGAQeETEKCDkvKDS/eyiG2g6MNSRhqg6BaqUEzD501Gl2WfHILjSgHPdcoGBZuoIqEZIp6H0KFy+QJPtSAoJrK9Dh7pg9B3CgneV9O0ZsodYbyLEzqcJm9CTg1OawDQpBQAZGzDwYBpaoAAY8yyXRXfpJ+8Hs//oc/ecNyuo7PPvvsb8ihe+GdrIftXGXm1Pvdh++e3NFh6k4JaMihV+aiGkMjsMGGMJWLwnaXW4uT0HQ4d6SObNG/ZSXdn+fRxKSHaHJBhI37jUNLetqfbLaoPduqTJkwxwamVCLoI6AyXW3Rp+xlHNzdcpMWGkhlQq8RpNjBI0Xdm23djS1ySro6FnQGINLVwoQyXMPAobtMk7YC8sB3IbTCEPOI270YkmVRvzZAzagGJyOStSEQiljnonUYNBiACoROQAOqCpiD5LBUdlp+53s/6M9/oj97jt3r/HnayWzUWCGS2pLPQsq0lZEHJyk+nEOWNnejWEm9scssY/fm/n1pzBGKmKMJWBqT2RrJFZO0GxVmbnexdY0QqHKIgExT5chD8li6bdTQ4kr1oA4KURAoQFQ3QnVM7okMCVgW+iBSdkIg0oOLWtuEovf6Xqi3o3JwTOhphN24VNbE0wBNnTkxkHwrqfJ+lZ4wbjN2C0oIQEkDkogRKk4R2cGpMhpFANWmKXL0gEhAdom+OWGROiQXD0AU8CYSy+Hl8++W6+ia24bLX3z+XPKslj7o/VOXYlVa6RSVwMPhAyB1U1HtU/dIOa0uhKZxIzOZDVdB0OAiQVGftXejACrktB8VPtRhieGQUgnk3XvMjaVh6nN5xGG51MzuLtPYl5WjJZMWMDHpCtfB4xa5a1BJERQZvUxrlHbM6/mT6d3VnMIcaQhdI0RV7h4Lq0MU4rms4C1WKa1WU2FO8AtZYljYoTYNmkOYZGixiwVznTdLFQkxtyHKgLqCmvrssufWQ0AesHoIDZ7CDTp5iOgog4qou939nFsoFl/7Th87RJn9/vi6TWt2sRGSuuS0iWEvDU7rpBoaBLlCHSKR9/HE4zb5JjaMLpRJVnORkW4oGwEouRQ164/BtD+7Zdn3J0kcqSNnri/PbMmxt8f0cHjt9/W1CGcJNGrSbBJbW1ZwXnfW3Ex7TeNlvm69DGiumCbPb4uMPGMI16BkBu7lnTrFNElEw6SdZNaajxe97L3OaY3IR5WKLcDspJVVl8ZyDMPatum+im9gk2f5qeahlNBx4wmaF3YBFSBYlohq8FxsbRDsN79t3qQhyi4RzZVJUcSvLgKkrENGWU6Rp2ssG4TIebGW6FyfqZ3uptPVetAucuw0OVz34+Xr/t5m8e6SPG0sKnZB0qyjC1wgz7ez5n2zuFjAIUDKvdtv/LNhjLIfl2LXNLmknlTTGXm4JwE9GV3rlCf7lYkL9UgfLb573i2/0o96Pfhq+vagUrZXvza+XuZSJ++o63FG212e85fp4aLLZXziH4qEzn/+YnYXzaNxj7d5HpMPS7ziirB8nTvF7P78Ynm/7diOvR3L63dpqYLjqUdBcW4W8NtBL/dYrqUJsMim4fej35Wafyk6NRGFkkGCQp0i11CCPRWkOIhNsUfzvD/5onbmM3SohI62tiQtdP/pxzk9fPrDu/1yfO/T8f2AFbzheLvO98fs8vJoOzjcR58yem+BoCmnWILQGU/UkBKJBOeBp37YR/jYRDrn6/Dq40Jj3XqH19FDVtYO5cW7Unx5lt7mtDtsTx8e1+nD23M7n7aHseXT28P8Bq2tT0jDZU5Lf5zuXrWFWcvwZ2W3vJk/rGu5u+DD2R8/FK4t1p7fr9erpXe8w1b2UpHL0nvlO1eZyvutXB7Pl9x7UC+e4N7nVKbsAihv3DUnKPtYsyzLmEeZ1mk38lSIG5HPsE+ykw5J83Hr9uWnF7X9JBbIodPoY1/Sx3mtboHDQytlDIHuPv+9v/V748Vv/ovfefXZ78x/LHESHg+n08dykRi+Vr9s21NVlOcyytRKVgPyTLkrkzTeHbhFEHO3kae8n7uPSRBhcbSI/VyZgDBaljRHSkgq8iyX3cTNtzI7Ytc+2PwyX7ksD5+XzSQ9LBbhlz2j6CXC5oUpjRL1umzvuIz7whd8qtO4P44cPsw05SE7XqZN7wsnQcQZZa2W7t/ipa8b9Nm9P0E/tCQfRvLURFmagKSyObzBJNt+Ekt0EIshUhUVq9rW/MFHq3RQBEGyjqjZcl4xUvry++35DthWmbvnaY7HqQ8bD/Yk85orOLuXeX7+6//y38n/0e9/gaP/7F/49PW//4/rU04dnrrmyaw8dURM1ubzOAzPVYKhUBDKlKsLwBzw5LgtwqY9KCB0jhghJQYAuJRwQlM0KMRTbsShAkEZEi/wwZUCKatICp9qGeKKl+Nx9/nPIeGSawkw11z0qk6UtIWql2bSRWLSixy24GTb3ep0KTXDKeQyv89lkxuNZ+ETcCh16i3UoqtP+QnHPnltUGPMxbtDcfdBXATEXFTR6WsctwGFgCkNByk5MHC479e6n8Wk17brltyCZ+aeZOzmyXcn+LIv3Xbz/rMvl3/pX1//4RbDx/b8h/b1m3zMqWyiVEa/PvrQnrpIA5k3uY00ppu4IcOzhElQpv7xZUe2KmFN50izqFQ71LsduUAkqw+ZITEkRRpILZSqrtYTsl2vlNkhEVk4yvFuJqfSIr0/lnVIlzRsmqZ52QrbyBqaPIYh6HkwlV7q0GWEiHM3eECoHLwrmHKvS8rqi/aY53zGvGsra8sRnfOzdayTdIwITmUAGRth2jo5JQQ0hviGbVVbPRcNkWBITg4OCWI8tv7y4UPr79ZmtSdbYr5OS58Kr62b2773uioF6C+T/8lP5n/jA47rT+8/Sbsf/MOGfmH2HrSW1Epel9izDiSpxYslvR9nKMldxKfTOw+RVfc2oWZRAD3P7W7LK/2Tb572P9r96nUsoRyO03oIzqBTUzDLSGnFIW+S9Wnf9uYdCcFlKmvVu/34YDwfcpPdSVJffMVQUVXc5avpRzzrfj2VXb0yCZfdtWQ/Q3DwvNO0T3dr0rYIp7Ylu3A31ftdbo9aNETH1NqRKnwnz549vp8LLjLrFiZdLGffCnnYoZEhrWK38U46Uma16WplDinc7c6Matbk2Y/foUnM/Vqq3bG1pjT0NaaC9HHPs+VDj6Dpyx998nD4/Pu/9eUPf/xl1fXxV0/rUyTxSGU/J6FjNh0nN4xI0zZ62wuPJSLERj8/wvPku3zxE9zdZq8sR6Z8RrJT1vnv/r0/+enTxIZx2WIvIspWh6GZB5tPddIt7itb0uhRZu85ab0G6vnp6vfPv2mokaQdo4JJPZfa+7qOsdWHcT1r1LPnFkd9vwBzjP3uvKlv0vtWbXl8tsxepVBkimZTvOMmF+nOKTSulZyzbcMj5mVWyYS6FOvTcCJij2TswdF15AiziGBjcLlsrfX3m3Yr0wn+9l0dVYbmjvSYj149Tsol9dbjz1AG2Rcq8/G//NdefHxj1x+PL1798dO8sDfVJuyhaAjfEmXZbHkEzoLcP4SkAJAP75FHTdczKJFMUtmqNz7U9WS+jD7FA/xH//Xf/w/zhyhTI7UzbACl9MTBHNHHvpK6bR+1SxOoBFVGawno8Fzy3iJcWRcOkSCGlEA/Zqhf/1SFQbOR7fK03G0dw8oKzJuwEpPGa32Vu3fkQeVuWx8Fy3FVWdS6id5dG7I0esx2CtKnkcJ8S8ltIHC9JAeYOsY0OQcp09KZaOPgKMjScxsPv/mVnyVgTFPTnJIxnSKmims2QEN7gCMp0l4/Su0v1QynV/Obf/zPt64FLpp8BEvTyRkRezSUIcEmCWroLnz0LNYHRQD4ce3iTDbWTXTYFrLF+uE+8Mn3fxn0E1WBEM01SRobNegijvasLqe0bhMZ3gKgu6E1Jmc7ax7DuiR3qtiYNZDdYDEq4Lq/mBuvKdJT6cji7ho7t+GSoodEb0RKbpE9TQ0aK10o3LyVfJ1jYLjTtmnGdeRZW0kOaxdiAplGTlWCVqidCMlSGV1yVRsoLomLYuTpYrLmsVstd5OxtmLuABndRAMigMiQeX95805Of3Ha/vz3f/oH/+hn/48/fHT3VgdUPZg8wT10mmqf51k2E6CoDJekw4UeCiFVRKpLCEaIOUyHwKkdL158+Ad/MZCQwhQ5qViQGthXgdOmiktKklmHjC6iMhgQhE6iokodt5EAQ0QMM9pg9tYHubj7lFJDkCQmcww31xaIb8VnSZ2WxiAdbRCEGjVzjEgA6TK6KOC9NiZpA2RsPsI4xADFgCokxiCB0rsHwZAUxJCIcKuijwODGkMYPdkQDBeLYSy5t2GiwaRINk5/+JMvf/LwKyoup+vj49MpbZDAPLonGBKciYlr0Q2H80KMCJUQ6YAIhRDOc27XCFJAxbROW0t0FShS/MH33m6S0VkCKSKAsLRB5Fl11zTZJr6661y7iKbhOajmaVIP512ssG8lPmRIac1UtpLorlfJyXxTF5nAseY+iihDSpU0HNNQdBobQSEU0EjWwA1ioYdHzhwmAEMFGQMQsoupq6pNsYlQ1CdxJukQCzALlSEcLEJ1ZWCkRKTWVVN1S5llNz3qjqjX2dZb4LO6avjbqu3nqTXJ/bRet+CH9DIps2B3ukZNvYh0HRZdcxPpUPGhoU2hkNIDsez84khVU5EmkS/X0nXuRAq3+g8/PwkkAjrCucuXoblTeHEhpkk7lfmL81NJTfZW/TBVHTToRfdlUvIhViVBKdlt1INs0lbMu5ima5WVIrpco+w9RMOl39QwA+AmjmmzboqWnXPixgEVlp4H+5OMVSOFCyQlDDfaACASykBAhEh9HC5CjDKNsiKFZ1E3rQJtuAlQYUIOlMm5c5WP3qqUmny6Pj9FEMkByZoVAPMyIXud6dfa3Z1LjCmSXVJsOTVpypKG02LHTcZcTlQ3gVgwWVMP6DAi5jxIhiSWBjvJErqVvht3ikuMGoX7NGqN7CnIWbTj2DZpIPL87L3KZX94F1++kU9+cZ78erhin58K9aN4W3hl1hXF5v059mtLZw1Lpc9znGZep7gsv/mrCpVDa7vgrr7a6/rpxz+vD+9yfJishmLw4zzSh+ef/jN8/Ku001+MpZZ8ZbbCp3w4xV6H6pkLyB5MnpEa71Fs6NuHl6eYTydFDOlJY8Haprzdb6H5/Mm6hrjHbuFlD3lxGTzOeeysvkLR5mBiszvE8LxDuDYWB8ZVeHzSdIwT/+ovtr3FxZ22lFPIMK/6rPZOarrpt0gbgI7cQmksqNN0RkCkSV5W+h4X5QzOMVYy6QhiLrUrOXdGVu8plJzKpWT84A0+fv8m6XQfZ+uYw+L5ifiw/sa79NHjNl22Z/Mp3311L0+xO/dPYuX1NLIucZnvxMa4+/SP3t8T6R2Wu5Ppsr9+I3jxb/WfiKY/ff/Rwx/NH8b3X8cnb/t8lh0jyXaG0KaQVrSPbwWZeQRyFyHE3OiCl8ft8vAXePEuPLEElF05nv/aP7dVQqUeN2P0kZD7npvs+5C7aU0P/XLGuImvPamgAnPp6t4USVWuMimuKmFTbfl4vuvefZJrpKS9SZa8i0ehEil3oiguAShKgyNLPLz8WU+Qxrgv7xM4XcAvX+9y3cKZ3FO4YgyYhFr2KiKgeDIYY68h+GBNbR4bjk/3uko9bHqscWh6GUnkumzz0R4fklxP42VInOL518fDO1keznfTqZlPshsffbNK/e4Xf+VHz/9Xf/TDX/5Pn/nrfPofXf7HP/j3/tE/5fKgC96vue+LrpfYJt2UXWaFmpRaxaXthscszqC/eHb+8KL1Z6tpkfVcp+dPFcVi85zfHy5iNmm9w6NQvSlDFEhNEq44YxWkHtEUrhi5FaF4JYOgAKIJclX1JVo9SPug7x2SxrDUR4pUagwnBRCOQdHtJv4O9GwZtOvpTdprq9PQdnVXwRL5VVwDOlUJKqECFVIkvEqi6Fi6TZcUxIl607SOy8LldN+8SXnK/SnSN3m/vJ/rUE51pdbiPuFX85hj+wqn5tHf81Ue0Cnqg/KrbV5fPv/hF3/8f/h33n/z8q1/tlzXr/rv2j/5xJ++TofG7bp/paC5jiGYUu8yRW8UBTxvIXujXQP64QPxtco5yZoXUZwvyNZ8aN/0/qiXsBxW94rd9VuNy6bpeHd5WzKV7goxd4UFPHnKMbohKMZQSGpTrFNCBC/JukOyhcMJNlvS1LYOddEgYfSIhJwFrY10PvaOIlubI6XQLeleNx+h5Wlj1pPJst3FCKdO0d10ZAao6vlqpYqJmMfU65wvsWHjo4WgmYUfsNlo2Jwp6MdLbqsmptF7DwmDwwhhWGCDfEj1/LCfx288ww+/v3/2//z5M3m3f/Xw1avxnfRw6ilWpkhVIo9mamlgEMYWgZtAzSPlS7ZOZvckVIbedSyXDslwTyYxEsvVhyyoetfqPC4jlcA89xHJ3kneZ7PmOrK4MMAENY8taNGFtzNyi/LuUz0pJdRIANGDJFVgeSsOgg6l3rhq+ZSYkrIF1mULm7vEjP6s9aRDrxmml7pRDDJLIENByeGhIprDSB06ms5NZg6bVjBHDSS9iWKxXIYf4iLcHOqQAWJDzRENRJogVyHGDZ8EVZ1gV6LL/L2P9e2rr6/2v+m/86fbdJk/th/+7CVt+E0FAHTs2ATBAToElDRcADWn9lIpDpIKHem8SROF5QaJQQp9Ptqr3Xya7si6hsqATj40Rxr5HOehHZkMVQqVEdqLU+B/6a0QDuNsV6VNzQdUQu3GnTPQUmdHHmLFSzM/I8lK94jozOREzHpR3QRp212Nh7g7NaovPWWOqz2g8hSQDgAOmCnVnADnbZm6c4OxY96YS+2AUUUktel6HN9yngFTKkIElJiuQ0TBbwV1hDiUk035cn9PNrn/O7/60V+/fvmv/PEffPoH88v1n8juyUNdhRZI9AF0qoJgAEDP1hkSSBL5WysX6xD1kgaTDocounDZZPmQ4viFfoI1PcY8McZ1XjOjwXrajTHd+HSaFIk3DwqH2k3KLwInROruOpYUrYxkAZZIKipC2oweYjAtpYiOsDzV/VCV4ZrFbVNnLdxFSfsPhaU//1guKyFdi1jqBbVpv+k6haKqGNCgeuRHmIffPBqGz7l2kqBCtT0/77c6AcYZBGCSCpJRzWvozWMDeXIjJCsnktN0LvqTL1/+R3//k6cXP/7t57/oD988/8P/4H//H/7Z3Oq3VIEMSEQIFjgIGASi0uPG4NW+WwFQc0ZKMu+IFEk1LcqwOR8fjmXFQc6rfVXbaBK1Y8yepmWznGsr6+CioVnsxmU23AjPTHqTVJhF6PCHcr0buxhmIgkBZBIGY2DnMCuTIoarmI2JeRZ4iqAOkQjuWitRh7bFjvP7JhZ3o9cqNW+BBvvWPMPKzXciCE+uwUZRCMCQIQwNBDhyhjgcSFkGF4ZwSmWepzxRk5Vsqnn30adzmqey7OasU649p+vVfu8fPL3bf/ajT/o/f7e95qe73/2rf+PrVLfHeUQqU94Y4rsp1HvKyjlRYdOdcYIlLY5zApFMJ2kB5CodIgEfSFruZ50Q0/78YXsao3sK5DEnLpv3ZMd1sfslT1efX/iYpt4dAKAI483/RCRThtleD30c9HosncIghC76bS3TZRboaOsQ4ehfbp72Sx8vpy6TMI3kFTH5nEe27cvf/X/5zm2FLDqk71vOKUG/NdYwRjAI1zCYiJpIhAtVu2IiMWWtLWoS0GITRw+RNLoPcqwBgaqFLTpeEzATtAHdXxAIu7z4zU+/9zu/s0vTpHcv7/XHXMfj63bKo5UBY5Yu7nkLCHwgXAD1tY+eB+mB2SRUTCKYfT5w3JxDilwO+/HQzuf1OmQguUhadm03jivhqpPIM8y6nZ/Vq2VpI0cPNTeFCozd0ChMwdTn9rA9Ha73tBLp3fjW3SKDJCTciON1pGY3kAEie/lAiHwsl+m6Bkxh5W699mfv9bPv/vCf/nxsJfVQjH5/yondixJ0VzhhhQ0iAgSs9EKJETDqxuRIFs7SRR7OPtfBEKP13WWPRqExrIoIY9J2uIrOrc8VxP3j5E0s3z18/9cnO5f3BxtesI7r+d3P3r0UzB+e5vLBOqDz1LoKZodhS2l0A2KE5ARcIWImIl4zxPLYpKfcLGxZ3qcteczXqS5VxaRMj46uSAINkck/272qqU6sFGB8awsjRPFOC4CQ0oHk/ileffqIZ6NGrwKRIVYiKMuptDBNjdPwmIaAYWm6n4hT7k9dukz78aQFesEBVfn9H//sF5e79zoCpcuySSjDuCzvocfWe4gihBK77aPHKnkeaQxwZIdlMFrYDFRln8vo7NnGsGmbBE0hBKOkEOPqiSL7CwCBq398Lptk4/0xfTd9GH4tD9vFHfX4h8WdQ7qC5gOLeFVSisJDmUpvWSmtpHLtxQFjqJcGoR+4YiTHuPOVMLPOeDEeMS3nyUK3WR7vzi6YEHK/ffEVZM6PjFtagjdvppsblAYBEddpeWcfPVJLuvquX6EMpZoDKhbdD6Ni8Y79dhynhIAu6XFim3w4kMqmGgEdAlHZf/qZff31G7EIFbFcVcq2fPRVPVzIuRWNEA1064fLs6fYET2UQ5LvynnuTYbFNMCALHpiTsnHcEXScFMQYEzNpBYdIiUQBIPlkPRNEtWkH3ifMzbuxEdmv//TlpYRDH5rA1bWsXi3sc9nSGCvfTO4OLO5J+a87i4HWa5n5bJ8GEdpF9ttXWTW85Qaj361QVWwdM3DLrlBMmyPd4KU+sQQUZkcovqXrk+Eyo26r1Jq2bFVtJ7WTgExWexTE3DTvlyVd5fURbFJGkJy6aPMWAcpgq4RhYziEEZJ/mojqZFAMonLGPW9zk1VaEopU6KmLVXp6ooWCJmKWcalRlBMOhllSRvLKEB0B1RHKAQRZAzTyBIlE/Pxvr54vqv3b+rVTSPaSumn05rey+V0GbI+DVkuJOMvremq00Oc0kERmvbbgVBUJSai5XWfZ27L895OOkQGMe0+smN5suk4LD/KUmpGOmymQfrheWfayV315+f5qjeyuhImXSkKFyIgCBHqNPriDUJ5eXbbpMgWOXfMHJED4dO6a313VUA0KKV3mdsRvjqCJpFePPok55dvxnSsnnReHxf3mz8fCjmpyyS1WrgohqqZb5ktWT/aVgHIJBq+u6j1RrFA2T8i7d9bRVJnQBJCbzZahIRSpIxP/7Py9/87f/Gzv/3deO9V/+OvXntKWhUuOUtObS01IoqIlQ9A8OaDBTolkD2NBGFpKXWGAyooI1vWFarOGFTPjijihtb1QD1DZjme2ES6ggm76H2+xPEkebGso/N5RcRgFE9uTua7TZ6lpseNQqglb9N33vN56XLGQMYLsU0bEi0lVdn7RTqMIhrCECCSjBh1UwKGkjWd8vSElqTUkRHX/Xxd2m1whCHovXUdVRw5zUvq7pXMwBGTzL3BiKmIxmYYYiBitnM6PDzGQgtIYk6k3kzYFCIaNB2f/J0f7z/8vXH6u7v9J59/+dL+0//0+dNkWYdS06jXS5pblqUumuuK2wGUoRFhxK1Rq8YQufHQTIgQK9PtLohISadRJfYRWvW+DErowwdfTZ2eMVLWwdh5waHvMSwLQq3dmOSDQOhujGvZvEluihAwhoa+/SjqkClt+4x9fxxMCxe2BrgQFmnXUUIAVau+mytFExdwHqDbkLZs0JYndum301XQkpAWs+cyR+8ybNkd6Oii89DjOeh3+XLF8+fZph3Hjr3AaEKXtrT9dpk8S0hWTFnipgqRdDPVSrn8rb/+w//k8Oz3v/PXdjgixf/9k/+YNlA7lYrrwMtTy2OX+xiHR96T4uC3rmtacsqQEpadFgEJK06BaNQUXRihKSVueeh18JNrPtS+23m+apjH7DIU1E3suA0xjbXTZg0bWw4qssTN00sCriIG5mVImWYx7QtiuRu9z5fnOWyNu+LZPFSVI7Qh57DdJgyPbCGpxyyCmz+EYOCwTpiqSH/I7l6o3ookJd0oBvRbm9Lx/tSqhnkRWt7XKg0vl/U6tfFUV4feAVZlYiI/fq1ldzghMTjMQhWDSbIFQU3z8d/+tTsfq8pHxf4JX/7kf5d+1n7jHWTw6P1F5Xg+usYWc7Z8kjmkgAmY56CWUtKIJEEtHRo2GyQJDKkOohQj1UarfvC0NL1btscBzMOxJZsb89yCMiL6hjZqg0JtEuizfC0ICAGPiJQJzffIndKV7h4uu6uHXWtYWRrde2yVdIFaC9PocJcYFIHcXRJHVbHUwKWtDhokedkCYtx2NtBKbOnhHI2wm0coNc0q3v0+cc6dxGK1R0699HrZvI2mZYoop8A6Daq59MHozUEIQ4uO4cjJ2F1V/eGTv/jvfme//i/v49//D7768LPTL/5n848+++eP1RJShVxnvZPrF//6y933vhufnU/7OA+KgBheVciAhyjFOzRU6xDsOUz34Z4GSZfWR5Ja2uw79hHMPA8fwKQ9elcFkNQ+lRq5iAdNQ6cXMiYgAGe2femG3dJMt5srBlLa1WZp6rUxYqxLvbiUrEJVDATAgCqsYIhGdBnFRabaGflKkLQ2DdkixKyUbk2XdShXhigJSxmhJh5mw+roEjsWqw9nhPdElcVcQJ02HufLJB4qUy5zc5O5iaiC0lsLyjRlRISY+N1DP/x6Wv7oD5/9O3/ny3/z9/xnFf/X93fVRHxS0SjbDht/9nj+2Z/V14/RkYsrzGg6aZKIG4ugpzyJYYiIFLscp4KrZIlovrNNEUeOMVhL2vIkLpQBkhKWUhoigtP15nRpSZ6N4ff9Ktrn/jzeTog4Xkeyriio2G9LXZ+llt7rKMrNonTkjtlZwiHBwu4hi6aLOSjCXqyPzP39V57CdmcAtku1Lo+H67BcUkWXXrQbRx7LRSeU4UNp4RG648nyixW95hqigFqq5Yhr88lGy8uH3a75FSgj5o2pmYYAIV1UpYgOIBrM6ou7/IvjJz+zv/ovo9mvvYvzH31yWH/+p0+233T9eL20KEE9XCosInQq5+UqamDCuLm+iVOlzrt3mRRC7MG7bRloEmQTTKvurtOmUPWPrtnaKT08bcpYUCMb0/DbgCbJmIY8mLqNfKJwmnWEBu5wjudpXqb5nvU49A55eVvNMJ7f/9ren9td0Y5+0ytyhKUuUXq/uovm4uay163Q1goLy1kRc6neno0REFEuP5wehYf91VMML5NKRzDp1pPmBDzTQD9nDA0LDVlqWMsmtvVkOUa32pmONTIEnSXpJOPoke9lNzeduxeGSZJvdv+p/8b3/u7/5Pul7Eo8fPdH/4XvPJ7+8AyqXOKxIekIyuqIZxUPeim7pyShid4oNzxRTQhroBDcT/3Yygn1bndt2Ux1v42ycSRVpEP0Oceqtun9ikUGaL4fCJGB53l9UTppMlvxSGateh/MkXrIViub6Nq0reulN1FG8/r49n21XZrKpSTI7BJg7okOmszZDToFPLyLm7ep6b6N2qWk9dqnc1DdGPjyPzf/6TTHk+W5p9yCVSR2PkLNieHruNtj5j5lL3xmu+QzxlbbEAtOfaQ6AGxiaYxUFqziX6x9h9Rqra2v3sOP1nxXp2MZ6ZsP5/cV31R7+/r//Sc/fcUkfUyADFmGvbjca/7kcSQywCYve3jTpFoAimWIlI3PhhWZ24am8DJ4lUkR+snyKGYwLdlH9HX+4F62aKtoRiQVONAwHYckX8GA5VatEVDYQlqV7mBZutZ67dbSs4OOqbThzCV1Qnw7rzQNyYLpeJkCKPBpuEPAPgJwURMIsidoph2GWoqSI5dRxm7+N8dPa69K74z9mJLN2VrAIhfJ4rKf4tIvNXicprpufQxTfVA3KNjIPHZVE+GS9m1z66rO6sMX+uTmEnhI+53O4l+/fvWL93/0it/82atXv/zjn/3JhTVmNHRniRZyibu51bxzXbil++NEn9r+ZbWbpLAFJvOytE5vDDVRjezTUbceGZeWAxIeM9JGrIjbqRhLlTRkDu31MIziI6RJrv8f22qFLnp1YfIAAAAASUVORK5CYII=",
"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",
"