From d83be6df2d8b0e2fef4cb6866cfdb6434bbef5c4 Mon Sep 17 00:00:00 2001
From: hmhealey <harrisonmhealey@gmail.com>
Date: Thu, 17 Sep 2015 11:08:47 -0400
Subject: PLT-173 Added graphics-go and goexif libraries for image manipulation

---
 Godeps/Godeps.json                                 |   13 +
 .../p/graphics-go/graphics/Makefile                |   15 +
 .../p/graphics-go/graphics/affine.go               |  174 ++
 .../code.google.com/p/graphics-go/graphics/blur.go |   68 +
 .../p/graphics-go/graphics/blur_test.go            |  207 ++
 .../p/graphics-go/graphics/convolve/Makefile       |   11 +
 .../p/graphics-go/graphics/convolve/convolve.go    |  274 +++
 .../graphics-go/graphics/convolve/convolve_test.go |   78 +
 .../p/graphics-go/graphics/detect/Makefile         |   15 +
 .../p/graphics-go/graphics/detect/detect.go        |  133 ++
 .../p/graphics-go/graphics/detect/detect_test.go   |   77 +
 .../p/graphics-go/graphics/detect/doc.go           |   31 +
 .../p/graphics-go/graphics/detect/integral.go      |   93 +
 .../p/graphics-go/graphics/detect/integral_test.go |  156 ++
 .../p/graphics-go/graphics/detect/opencv_parser.go |  125 ++
 .../graphics/detect/opencv_parser_test.go          |   75 +
 .../p/graphics-go/graphics/detect/projector.go     |   55 +
 .../graphics-go/graphics/detect/projector_test.go  |   49 +
 .../p/graphics-go/graphics/graphicstest/Makefile   |   11 +
 .../graphics/graphicstest/graphicstest.go          |  112 +
 .../p/graphics-go/graphics/interp/Makefile         |   13 +
 .../p/graphics-go/graphics/interp/bilinear.go      |  206 ++
 .../p/graphics-go/graphics/interp/bilinear_test.go |  143 ++
 .../p/graphics-go/graphics/interp/doc.go           |   25 +
 .../p/graphics-go/graphics/interp/interp.go        |   29 +
 .../p/graphics-go/graphics/rotate.go               |   35 +
 .../p/graphics-go/graphics/rotate_test.go          |  169 ++
 .../p/graphics-go/graphics/scale.go                |   31 +
 .../p/graphics-go/graphics/scale_test.go           |  153 ++
 .../p/graphics-go/graphics/shared_test.go          |   69 +
 .../p/graphics-go/graphics/thumbnail.go            |   41 +
 .../p/graphics-go/graphics/thumbnail_test.go       |   53 +
 .../src/github.com/rwcarlsen/goexif/exif/README.md |    4 +
 .../rwcarlsen/goexif/exif/example_test.go          |   42 +
 .../src/github.com/rwcarlsen/goexif/exif/exif.go   |  619 ++++++
 .../github.com/rwcarlsen/goexif/exif/exif_test.go  |  202 ++
 .../src/github.com/rwcarlsen/goexif/exif/fields.go |  293 +++
 .../rwcarlsen/goexif/exif/regen_regress.go         |   79 +
 .../rwcarlsen/goexif/exif/regress_expected_test.go | 2293 ++++++++++++++++++++
 .../src/github.com/rwcarlsen/goexif/tiff/tag.go    |  438 ++++
 .../src/github.com/rwcarlsen/goexif/tiff/tiff.go   |  153 ++
 .../github.com/rwcarlsen/goexif/tiff/tiff_test.go  |  235 ++
 42 files changed, 7097 insertions(+)
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/Makefile
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/affine.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/Makefile
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/Makefile
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/doc.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/Makefile
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/graphicstest.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/Makefile
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/doc.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/interp.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/shared_test.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail.go
 create mode 100644 Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail_test.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/README.md
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/example_test.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif_test.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/fields.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regen_regress.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regress_expected_test.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tag.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff.go
 create mode 100644 Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff_test.go

(limited to 'Godeps')

diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index 7a037e6ab..d6503a1d5 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -12,6 +12,11 @@
 			"Comment": "null-236",
 			"Rev": "69e2a90ed92d03812364aeb947b7068dc42e561e"
 		},
+		{
+			"ImportPath": "code.google.com/p/graphics-go/graphics",
+			"Comment": "null-25",
+			"Rev": "f843bfcd8ac420072c7f6804599995b0a229070b"
+		},
 		{
 			"ImportPath": "code.google.com/p/log4go",
 			"Comment": "go.weekly.2012-02-22-1",
@@ -87,6 +92,14 @@
 			"ImportPath": "github.com/nfnt/resize",
 			"Rev": "dc93e1b98c579d90ee2fa15c1fd6dac34f6e7899"
 		},
+		{
+			"ImportPath": "github.com/rwcarlsen/goexif/exif",
+			"Rev": "709fab3d192d7c62f86043caff1e7e3fb0f42bd8"
+		},
+		{
+			"ImportPath": "github.com/rwcarlsen/goexif/tiff",
+			"Rev": "709fab3d192d7c62f86043caff1e7e3fb0f42bd8"
+		},
 		{
 			"ImportPath": "github.com/stretchr/objx",
 			"Rev": "cbeaeb16a013161a98496fad62933b1d21786672"
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/Makefile b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/Makefile
new file mode 100644
index 000000000..28a06f0e8
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/Makefile
@@ -0,0 +1,15 @@
+# Copyright 2011 The Graphics-Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.inc
+
+TARG=code.google.com/p/graphics-go/graphics
+GOFILES=\
+	affine.go\
+	blur.go\
+	rotate.go\
+	scale.go\
+	thumbnail.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/affine.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/affine.go
new file mode 100644
index 000000000..0ac2ec9da
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/affine.go
@@ -0,0 +1,174 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/interp"
+	"errors"
+	"image"
+	"image/draw"
+	"math"
+)
+
+// I is the identity Affine transform matrix.
+var I = Affine{
+	1, 0, 0,
+	0, 1, 0,
+	0, 0, 1,
+}
+
+// Affine is a 3x3 2D affine transform matrix.
+// M(i,j) is Affine[i*3+j].
+type Affine [9]float64
+
+// Mul returns the multiplication of two affine transform matrices.
+func (a Affine) Mul(b Affine) Affine {
+	return Affine{
+		a[0]*b[0] + a[1]*b[3] + a[2]*b[6],
+		a[0]*b[1] + a[1]*b[4] + a[2]*b[7],
+		a[0]*b[2] + a[1]*b[5] + a[2]*b[8],
+		a[3]*b[0] + a[4]*b[3] + a[5]*b[6],
+		a[3]*b[1] + a[4]*b[4] + a[5]*b[7],
+		a[3]*b[2] + a[4]*b[5] + a[5]*b[8],
+		a[6]*b[0] + a[7]*b[3] + a[8]*b[6],
+		a[6]*b[1] + a[7]*b[4] + a[8]*b[7],
+		a[6]*b[2] + a[7]*b[5] + a[8]*b[8],
+	}
+}
+
+func (a Affine) transformRGBA(dst *image.RGBA, src *image.RGBA, i interp.RGBA) error {
+	srcb := src.Bounds()
+	b := dst.Bounds()
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			sx, sy := a.pt(x, y)
+			if inBounds(srcb, sx, sy) {
+				c := i.RGBA(src, sx, sy)
+				off := (y-dst.Rect.Min.Y)*dst.Stride + (x-dst.Rect.Min.X)*4
+				dst.Pix[off+0] = c.R
+				dst.Pix[off+1] = c.G
+				dst.Pix[off+2] = c.B
+				dst.Pix[off+3] = c.A
+			}
+		}
+	}
+	return nil
+}
+
+// Transform applies the affine transform to src and produces dst.
+func (a Affine) Transform(dst draw.Image, src image.Image, i interp.Interp) error {
+	if dst == nil {
+		return errors.New("graphics: dst is nil")
+	}
+	if src == nil {
+		return errors.New("graphics: src is nil")
+	}
+
+	// RGBA fast path.
+	dstRGBA, dstOk := dst.(*image.RGBA)
+	srcRGBA, srcOk := src.(*image.RGBA)
+	interpRGBA, interpOk := i.(interp.RGBA)
+	if dstOk && srcOk && interpOk {
+		return a.transformRGBA(dstRGBA, srcRGBA, interpRGBA)
+	}
+
+	srcb := src.Bounds()
+	b := dst.Bounds()
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			sx, sy := a.pt(x, y)
+			if inBounds(srcb, sx, sy) {
+				dst.Set(x, y, i.Interp(src, sx, sy))
+			}
+		}
+	}
+	return nil
+}
+
+func inBounds(b image.Rectangle, x, y float64) bool {
+	if x < float64(b.Min.X) || x >= float64(b.Max.X) {
+		return false
+	}
+	if y < float64(b.Min.Y) || y >= float64(b.Max.Y) {
+		return false
+	}
+	return true
+}
+
+func (a Affine) pt(x0, y0 int) (x1, y1 float64) {
+	fx := float64(x0) + 0.5
+	fy := float64(y0) + 0.5
+	x1 = fx*a[0] + fy*a[1] + a[2]
+	y1 = fx*a[3] + fy*a[4] + a[5]
+	return x1, y1
+}
+
+// TransformCenter applies the affine transform to src and produces dst.
+// Equivalent to
+//   a.CenterFit(dst, src).Transform(dst, src, i).
+func (a Affine) TransformCenter(dst draw.Image, src image.Image, i interp.Interp) error {
+	if dst == nil {
+		return errors.New("graphics: dst is nil")
+	}
+	if src == nil {
+		return errors.New("graphics: src is nil")
+	}
+
+	return a.CenterFit(dst.Bounds(), src.Bounds()).Transform(dst, src, i)
+}
+
+// Scale produces a scaling transform of factors x and y.
+func (a Affine) Scale(x, y float64) Affine {
+	return a.Mul(Affine{
+		1 / x, 0, 0,
+		0, 1 / y, 0,
+		0, 0, 1,
+	})
+}
+
+// Rotate produces a clockwise rotation transform of angle, in radians.
+func (a Affine) Rotate(angle float64) Affine {
+	s, c := math.Sincos(angle)
+	return a.Mul(Affine{
+		+c, +s, +0,
+		-s, +c, +0,
+		+0, +0, +1,
+	})
+}
+
+// Shear produces a shear transform by the slopes x and y.
+func (a Affine) Shear(x, y float64) Affine {
+	d := 1 - x*y
+	return a.Mul(Affine{
+		+1 / d, -x / d, 0,
+		-y / d, +1 / d, 0,
+		0, 0, 1,
+	})
+}
+
+// Translate produces a translation transform with pixel distances x and y.
+func (a Affine) Translate(x, y float64) Affine {
+	return a.Mul(Affine{
+		1, 0, -x,
+		0, 1, -y,
+		0, 0, +1,
+	})
+}
+
+// Center produces the affine transform, centered around the provided point.
+func (a Affine) Center(x, y float64) Affine {
+	return I.Translate(-x, -y).Mul(a).Translate(x, y)
+}
+
+// CenterFit produces the affine transform, centered around the rectangles.
+// It is equivalent to
+//   I.Translate(-<center of src>).Mul(a).Translate(<center of dst>)
+func (a Affine) CenterFit(dst, src image.Rectangle) Affine {
+	dx := float64(dst.Min.X) + float64(dst.Dx())/2
+	dy := float64(dst.Min.Y) + float64(dst.Dy())/2
+	sx := float64(src.Min.X) + float64(src.Dx())/2
+	sy := float64(src.Min.Y) + float64(src.Dy())/2
+	return I.Translate(-sx, -sy).Mul(a).Translate(dx, dy)
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur.go
new file mode 100644
index 000000000..9a54d5ad5
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur.go
@@ -0,0 +1,68 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/convolve"
+	"errors"
+	"image"
+	"image/draw"
+	"math"
+)
+
+// DefaultStdDev is the default blurring parameter.
+var DefaultStdDev = 0.5
+
+// BlurOptions are the blurring parameters.
+// StdDev is the standard deviation of the normal, higher is blurrier.
+// Size is the size of the kernel. If zero, it is set to Ceil(6 * StdDev).
+type BlurOptions struct {
+	StdDev float64
+	Size   int
+}
+
+// Blur produces a blurred version of the image, using a Gaussian blur.
+func Blur(dst draw.Image, src image.Image, opt *BlurOptions) error {
+	if dst == nil {
+		return errors.New("graphics: dst is nil")
+	}
+	if src == nil {
+		return errors.New("graphics: src is nil")
+	}
+
+	sd := DefaultStdDev
+	size := 0
+
+	if opt != nil {
+		sd = opt.StdDev
+		size = opt.Size
+	}
+
+	if size < 1 {
+		size = int(math.Ceil(sd * 6))
+	}
+
+	kernel := make([]float64, 2*size+1)
+	for i := 0; i <= size; i++ {
+		x := float64(i) / sd
+		x = math.Pow(1/math.SqrtE, x*x)
+		kernel[size-i] = x
+		kernel[size+i] = x
+	}
+
+	// Normalize the weights to sum to 1.0.
+	kSum := 0.0
+	for _, k := range kernel {
+		kSum += k
+	}
+	for i, k := range kernel {
+		kernel[i] = k / kSum
+	}
+
+	return convolve.Convolve(dst, src, &convolve.SeparableKernel{
+		X: kernel,
+		Y: kernel,
+	})
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur_test.go
new file mode 100644
index 000000000..1d84fa604
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/blur_test.go
@@ -0,0 +1,207 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/graphicstest"
+	"image"
+	"image/color"
+	"testing"
+
+	_ "image/png"
+)
+
+var blurOneColorTests = []transformOneColorTest{
+	{
+		"1x1-blank", 1, 1, 1, 1,
+		&BlurOptions{0.83, 1},
+		[]uint8{0xff},
+		[]uint8{0xff},
+	},
+	{
+		"1x1-spreadblank", 1, 1, 1, 1,
+		&BlurOptions{0.83, 2},
+		[]uint8{0xff},
+		[]uint8{0xff},
+	},
+	{
+		"3x3-blank", 3, 3, 3, 3,
+		&BlurOptions{0.83, 2},
+		[]uint8{
+			0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff,
+		},
+		[]uint8{
+			0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff,
+		},
+	},
+	{
+		"3x3-dot", 3, 3, 3, 3,
+		&BlurOptions{0.34, 1},
+		[]uint8{
+			0x00, 0x00, 0x00,
+			0x00, 0xff, 0x00,
+			0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0x03, 0x00,
+			0x03, 0xf2, 0x03,
+			0x00, 0x03, 0x00,
+		},
+	},
+	{
+		"5x5-dot", 5, 5, 5, 5,
+		&BlurOptions{0.34, 1},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0xff, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x03, 0x00, 0x00,
+			0x00, 0x03, 0xf2, 0x03, 0x00,
+			0x00, 0x00, 0x03, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+	},
+	{
+		"5x5-dot-spread", 5, 5, 5, 5,
+		&BlurOptions{0.85, 1},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0xff, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x10, 0x20, 0x10, 0x00,
+			0x00, 0x20, 0x40, 0x20, 0x00,
+			0x00, 0x10, 0x20, 0x10, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+	},
+	{
+		"4x4-box", 4, 4, 4, 4,
+		&BlurOptions{0.34, 1},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00,
+			0x00, 0xff, 0xff, 0x00,
+			0x00, 0xff, 0xff, 0x00,
+			0x00, 0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0x03, 0x03, 0x00,
+			0x03, 0xf8, 0xf8, 0x03,
+			0x03, 0xf8, 0xf8, 0x03,
+			0x00, 0x03, 0x03, 0x00,
+		},
+	},
+	{
+		"5x5-twodots", 5, 5, 5, 5,
+		&BlurOptions{0.34, 1},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x96, 0x00, 0x96, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x02, 0x00, 0x02, 0x00,
+			0x02, 0x8e, 0x04, 0x8e, 0x02,
+			0x00, 0x02, 0x00, 0x02, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+	},
+}
+
+func TestBlurOneColor(t *testing.T) {
+	for _, oc := range blurOneColorTests {
+		dst := oc.newDst()
+		src := oc.newSrc()
+		opt := oc.opt.(*BlurOptions)
+		if err := Blur(dst, src, opt); err != nil {
+			t.Fatal(err)
+		}
+
+		if !checkTransformTest(t, &oc, dst) {
+			continue
+		}
+	}
+}
+
+func TestBlurEmpty(t *testing.T) {
+	empty := image.NewRGBA(image.Rect(0, 0, 0, 0))
+	if err := Blur(empty, empty, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestBlurGopher(t *testing.T) {
+	src, err := graphicstest.LoadImage("../testdata/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dst := image.NewRGBA(src.Bounds())
+	if err = Blur(dst, src, &BlurOptions{StdDev: 1.1}); err != nil {
+		t.Fatal(err)
+	}
+
+	cmp, err := graphicstest.LoadImage("../testdata/gopher-blur.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0x101)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func benchBlur(b *testing.B, bounds image.Rectangle) {
+	b.StopTimer()
+
+	// Construct a fuzzy image.
+	src := image.NewRGBA(bounds)
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			src.SetRGBA(x, y, color.RGBA{
+				uint8(5 * x % 0x100),
+				uint8(7 * y % 0x100),
+				uint8((7*x + 5*y) % 0x100),
+				0xff,
+			})
+		}
+	}
+	dst := image.NewRGBA(bounds)
+
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		Blur(dst, src, &BlurOptions{0.84, 3})
+	}
+}
+
+func BenchmarkBlur400x400x3(b *testing.B) {
+	benchBlur(b, image.Rect(0, 0, 400, 400))
+}
+
+// Exactly twice the pixel count of 400x400.
+func BenchmarkBlur400x800x3(b *testing.B) {
+	benchBlur(b, image.Rect(0, 0, 400, 800))
+}
+
+// Exactly twice the pixel count of 400x800
+func BenchmarkBlur400x1600x3(b *testing.B) {
+	benchBlur(b, image.Rect(0, 0, 400, 1600))
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/Makefile b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/Makefile
new file mode 100644
index 000000000..a5691fa30
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/Makefile
@@ -0,0 +1,11 @@
+# Copyright 2011 The Graphics-Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.inc
+
+TARG=code.google.com/p/graphics-go/graphics/convolve
+GOFILES=\
+	convolve.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve.go
new file mode 100644
index 000000000..da69496d0
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve.go
@@ -0,0 +1,274 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package convolve
+
+import (
+	"errors"
+	"fmt"
+	"image"
+	"image/draw"
+	"math"
+)
+
+// clamp clamps x to the range [x0, x1].
+func clamp(x, x0, x1 float64) float64 {
+	if x < x0 {
+		return x0
+	}
+	if x > x1 {
+		return x1
+	}
+	return x
+}
+
+// Kernel is a square matrix that defines a convolution.
+type Kernel interface {
+	// Weights returns the square matrix of weights in row major order.
+	Weights() []float64
+}
+
+// SeparableKernel is a linearly separable, square convolution kernel.
+// X and Y are the per-axis weights. Each slice must be the same length, and
+// have an odd length. The middle element of each slice is the weight for the
+// central pixel. For example, the horizontal Sobel kernel is:
+//	sobelX := &SeparableKernel{
+//		X: []float64{-1, 0, +1},
+//		Y: []float64{1, 2, 1},
+//	}
+type SeparableKernel struct {
+	X, Y []float64
+}
+
+func (k *SeparableKernel) Weights() []float64 {
+	n := len(k.X)
+	w := make([]float64, n*n)
+	for y := 0; y < n; y++ {
+		for x := 0; x < n; x++ {
+			w[y*n+x] = k.X[x] * k.Y[y]
+		}
+	}
+	return w
+}
+
+// fullKernel is a square convolution kernel.
+type fullKernel []float64
+
+func (k fullKernel) Weights() []float64 { return k }
+
+func kernelSize(w []float64) (size int, err error) {
+	size = int(math.Sqrt(float64(len(w))))
+	if size*size != len(w) {
+		return 0, errors.New("graphics: kernel is not square")
+	}
+	if size%2 != 1 {
+		return 0, errors.New("graphics: kernel size is not odd")
+	}
+	return size, nil
+}
+
+// NewKernel returns a square convolution kernel.
+func NewKernel(w []float64) (Kernel, error) {
+	if _, err := kernelSize(w); err != nil {
+		return nil, err
+	}
+	return fullKernel(w), nil
+}
+
+func convolveRGBASep(dst *image.RGBA, src image.Image, k *SeparableKernel) error {
+	if len(k.X) != len(k.Y) {
+		return fmt.Errorf("graphics: kernel not square (x %d, y %d)", len(k.X), len(k.Y))
+	}
+	if len(k.X)%2 != 1 {
+		return fmt.Errorf("graphics: kernel length (%d) not odd", len(k.X))
+	}
+	radius := (len(k.X) - 1) / 2
+
+	// buf holds the result of vertically blurring src.
+	bounds := dst.Bounds()
+	width, height := bounds.Dx(), bounds.Dy()
+	buf := make([]float64, width*height*4)
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			var r, g, b, a float64
+			// k0 is the kernel weight for the center pixel. This may be greater
+			// than kernel[0], near the boundary of the source image, to avoid
+			// vignetting.
+			k0 := k.X[radius]
+
+			// Add the pixels from above.
+			for i := 1; i <= radius; i++ {
+				f := k.Y[radius-i]
+				if y-i < bounds.Min.Y {
+					k0 += f
+				} else {
+					or, og, ob, oa := src.At(x, y-i).RGBA()
+					r += float64(or>>8) * f
+					g += float64(og>>8) * f
+					b += float64(ob>>8) * f
+					a += float64(oa>>8) * f
+				}
+			}
+
+			// Add the pixels from below.
+			for i := 1; i <= radius; i++ {
+				f := k.Y[radius+i]
+				if y+i >= bounds.Max.Y {
+					k0 += f
+				} else {
+					or, og, ob, oa := src.At(x, y+i).RGBA()
+					r += float64(or>>8) * f
+					g += float64(og>>8) * f
+					b += float64(ob>>8) * f
+					a += float64(oa>>8) * f
+				}
+			}
+
+			// Add the central pixel.
+			or, og, ob, oa := src.At(x, y).RGBA()
+			r += float64(or>>8) * k0
+			g += float64(og>>8) * k0
+			b += float64(ob>>8) * k0
+			a += float64(oa>>8) * k0
+
+			// Write to buf.
+			o := (y-bounds.Min.Y)*width*4 + (x-bounds.Min.X)*4
+			buf[o+0] = r
+			buf[o+1] = g
+			buf[o+2] = b
+			buf[o+3] = a
+		}
+	}
+
+	// dst holds the result of horizontally blurring buf.
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			var r, g, b, a float64
+			k0, off := k.X[radius], y*width*4+x*4
+
+			// Add the pixels from the left.
+			for i := 1; i <= radius; i++ {
+				f := k.X[radius-i]
+				if x-i < 0 {
+					k0 += f
+				} else {
+					o := off - i*4
+					r += buf[o+0] * f
+					g += buf[o+1] * f
+					b += buf[o+2] * f
+					a += buf[o+3] * f
+				}
+			}
+
+			// Add the pixels from the right.
+			for i := 1; i <= radius; i++ {
+				f := k.X[radius+i]
+				if x+i >= width {
+					k0 += f
+				} else {
+					o := off + i*4
+					r += buf[o+0] * f
+					g += buf[o+1] * f
+					b += buf[o+2] * f
+					a += buf[o+3] * f
+				}
+			}
+
+			// Add the central pixel.
+			r += buf[off+0] * k0
+			g += buf[off+1] * k0
+			b += buf[off+2] * k0
+			a += buf[off+3] * k0
+
+			// Write to dst, clamping to the range [0, 255].
+			dstOff := (y-dst.Rect.Min.Y)*dst.Stride + (x-dst.Rect.Min.X)*4
+			dst.Pix[dstOff+0] = uint8(clamp(r+0.5, 0, 255))
+			dst.Pix[dstOff+1] = uint8(clamp(g+0.5, 0, 255))
+			dst.Pix[dstOff+2] = uint8(clamp(b+0.5, 0, 255))
+			dst.Pix[dstOff+3] = uint8(clamp(a+0.5, 0, 255))
+		}
+	}
+
+	return nil
+}
+
+func convolveRGBA(dst *image.RGBA, src image.Image, k Kernel) error {
+	b := dst.Bounds()
+	bs := src.Bounds()
+	w := k.Weights()
+	size, err := kernelSize(w)
+	if err != nil {
+		return err
+	}
+	radius := (size - 1) / 2
+
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			if !image.Pt(x, y).In(bs) {
+				continue
+			}
+
+			var r, g, b, a, adj float64
+			for cy := y - radius; cy <= y+radius; cy++ {
+				for cx := x - radius; cx <= x+radius; cx++ {
+					factor := w[(cy-y+radius)*size+cx-x+radius]
+					if !image.Pt(cx, cy).In(bs) {
+						adj += factor
+					} else {
+						sr, sg, sb, sa := src.At(cx, cy).RGBA()
+						r += float64(sr>>8) * factor
+						g += float64(sg>>8) * factor
+						b += float64(sb>>8) * factor
+						a += float64(sa>>8) * factor
+					}
+				}
+			}
+
+			if adj != 0 {
+				sr, sg, sb, sa := src.At(x, y).RGBA()
+				r += float64(sr>>8) * adj
+				g += float64(sg>>8) * adj
+				b += float64(sb>>8) * adj
+				a += float64(sa>>8) * adj
+			}
+
+			off := (y-dst.Rect.Min.Y)*dst.Stride + (x-dst.Rect.Min.X)*4
+			dst.Pix[off+0] = uint8(clamp(r+0.5, 0, 0xff))
+			dst.Pix[off+1] = uint8(clamp(g+0.5, 0, 0xff))
+			dst.Pix[off+2] = uint8(clamp(b+0.5, 0, 0xff))
+			dst.Pix[off+3] = uint8(clamp(a+0.5, 0, 0xff))
+		}
+	}
+
+	return nil
+}
+
+// Convolve produces dst by applying the convolution kernel k to src.
+func Convolve(dst draw.Image, src image.Image, k Kernel) (err error) {
+	if dst == nil || src == nil || k == nil {
+		return nil
+	}
+
+	b := dst.Bounds()
+	dstRgba, ok := dst.(*image.RGBA)
+	if !ok {
+		dstRgba = image.NewRGBA(b)
+	}
+
+	switch k := k.(type) {
+	case *SeparableKernel:
+		err = convolveRGBASep(dstRgba, src, k)
+	default:
+		err = convolveRGBA(dstRgba, src, k)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if !ok {
+		draw.Draw(dst, b, dstRgba, b.Min, draw.Src)
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve_test.go
new file mode 100644
index 000000000..f34d7afc8
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/convolve/convolve_test.go
@@ -0,0 +1,78 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package convolve
+
+import (
+	"code.google.com/p/graphics-go/graphics/graphicstest"
+	"image"
+	"reflect"
+	"testing"
+
+	_ "image/png"
+)
+
+func TestSeparableWeights(t *testing.T) {
+	sobelXFull := []float64{
+		-1, 0, 1,
+		-2, 0, 2,
+		-1, 0, 1,
+	}
+	sobelXSep := &SeparableKernel{
+		X: []float64{-1, 0, +1},
+		Y: []float64{1, 2, 1},
+	}
+	w := sobelXSep.Weights()
+	if !reflect.DeepEqual(w, sobelXFull) {
+		t.Errorf("got %v want %v", w, sobelXFull)
+	}
+}
+
+func TestConvolve(t *testing.T) {
+	kernFull, err := NewKernel([]float64{
+		0, 0, 0,
+		1, 1, 1,
+		0, 0, 0,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	kernSep := &SeparableKernel{
+		X: []float64{1, 1, 1},
+		Y: []float64{0, 1, 0},
+	}
+
+	src, err := graphicstest.LoadImage("../../testdata/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b := src.Bounds()
+
+	sep := image.NewRGBA(b)
+	if err = Convolve(sep, src, kernSep); err != nil {
+		t.Fatal(err)
+	}
+
+	full := image.NewRGBA(b)
+	Convolve(full, src, kernFull)
+
+	err = graphicstest.ImageWithinTolerance(sep, full, 0x101)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestConvolveNil(t *testing.T) {
+	if err := Convolve(nil, nil, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestConvolveEmpty(t *testing.T) {
+	empty := image.NewRGBA(image.Rect(0, 0, 0, 0))
+	if err := Convolve(empty, empty, nil); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/Makefile b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/Makefile
new file mode 100644
index 000000000..0b1c6cb3e
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/Makefile
@@ -0,0 +1,15 @@
+# Copyright 2011 The Graphics-Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.inc
+
+TARG=code.google.com/p/graphics-go/graphics
+GOFILES=\
+	detect.go\
+	doc.go\
+	integral.go\
+	opencv_parser.go\
+	projector.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect.go
new file mode 100644
index 000000000..dde941cbe
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect.go
@@ -0,0 +1,133 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"image"
+	"math"
+)
+
+// Feature is a Haar-like feature.
+type Feature struct {
+	Rect   image.Rectangle
+	Weight float64
+}
+
+// Classifier is a set of features with a threshold.
+type Classifier struct {
+	Feature   []Feature
+	Threshold float64
+	Left      float64
+	Right     float64
+}
+
+// CascadeStage is a cascade of classifiers.
+type CascadeStage struct {
+	Classifier []Classifier
+	Threshold  float64
+}
+
+// Cascade is a degenerate tree of Haar-like classifiers.
+type Cascade struct {
+	Stage []CascadeStage
+	Size  image.Point
+}
+
+// Match returns true if the full image is classified as an object.
+func (c *Cascade) Match(m image.Image) bool {
+	return c.classify(newWindow(m))
+}
+
+// Find returns a set of areas of m that match the feature cascade c.
+func (c *Cascade) Find(m image.Image) []image.Rectangle {
+	// TODO(crawshaw): Consider de-duping strategies.
+	matches := []image.Rectangle{}
+	w := newWindow(m)
+
+	b := m.Bounds()
+	origScale := c.Size
+	for s := origScale; s.X < b.Dx() && s.Y < b.Dy(); s = s.Add(s.Div(10)) {
+		// translate region and classify
+		tx := image.Pt(s.X/10, 0)
+		ty := image.Pt(0, s.Y/10)
+		for r := image.Rect(0, 0, s.X, s.Y).Add(b.Min); r.In(b); r = r.Add(ty) {
+			for r1 := r; r1.In(b); r1 = r1.Add(tx) {
+				if c.classify(w.subWindow(r1)) {
+					matches = append(matches, r1)
+				}
+			}
+		}
+	}
+	return matches
+}
+
+type window struct {
+	mi      *integral
+	miSq    *integral
+	rect    image.Rectangle
+	invArea float64
+	stdDev  float64
+}
+
+func (w *window) init() {
+	w.invArea = 1 / float64(w.rect.Dx()*w.rect.Dy())
+	mean := float64(w.mi.sum(w.rect)) * w.invArea
+	vr := float64(w.miSq.sum(w.rect))*w.invArea - mean*mean
+	if vr < 0 {
+		vr = 1
+	}
+	w.stdDev = math.Sqrt(vr)
+}
+
+func newWindow(m image.Image) *window {
+	mi, miSq := newIntegrals(m)
+	res := &window{
+		mi:   mi,
+		miSq: miSq,
+		rect: m.Bounds(),
+	}
+	res.init()
+	return res
+}
+
+func (w *window) subWindow(r image.Rectangle) *window {
+	res := &window{
+		mi:   w.mi,
+		miSq: w.miSq,
+		rect: r,
+	}
+	res.init()
+	return res
+}
+
+func (c *Classifier) classify(w *window, pr *projector) float64 {
+	s := 0.0
+	for _, f := range c.Feature {
+		s += float64(w.mi.sum(pr.rect(f.Rect))) * f.Weight
+	}
+	s *= w.invArea // normalize to maintain scale invariance
+	if s < c.Threshold*w.stdDev {
+		return c.Left
+	}
+	return c.Right
+}
+
+func (s *CascadeStage) classify(w *window, pr *projector) bool {
+	sum := 0.0
+	for _, c := range s.Classifier {
+		sum += c.classify(w, pr)
+	}
+	return sum >= s.Threshold
+}
+
+func (c *Cascade) classify(w *window) bool {
+	pr := newProjector(w.rect, image.Rectangle{image.Pt(0, 0), c.Size})
+	for _, s := range c.Stage {
+		if !s.classify(w, pr) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect_test.go
new file mode 100644
index 000000000..8a2df113d
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/detect_test.go
@@ -0,0 +1,77 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"image"
+	"image/draw"
+	"testing"
+)
+
+var (
+	c0 = Classifier{
+		Feature: []Feature{
+			Feature{Rect: image.Rect(0, 0, 3, 4), Weight: 4.0},
+		},
+		Threshold: 0.2,
+		Left:      0.8,
+		Right:     0.2,
+	}
+	c1 = Classifier{
+		Feature: []Feature{
+			Feature{Rect: image.Rect(3, 4, 4, 5), Weight: 4.0},
+		},
+		Threshold: 0.2,
+		Left:      0.8,
+		Right:     0.2,
+	}
+	c2 = Classifier{
+		Feature: []Feature{
+			Feature{Rect: image.Rect(0, 0, 1, 1), Weight: +4.0},
+			Feature{Rect: image.Rect(0, 0, 2, 2), Weight: -1.0},
+		},
+		Threshold: 0.2,
+		Left:      0.8,
+		Right:     0.2,
+	}
+)
+
+func TestClassifier(t *testing.T) {
+	m := image.NewGray(image.Rect(0, 0, 20, 20))
+	b := m.Bounds()
+	draw.Draw(m, image.Rect(0, 0, 20, 20), image.White, image.ZP, draw.Src)
+	draw.Draw(m, image.Rect(3, 4, 4, 5), image.Black, image.ZP, draw.Src)
+	w := newWindow(m)
+	pr := newProjector(b, b)
+
+	if res := c0.classify(w, pr); res != c0.Right {
+		t.Errorf("c0 got %f want %f", res, c0.Right)
+	}
+	if res := c1.classify(w, pr); res != c1.Left {
+		t.Errorf("c1 got %f want %f", res, c1.Left)
+	}
+	if res := c2.classify(w, pr); res != c1.Left {
+		t.Errorf("c2 got %f want %f", res, c1.Left)
+	}
+}
+
+func TestClassifierScale(t *testing.T) {
+	m := image.NewGray(image.Rect(0, 0, 50, 50))
+	b := m.Bounds()
+	draw.Draw(m, image.Rect(0, 0, 8, 10), image.White, b.Min, draw.Src)
+	draw.Draw(m, image.Rect(8, 10, 10, 13), image.Black, b.Min, draw.Src)
+	w := newWindow(m)
+	pr := newProjector(b, image.Rect(0, 0, 20, 20))
+
+	if res := c0.classify(w, pr); res != c0.Right {
+		t.Errorf("scaled c0 got %f want %f", res, c0.Right)
+	}
+	if res := c1.classify(w, pr); res != c1.Left {
+		t.Errorf("scaled c1 got %f want %f", res, c1.Left)
+	}
+	if res := c2.classify(w, pr); res != c1.Left {
+		t.Errorf("scaled c2 got %f want %f", res, c1.Left)
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/doc.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/doc.go
new file mode 100644
index 000000000..a0f4e94cd
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/doc.go
@@ -0,0 +1,31 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package detect implements an object detector cascade.
+
+The technique used is a degenerate tree of Haar-like classifiers, commonly
+used for face detection. It is described in
+
+	P. Viola, M. Jones.
+	Rapid Object Detection using a Boosted Cascade of Simple Features, 2001
+	IEEE Conference on Computer Vision and Pattern Recognition
+
+A Cascade can be constructed manually from a set of Classifiers in stages,
+or can be loaded from an XML file in the OpenCV format with
+
+	classifier, _, err := detect.ParseOpenCV(r)
+
+The classifier can be used to determine if a full image is detected as an
+object using Detect
+
+	if classifier.Match(m) {
+		// m is an image of a face.
+	}
+
+It is also possible to search an image for occurrences of an object
+
+	objs := classifier.Find(m)
+*/
+package detect
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral.go
new file mode 100644
index 000000000..814ced590
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral.go
@@ -0,0 +1,93 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"image"
+	"image/draw"
+)
+
+// integral is an image.Image-like structure that stores the cumulative
+// sum of the preceding pixels. This allows for O(1) summation of any
+// rectangular region within the image.
+type integral struct {
+	// pix holds the cumulative sum of the image's pixels. The pixel at
+	// (x, y) starts at pix[(y-rect.Min.Y)*stride + (x-rect.Min.X)*1].
+	pix    []uint64
+	stride int
+	rect   image.Rectangle
+}
+
+func (p *integral) at(x, y int) uint64 {
+	return p.pix[(y-p.rect.Min.Y)*p.stride+(x-p.rect.Min.X)]
+}
+
+func (p *integral) sum(b image.Rectangle) uint64 {
+	c := p.at(b.Max.X-1, b.Max.Y-1)
+	inY := b.Min.Y > p.rect.Min.Y
+	inX := b.Min.X > p.rect.Min.X
+	if inY && inX {
+		c += p.at(b.Min.X-1, b.Min.Y-1)
+	}
+	if inY {
+		c -= p.at(b.Max.X-1, b.Min.Y-1)
+	}
+	if inX {
+		c -= p.at(b.Min.X-1, b.Max.Y-1)
+	}
+	return c
+}
+
+func (m *integral) integrate() {
+	b := m.rect
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			c := uint64(0)
+			if y > b.Min.Y && x > b.Min.X {
+				c += m.at(x-1, y)
+				c += m.at(x, y-1)
+				c -= m.at(x-1, y-1)
+			} else if y > b.Min.Y {
+				c += m.at(b.Min.X, y-1)
+			} else if x > b.Min.X {
+				c += m.at(x-1, b.Min.Y)
+			}
+			m.pix[(y-m.rect.Min.Y)*m.stride+(x-m.rect.Min.X)] += c
+		}
+	}
+}
+
+// newIntegrals returns the integral and the squared integral.
+func newIntegrals(src image.Image) (*integral, *integral) {
+	b := src.Bounds()
+	srcg, ok := src.(*image.Gray)
+	if !ok {
+		srcg = image.NewGray(b)
+		draw.Draw(srcg, b, src, b.Min, draw.Src)
+	}
+
+	m := integral{
+		pix:    make([]uint64, b.Max.Y*b.Max.X),
+		stride: b.Max.X,
+		rect:   b,
+	}
+	mSq := integral{
+		pix:    make([]uint64, b.Max.Y*b.Max.X),
+		stride: b.Max.X,
+		rect:   b,
+	}
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			os := (y-b.Min.Y)*srcg.Stride + x - b.Min.X
+			om := (y-b.Min.Y)*m.stride + x - b.Min.X
+			c := uint64(srcg.Pix[os])
+			m.pix[om] = c
+			mSq.pix[om] = c * c
+		}
+	}
+	m.integrate()
+	mSq.integrate()
+	return &m, &mSq
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral_test.go
new file mode 100644
index 000000000..0bc321a4d
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/integral_test.go
@@ -0,0 +1,156 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"testing"
+)
+
+type integralTest struct {
+	x   int
+	y   int
+	src []uint8
+	res []uint8
+}
+
+var integralTests = []integralTest{
+	{
+		1, 1,
+		[]uint8{0x01},
+		[]uint8{0x01},
+	},
+	{
+		2, 2,
+		[]uint8{
+			0x01, 0x02,
+			0x03, 0x04,
+		},
+		[]uint8{
+			0x01, 0x03,
+			0x04, 0x0a,
+		},
+	},
+	{
+		4, 4,
+		[]uint8{
+			0x02, 0x03, 0x00, 0x01,
+			0x01, 0x02, 0x01, 0x05,
+			0x01, 0x01, 0x01, 0x01,
+			0x01, 0x01, 0x01, 0x01,
+		},
+		[]uint8{
+			0x02, 0x05, 0x05, 0x06,
+			0x03, 0x08, 0x09, 0x0f,
+			0x04, 0x0a, 0x0c, 0x13,
+			0x05, 0x0c, 0x0f, 0x17,
+		},
+	},
+}
+
+func sprintBox(box []byte, width, height int) string {
+	buf := bytes.NewBuffer(nil)
+	i := 0
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			fmt.Fprintf(buf, " 0x%02x,", box[i])
+			i++
+		}
+		buf.WriteByte('\n')
+	}
+	return buf.String()
+}
+
+func TestIntegral(t *testing.T) {
+	for i, oc := range integralTests {
+		src := &image.Gray{
+			Pix:    oc.src,
+			Stride: oc.x,
+			Rect:   image.Rect(0, 0, oc.x, oc.y),
+		}
+		dst, _ := newIntegrals(src)
+		res := make([]byte, len(dst.pix))
+		for i, p := range dst.pix {
+			res[i] = byte(p)
+		}
+
+		if !bytes.Equal(res, oc.res) {
+			got := sprintBox(res, oc.x, oc.y)
+			want := sprintBox(oc.res, oc.x, oc.y)
+			t.Errorf("%d: got\n%s\n want\n%s", i, got, want)
+		}
+	}
+}
+
+func TestIntegralSum(t *testing.T) {
+	src := &image.Gray{
+		Pix: []uint8{
+			0x02, 0x03, 0x00, 0x01, 0x03,
+			0x01, 0x02, 0x01, 0x05, 0x05,
+			0x01, 0x01, 0x01, 0x01, 0x02,
+			0x01, 0x01, 0x01, 0x01, 0x07,
+			0x02, 0x01, 0x00, 0x03, 0x01,
+		},
+		Stride: 5,
+		Rect:   image.Rect(0, 0, 5, 5),
+	}
+	img, _ := newIntegrals(src)
+
+	type sumTest struct {
+		rect image.Rectangle
+		sum  uint64
+	}
+
+	var sumTests = []sumTest{
+		{image.Rect(0, 0, 1, 1), 2},
+		{image.Rect(0, 0, 2, 1), 5},
+		{image.Rect(0, 0, 1, 3), 4},
+		{image.Rect(1, 1, 3, 3), 5},
+		{image.Rect(2, 2, 4, 4), 4},
+		{image.Rect(4, 3, 5, 5), 8},
+		{image.Rect(2, 4, 3, 5), 0},
+	}
+
+	for _, st := range sumTests {
+		s := img.sum(st.rect)
+		if s != st.sum {
+			t.Errorf("%v: got %d want %d", st.rect, s, st.sum)
+			return
+		}
+	}
+}
+
+func TestIntegralSubImage(t *testing.T) {
+	m0 := &image.Gray{
+		Pix: []uint8{
+			0x02, 0x03, 0x00, 0x01, 0x03,
+			0x01, 0x02, 0x01, 0x05, 0x05,
+			0x01, 0x04, 0x01, 0x01, 0x02,
+			0x01, 0x02, 0x01, 0x01, 0x07,
+			0x02, 0x01, 0x09, 0x03, 0x01,
+		},
+		Stride: 5,
+		Rect:   image.Rect(0, 0, 5, 5),
+	}
+	b := image.Rect(1, 1, 4, 4)
+	m1 := m0.SubImage(b)
+	mi0, _ := newIntegrals(m0)
+	mi1, _ := newIntegrals(m1)
+
+	sum0 := mi0.sum(b)
+	sum1 := mi1.sum(b)
+	if sum0 != sum1 {
+		t.Errorf("b got %d want %d", sum0, sum1)
+	}
+
+	r0 := image.Rect(2, 2, 4, 4)
+	sum0 = mi0.sum(r0)
+	sum1 = mi1.sum(r0)
+	if sum0 != sum1 {
+		t.Errorf("r0 got %d want %d", sum1, sum0)
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser.go
new file mode 100644
index 000000000..51ded1a1c
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser.go
@@ -0,0 +1,125 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"bytes"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"image"
+	"io"
+	"io/ioutil"
+	"strconv"
+	"strings"
+)
+
+type xmlFeature struct {
+	Rects     []string `xml:"grp>feature>rects>grp"`
+	Tilted    int      `xml:"grp>feature>tilted"`
+	Threshold float64  `xml:"grp>threshold"`
+	Left      float64  `xml:"grp>left_val"`
+	Right     float64  `xml:"grp>right_val"`
+}
+
+type xmlStages struct {
+	Trees           []xmlFeature `xml:"trees>grp"`
+	Stage_threshold float64      `xml:"stage_threshold"`
+	Parent          int          `xml:"parent"`
+	Next            int          `xml:"next"`
+}
+
+type opencv_storage struct {
+	Any struct {
+		XMLName xml.Name
+		Type    string      `xml:"type_id,attr"`
+		Size    string      `xml:"size"`
+		Stages  []xmlStages `xml:"stages>grp"`
+	} `xml:",any"`
+}
+
+func buildFeature(r string) (f Feature, err error) {
+	var x, y, w, h int
+	var weight float64
+	_, err = fmt.Sscanf(r, "%d %d %d %d %f", &x, &y, &w, &h, &weight)
+	if err != nil {
+		return
+	}
+	f.Rect = image.Rect(x, y, x+w, y+h)
+	f.Weight = weight
+	return
+}
+
+func buildCascade(s *opencv_storage) (c *Cascade, name string, err error) {
+	if s.Any.Type != "opencv-haar-classifier" {
+		err = fmt.Errorf("got %s want opencv-haar-classifier", s.Any.Type)
+		return
+	}
+	name = s.Any.XMLName.Local
+
+	c = &Cascade{}
+	sizes := strings.Split(s.Any.Size, " ")
+	w, err := strconv.Atoi(sizes[0])
+	if err != nil {
+		return nil, "", err
+	}
+	h, err := strconv.Atoi(sizes[1])
+	if err != nil {
+		return nil, "", err
+	}
+	c.Size = image.Pt(w, h)
+	c.Stage = []CascadeStage{}
+
+	for _, stage := range s.Any.Stages {
+		cs := CascadeStage{
+			Classifier: []Classifier{},
+			Threshold:  stage.Stage_threshold,
+		}
+		for _, tree := range stage.Trees {
+			if tree.Tilted != 0 {
+				err = errors.New("Cascade does not support tilted features")
+				return
+			}
+
+			cls := Classifier{
+				Feature:   []Feature{},
+				Threshold: tree.Threshold,
+				Left:      tree.Left,
+				Right:     tree.Right,
+			}
+
+			for _, rect := range tree.Rects {
+				f, err := buildFeature(rect)
+				if err != nil {
+					return nil, "", err
+				}
+				cls.Feature = append(cls.Feature, f)
+			}
+
+			cs.Classifier = append(cs.Classifier, cls)
+		}
+		c.Stage = append(c.Stage, cs)
+	}
+
+	return
+}
+
+// ParseOpenCV produces a detection Cascade from an OpenCV XML file.
+func ParseOpenCV(r io.Reader) (cascade *Cascade, name string, err error) {
+	// BUG(crawshaw): tag-based parsing doesn't seem to work with <_>
+	buf, err := ioutil.ReadAll(r)
+	if err != nil {
+		return
+	}
+	buf = bytes.Replace(buf, []byte("<_>"), []byte("<grp>"), -1)
+	buf = bytes.Replace(buf, []byte("</_>"), []byte("</grp>"), -1)
+
+	s := &opencv_storage{}
+	err = xml.Unmarshal(buf, s)
+	if err != nil {
+		return
+	}
+	return buildCascade(s)
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser_test.go
new file mode 100644
index 000000000..343390499
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/opencv_parser_test.go
@@ -0,0 +1,75 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"image"
+	"os"
+	"reflect"
+	"testing"
+)
+
+var (
+	classifier0 = Classifier{
+		Feature: []Feature{
+			Feature{Rect: image.Rect(0, 0, 3, 4), Weight: -1},
+			Feature{Rect: image.Rect(3, 4, 5, 6), Weight: 3.1},
+		},
+		Threshold: 0.03,
+		Left:      0.01,
+		Right:     0.8,
+	}
+	classifier1 = Classifier{
+		Feature: []Feature{
+			Feature{Rect: image.Rect(3, 7, 17, 11), Weight: -3.2},
+			Feature{Rect: image.Rect(3, 9, 17, 11), Weight: 2.},
+		},
+		Threshold: 0.11,
+		Left:      0.03,
+		Right:     0.83,
+	}
+	classifier2 = Classifier{
+		Feature: []Feature{
+			Feature{Rect: image.Rect(1, 1, 3, 3), Weight: -1.},
+			Feature{Rect: image.Rect(3, 3, 5, 5), Weight: 2.5},
+		},
+		Threshold: 0.07,
+		Left:      0.2,
+		Right:     0.4,
+	}
+	cascade = Cascade{
+		Stage: []CascadeStage{
+			CascadeStage{
+				Classifier: []Classifier{classifier0, classifier1},
+				Threshold:  0.82,
+			},
+			CascadeStage{
+				Classifier: []Classifier{classifier2},
+				Threshold:  0.22,
+			},
+		},
+		Size: image.Pt(20, 20),
+	}
+)
+
+func TestParseOpenCV(t *testing.T) {
+	file, err := os.Open("../../testdata/opencv.xml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+
+	cascadeFile, name, err := ParseOpenCV(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if name != "name_of_cascade" {
+		t.Fatalf("name: got %s want name_of_cascade", name)
+	}
+
+	if !reflect.DeepEqual(cascade, *cascadeFile) {
+		t.Errorf("got\n %v want\n %v", *cascadeFile, cascade)
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector.go
new file mode 100644
index 000000000..1ebd6db59
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector.go
@@ -0,0 +1,55 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"image"
+)
+
+// projector allows projecting from a source Rectangle onto a target Rectangle.
+type projector struct {
+	// rx, ry is the scaling factor.
+	rx, ry float64
+	// dx, dy is the translation factor.
+	dx, dy float64
+	// r is the clipping region of the target.
+	r image.Rectangle
+}
+
+// newProjector creates a Projector with source src and target dst.
+func newProjector(dst image.Rectangle, src image.Rectangle) *projector {
+	return &projector{
+		rx: float64(dst.Dx()) / float64(src.Dx()),
+		ry: float64(dst.Dy()) / float64(src.Dy()),
+		dx: float64(dst.Min.X - src.Min.X),
+		dy: float64(dst.Min.Y - src.Min.Y),
+		r:  dst,
+	}
+}
+
+// pt projects p from the source rectangle onto the target rectangle.
+func (s *projector) pt(p image.Point) image.Point {
+	return image.Point{
+		clamp(s.rx*float64(p.X)+s.dx, s.r.Min.X, s.r.Max.X),
+		clamp(s.ry*float64(p.Y)+s.dy, s.r.Min.Y, s.r.Max.Y),
+	}
+}
+
+// rect projects r from the source rectangle onto the target rectangle.
+func (s *projector) rect(r image.Rectangle) image.Rectangle {
+	return image.Rectangle{s.pt(r.Min), s.pt(r.Max)}
+}
+
+// clamp rounds and clamps o to the integer range [x0, x1].
+func clamp(o float64, x0, x1 int) int {
+	x := int(o + 0.5)
+	if x < x0 {
+		return x0
+	}
+	if x > x1 {
+		return x1
+	}
+	return x
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector_test.go
new file mode 100644
index 000000000..c6d0b0cd5
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/detect/projector_test.go
@@ -0,0 +1,49 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detect
+
+import (
+	"image"
+	"reflect"
+	"testing"
+)
+
+type projectorTest struct {
+	dst  image.Rectangle
+	src  image.Rectangle
+	pdst image.Rectangle
+	psrc image.Rectangle
+}
+
+var projectorTests = []projectorTest{
+	{
+		image.Rect(0, 0, 6, 6),
+		image.Rect(0, 0, 2, 2),
+		image.Rect(0, 0, 6, 6),
+		image.Rect(0, 0, 2, 2),
+	},
+	{
+		image.Rect(0, 0, 6, 6),
+		image.Rect(0, 0, 2, 2),
+		image.Rect(3, 3, 6, 6),
+		image.Rect(1, 1, 2, 2),
+	},
+	{
+		image.Rect(30, 30, 40, 40),
+		image.Rect(10, 10, 20, 20),
+		image.Rect(32, 33, 34, 37),
+		image.Rect(12, 13, 14, 17),
+	},
+}
+
+func TestProjector(t *testing.T) {
+	for i, tt := range projectorTests {
+		pr := newProjector(tt.dst, tt.src)
+		res := pr.rect(tt.psrc)
+		if !reflect.DeepEqual(res, tt.pdst) {
+			t.Errorf("%d: got %v want %v", i, res, tt.pdst)
+		}
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/Makefile b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/Makefile
new file mode 100644
index 000000000..7bfdf22d8
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/Makefile
@@ -0,0 +1,11 @@
+# Copyright 2011 The Graphics-Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.inc
+
+TARG=code.google.com/p/graphics-go/graphics/graphicstest
+GOFILES=\
+	graphicstest.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/graphicstest.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/graphicstest.go
new file mode 100644
index 000000000..ceb3a974d
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/graphicstest/graphicstest.go
@@ -0,0 +1,112 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphicstest
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"image"
+	"image/color"
+	"os"
+)
+
+// LoadImage decodes an image from a file.
+func LoadImage(path string) (img image.Image, err error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return
+	}
+	defer file.Close()
+	img, _, err = image.Decode(file)
+	return
+}
+
+func delta(u0, u1 uint32) int {
+	d := int(u0) - int(u1)
+	if d < 0 {
+		return -d
+	}
+	return d
+}
+
+func withinTolerance(c0, c1 color.Color, tol int) bool {
+	r0, g0, b0, a0 := c0.RGBA()
+	r1, g1, b1, a1 := c1.RGBA()
+	r := delta(r0, r1)
+	g := delta(g0, g1)
+	b := delta(b0, b1)
+	a := delta(a0, a1)
+	return r <= tol && g <= tol && b <= tol && a <= tol
+}
+
+// ImageWithinTolerance checks that each pixel varies by no more than tol.
+func ImageWithinTolerance(m0, m1 image.Image, tol int) error {
+	b0 := m0.Bounds()
+	b1 := m1.Bounds()
+	if !b0.Eq(b1) {
+		return errors.New(fmt.Sprintf("got bounds %v want %v", b0, b1))
+	}
+
+	for y := b0.Min.Y; y < b0.Max.Y; y++ {
+		for x := b0.Min.X; x < b0.Max.X; x++ {
+			c0 := m0.At(x, y)
+			c1 := m1.At(x, y)
+			if !withinTolerance(c0, c1, tol) {
+				e := fmt.Sprintf("got %v want %v at (%d, %d)", c0, c1, x, y)
+				return errors.New(e)
+			}
+		}
+	}
+	return nil
+}
+
+// SprintBox pretty prints the array as a hexidecimal matrix.
+func SprintBox(box []byte, width, height int) string {
+	buf := bytes.NewBuffer(nil)
+	i := 0
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			fmt.Fprintf(buf, " 0x%02x,", box[i])
+			i++
+		}
+		buf.WriteByte('\n')
+	}
+	return buf.String()
+}
+
+// SprintImageR pretty prints the red channel of src. It looks like SprintBox.
+func SprintImageR(src *image.RGBA) string {
+	w, h := src.Rect.Dx(), src.Rect.Dy()
+	i := 0
+	box := make([]byte, w*h)
+	for y := src.Rect.Min.Y; y < src.Rect.Max.Y; y++ {
+		for x := src.Rect.Min.X; x < src.Rect.Max.X; x++ {
+			off := (y-src.Rect.Min.Y)*src.Stride + (x-src.Rect.Min.X)*4
+			box[i] = src.Pix[off]
+			i++
+		}
+	}
+	return SprintBox(box, w, h)
+}
+
+// MakeRGBA returns an image with R, G, B taken from src.
+func MakeRGBA(src []uint8, width int) *image.RGBA {
+	b := image.Rect(0, 0, width, len(src)/width)
+	ret := image.NewRGBA(b)
+	i := 0
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			ret.SetRGBA(x, y, color.RGBA{
+				R: src[i],
+				G: src[i],
+				B: src[i],
+				A: 0xff,
+			})
+			i++
+		}
+	}
+	return ret
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/Makefile b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/Makefile
new file mode 100644
index 000000000..4d8f524fb
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/Makefile
@@ -0,0 +1,13 @@
+# Copyright 2012 The Graphics-Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.inc
+
+TARG=code.google.com/p/graphics-go/graphics/interp
+GOFILES=\
+	bilinear.go\
+	doc.go\
+	interp.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear.go
new file mode 100644
index 000000000..e18321a15
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear.go
@@ -0,0 +1,206 @@
+// Copyright 2012 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package interp
+
+import (
+	"image"
+	"image/color"
+	"math"
+)
+
+// Bilinear implements bilinear interpolation.
+var Bilinear Interp = bilinear{}
+
+type bilinear struct{}
+
+func (i bilinear) Interp(src image.Image, x, y float64) color.Color {
+	if src, ok := src.(*image.RGBA); ok {
+		return i.RGBA(src, x, y)
+	}
+	return bilinearGeneral(src, x, y)
+}
+
+func bilinearGeneral(src image.Image, x, y float64) color.Color {
+	p := findLinearSrc(src.Bounds(), x, y)
+	var fr, fg, fb, fa float64
+	var r, g, b, a uint32
+
+	r, g, b, a = src.At(p.low.X, p.low.Y).RGBA()
+	fr += float64(r) * p.frac00
+	fg += float64(g) * p.frac00
+	fb += float64(b) * p.frac00
+	fa += float64(a) * p.frac00
+
+	r, g, b, a = src.At(p.high.X, p.low.Y).RGBA()
+	fr += float64(r) * p.frac01
+	fg += float64(g) * p.frac01
+	fb += float64(b) * p.frac01
+	fa += float64(a) * p.frac01
+
+	r, g, b, a = src.At(p.low.X, p.high.Y).RGBA()
+	fr += float64(r) * p.frac10
+	fg += float64(g) * p.frac10
+	fb += float64(b) * p.frac10
+	fa += float64(a) * p.frac10
+
+	r, g, b, a = src.At(p.high.X, p.high.Y).RGBA()
+	fr += float64(r) * p.frac11
+	fg += float64(g) * p.frac11
+	fb += float64(b) * p.frac11
+	fa += float64(a) * p.frac11
+
+	var c color.RGBA64
+	c.R = uint16(fr + 0.5)
+	c.G = uint16(fg + 0.5)
+	c.B = uint16(fb + 0.5)
+	c.A = uint16(fa + 0.5)
+	return c
+}
+
+func (bilinear) RGBA(src *image.RGBA, x, y float64) color.RGBA {
+	p := findLinearSrc(src.Bounds(), x, y)
+
+	// Array offsets for the surrounding pixels.
+	off00 := offRGBA(src, p.low.X, p.low.Y)
+	off01 := offRGBA(src, p.high.X, p.low.Y)
+	off10 := offRGBA(src, p.low.X, p.high.Y)
+	off11 := offRGBA(src, p.high.X, p.high.Y)
+
+	var fr, fg, fb, fa float64
+
+	fr += float64(src.Pix[off00+0]) * p.frac00
+	fg += float64(src.Pix[off00+1]) * p.frac00
+	fb += float64(src.Pix[off00+2]) * p.frac00
+	fa += float64(src.Pix[off00+3]) * p.frac00
+
+	fr += float64(src.Pix[off01+0]) * p.frac01
+	fg += float64(src.Pix[off01+1]) * p.frac01
+	fb += float64(src.Pix[off01+2]) * p.frac01
+	fa += float64(src.Pix[off01+3]) * p.frac01
+
+	fr += float64(src.Pix[off10+0]) * p.frac10
+	fg += float64(src.Pix[off10+1]) * p.frac10
+	fb += float64(src.Pix[off10+2]) * p.frac10
+	fa += float64(src.Pix[off10+3]) * p.frac10
+
+	fr += float64(src.Pix[off11+0]) * p.frac11
+	fg += float64(src.Pix[off11+1]) * p.frac11
+	fb += float64(src.Pix[off11+2]) * p.frac11
+	fa += float64(src.Pix[off11+3]) * p.frac11
+
+	var c color.RGBA
+	c.R = uint8(fr + 0.5)
+	c.G = uint8(fg + 0.5)
+	c.B = uint8(fb + 0.5)
+	c.A = uint8(fa + 0.5)
+	return c
+}
+
+func (bilinear) Gray(src *image.Gray, x, y float64) color.Gray {
+	p := findLinearSrc(src.Bounds(), x, y)
+
+	// Array offsets for the surrounding pixels.
+	off00 := offGray(src, p.low.X, p.low.Y)
+	off01 := offGray(src, p.high.X, p.low.Y)
+	off10 := offGray(src, p.low.X, p.high.Y)
+	off11 := offGray(src, p.high.X, p.high.Y)
+
+	var fc float64
+	fc += float64(src.Pix[off00]) * p.frac00
+	fc += float64(src.Pix[off01]) * p.frac01
+	fc += float64(src.Pix[off10]) * p.frac10
+	fc += float64(src.Pix[off11]) * p.frac11
+
+	var c color.Gray
+	c.Y = uint8(fc + 0.5)
+	return c
+}
+
+type bilinearSrc struct {
+	// Top-left and bottom-right interpolation sources
+	low, high image.Point
+	// Fraction of each pixel to take. The 0 suffix indicates
+	// top/left, and the 1 suffix indicates bottom/right.
+	frac00, frac01, frac10, frac11 float64
+}
+
+func findLinearSrc(b image.Rectangle, sx, sy float64) bilinearSrc {
+	maxX := float64(b.Max.X)
+	maxY := float64(b.Max.Y)
+	minX := float64(b.Min.X)
+	minY := float64(b.Min.Y)
+	lowX := math.Floor(sx - 0.5)
+	lowY := math.Floor(sy - 0.5)
+	if lowX < minX {
+		lowX = minX
+	}
+	if lowY < minY {
+		lowY = minY
+	}
+
+	highX := math.Ceil(sx - 0.5)
+	highY := math.Ceil(sy - 0.5)
+	if highX >= maxX {
+		highX = maxX - 1
+	}
+	if highY >= maxY {
+		highY = maxY - 1
+	}
+
+	// In the variables below, the 0 suffix indicates top/left, and the
+	// 1 suffix indicates bottom/right.
+
+	// Center of each surrounding pixel.
+	x00 := lowX + 0.5
+	y00 := lowY + 0.5
+	x01 := highX + 0.5
+	y01 := lowY + 0.5
+	x10 := lowX + 0.5
+	y10 := highY + 0.5
+	x11 := highX + 0.5
+	y11 := highY + 0.5
+
+	p := bilinearSrc{
+		low:  image.Pt(int(lowX), int(lowY)),
+		high: image.Pt(int(highX), int(highY)),
+	}
+
+	// Literally, edge cases. If we are close enough to the edge of
+	// the image, curtail the interpolation sources.
+	if lowX == highX && lowY == highY {
+		p.frac00 = 1.0
+	} else if sy-minY <= 0.5 && sx-minX <= 0.5 {
+		p.frac00 = 1.0
+	} else if maxY-sy <= 0.5 && maxX-sx <= 0.5 {
+		p.frac11 = 1.0
+	} else if sy-minY <= 0.5 || lowY == highY {
+		p.frac00 = x01 - sx
+		p.frac01 = sx - x00
+	} else if sx-minX <= 0.5 || lowX == highX {
+		p.frac00 = y10 - sy
+		p.frac10 = sy - y00
+	} else if maxY-sy <= 0.5 {
+		p.frac10 = x11 - sx
+		p.frac11 = sx - x10
+	} else if maxX-sx <= 0.5 {
+		p.frac01 = y11 - sy
+		p.frac11 = sy - y01
+	} else {
+		p.frac00 = (x01 - sx) * (y10 - sy)
+		p.frac01 = (sx - x00) * (y11 - sy)
+		p.frac10 = (x11 - sx) * (sy - y00)
+		p.frac11 = (sx - x10) * (sy - y01)
+	}
+
+	return p
+}
+
+// TODO(crawshaw): When we have inlining, consider func (p *RGBA) Off(x, y) int
+func offRGBA(src *image.RGBA, x, y int) int {
+	return (y-src.Rect.Min.Y)*src.Stride + (x-src.Rect.Min.X)*4
+}
+func offGray(src *image.Gray, x, y int) int {
+	return (y-src.Rect.Min.Y)*src.Stride + (x - src.Rect.Min.X)
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear_test.go
new file mode 100644
index 000000000..242d70546
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/bilinear_test.go
@@ -0,0 +1,143 @@
+// Copyright 2012 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package interp
+
+import (
+	"image"
+	"image/color"
+	"testing"
+)
+
+type interpTest struct {
+	desc     string
+	src      []uint8
+	srcWidth int
+	x, y     float64
+	expect   uint8
+}
+
+func (p *interpTest) newSrc() *image.RGBA {
+	b := image.Rect(0, 0, p.srcWidth, len(p.src)/p.srcWidth)
+	src := image.NewRGBA(b)
+	i := 0
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			src.SetRGBA(x, y, color.RGBA{
+				R: p.src[i],
+				G: p.src[i],
+				B: p.src[i],
+				A: 0xff,
+			})
+			i++
+		}
+	}
+	return src
+}
+
+var interpTests = []interpTest{
+	{
+		desc:     "center of a single white pixel should match that pixel",
+		src:      []uint8{0x00},
+		srcWidth: 1,
+		x:        0.5,
+		y:        0.5,
+		expect:   0x00,
+	},
+	{
+		desc: "middle of a square is equally weighted",
+		src: []uint8{
+			0x00, 0xff,
+			0xff, 0x00,
+		},
+		srcWidth: 2,
+		x:        1.0,
+		y:        1.0,
+		expect:   0x80,
+	},
+	{
+		desc: "center of a pixel is just that pixel",
+		src: []uint8{
+			0x00, 0xff,
+			0xff, 0x00,
+		},
+		srcWidth: 2,
+		x:        1.5,
+		y:        0.5,
+		expect:   0xff,
+	},
+	{
+		desc: "asymmetry abounds",
+		src: []uint8{
+			0xaa, 0x11, 0x55,
+			0xff, 0x95, 0xdd,
+		},
+		srcWidth: 3,
+		x:        2.0,
+		y:        1.0,
+		expect:   0x76, // (0x11 + 0x55 + 0x95 + 0xdd) / 4
+	},
+}
+
+func TestBilinearRGBA(t *testing.T) {
+	for _, p := range interpTests {
+		src := p.newSrc()
+
+		// Fast path.
+		c := Bilinear.(RGBA).RGBA(src, p.x, p.y)
+		if c.R != c.G || c.R != c.B || c.A != 0xff {
+			t.Errorf("expect channels to match, got %v", c)
+			continue
+		}
+		if c.R != p.expect {
+			t.Errorf("%s: got 0x%02x want 0x%02x", p.desc, c.R, p.expect)
+			continue
+		}
+
+		// Standard Interp should use the fast path.
+		cStd := Bilinear.Interp(src, p.x, p.y)
+		if cStd != c {
+			t.Errorf("%s: standard mismatch got %v want %v", p.desc, cStd, c)
+			continue
+		}
+
+		// General case should match the fast path.
+		cGen := color.RGBAModel.Convert(bilinearGeneral(src, p.x, p.y))
+		r0, g0, b0, a0 := c.RGBA()
+		r1, g1, b1, a1 := cGen.RGBA()
+		if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 {
+			t.Errorf("%s: general case mismatch got %v want %v", p.desc, c, cGen)
+			continue
+		}
+	}
+}
+
+func TestBilinearSubImage(t *testing.T) {
+	b0 := image.Rect(0, 0, 4, 4)
+	src0 := image.NewRGBA(b0)
+	b1 := image.Rect(1, 1, 3, 3)
+	src1 := src0.SubImage(b1).(*image.RGBA)
+	src1.Set(1, 1, color.RGBA{0x11, 0, 0, 0xff})
+	src1.Set(2, 1, color.RGBA{0x22, 0, 0, 0xff})
+	src1.Set(1, 2, color.RGBA{0x33, 0, 0, 0xff})
+	src1.Set(2, 2, color.RGBA{0x44, 0, 0, 0xff})
+
+	tests := []struct {
+		x, y float64
+		want uint8
+	}{
+		{1, 1, 0x11},
+		{3, 1, 0x22},
+		{1, 3, 0x33},
+		{3, 3, 0x44},
+		{2, 2, 0x2b},
+	}
+
+	for _, p := range tests {
+		c := Bilinear.(RGBA).RGBA(src1, p.x, p.y)
+		if c.R != p.want {
+			t.Errorf("(%.0f, %.0f): got 0x%02x want 0x%02x", p.x, p.y, c.R, p.want)
+		}
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/doc.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/doc.go
new file mode 100644
index 000000000..b115534cc
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/doc.go
@@ -0,0 +1,25 @@
+// Copyright 2012 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package interp implements image interpolation.
+
+An interpolator provides the Interp interface, which can be used
+to interpolate a pixel:
+
+  c := interp.Bilinear.Interp(src, 1.2, 1.8)
+
+To interpolate a large number of RGBA or Gray pixels, an implementation 
+may provide a fast-path by implementing the RGBA or Gray interfaces.
+
+	i1, ok := i.(interp.RGBA)
+	if ok {
+		c := i1.RGBA(src, 1.2, 1.8)
+		// use c.R, c.G, etc
+		return
+	}
+	c := i.Interp(src, 1.2, 1.8)
+	// use generic color.Color
+*/
+package interp
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/interp.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/interp.go
new file mode 100644
index 000000000..560637d4a
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/interp/interp.go
@@ -0,0 +1,29 @@
+// Copyright 2012 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package interp
+
+import (
+	"image"
+	"image/color"
+)
+
+// Interp interpolates an image's color at fractional co-ordinates.
+type Interp interface {
+	// Interp interpolates (x, y).
+	Interp(src image.Image, x, y float64) color.Color
+}
+
+// RGBA is a fast-path interpolation implementation for image.RGBA.
+// It is common for an Interp to also implement RGBA.
+type RGBA interface {
+	// RGBA interpolates (x, y).
+	RGBA(src *image.RGBA, x, y float64) color.RGBA
+}
+
+// Gray is a fast-path interpolation implementation for image.Gray.
+type Gray interface {
+	// Gray interpolates (x, y).
+	Gray(src *image.Gray, x, y float64) color.Gray
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate.go
new file mode 100644
index 000000000..62bde1a08
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate.go
@@ -0,0 +1,35 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/interp"
+	"errors"
+	"image"
+	"image/draw"
+)
+
+// RotateOptions are the rotation parameters.
+// Angle is the angle, in radians, to rotate the image clockwise.
+type RotateOptions struct {
+	Angle float64
+}
+
+// Rotate produces a rotated version of src, drawn onto dst.
+func Rotate(dst draw.Image, src image.Image, opt *RotateOptions) error {
+	if dst == nil {
+		return errors.New("graphics: dst is nil")
+	}
+	if src == nil {
+		return errors.New("graphics: src is nil")
+	}
+
+	angle := 0.0
+	if opt != nil {
+		angle = opt.Angle
+	}
+
+	return I.Rotate(angle).TransformCenter(dst, src, interp.Bilinear)
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate_test.go
new file mode 100644
index 000000000..bfc532a0a
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/rotate_test.go
@@ -0,0 +1,169 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/graphicstest"
+	"image"
+	"math"
+	"testing"
+
+	_ "image/png"
+)
+
+var rotateOneColorTests = []transformOneColorTest{
+	{
+		"onepixel-onequarter", 1, 1, 1, 1,
+		&RotateOptions{math.Pi / 2},
+		[]uint8{0xff},
+		[]uint8{0xff},
+	},
+	{
+		"onepixel-partial", 1, 1, 1, 1,
+		&RotateOptions{math.Pi * 2.0 / 3.0},
+		[]uint8{0xff},
+		[]uint8{0xff},
+	},
+	{
+		"onepixel-complete", 1, 1, 1, 1,
+		&RotateOptions{2 * math.Pi},
+		[]uint8{0xff},
+		[]uint8{0xff},
+	},
+	{
+		"even-onequarter", 2, 2, 2, 2,
+		&RotateOptions{math.Pi / 2.0},
+		[]uint8{
+			0xff, 0x00,
+			0x00, 0xff,
+		},
+		[]uint8{
+			0x00, 0xff,
+			0xff, 0x00,
+		},
+	},
+	{
+		"even-complete", 2, 2, 2, 2,
+		&RotateOptions{2.0 * math.Pi},
+		[]uint8{
+			0xff, 0x00,
+			0x00, 0xff,
+		},
+		[]uint8{
+			0xff, 0x00,
+			0x00, 0xff,
+		},
+	},
+	{
+		"line-partial", 3, 3, 3, 3,
+		&RotateOptions{math.Pi * 1.0 / 3.0},
+		[]uint8{
+			0x00, 0x00, 0x00,
+			0xff, 0xff, 0xff,
+			0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0xa2, 0x80, 0x00,
+			0x22, 0xff, 0x22,
+			0x00, 0x80, 0xa2,
+		},
+	},
+	{
+		"line-offset-partial", 3, 3, 3, 3,
+		&RotateOptions{math.Pi * 3 / 2},
+		[]uint8{
+			0x00, 0x00, 0x00,
+			0x00, 0xff, 0xff,
+			0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0xff, 0x00,
+			0x00, 0xff, 0x00,
+			0x00, 0x00, 0x00,
+		},
+	},
+	{
+		"dot-partial", 4, 4, 4, 4,
+		&RotateOptions{math.Pi},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00,
+			0x00, 0xff, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00,
+		},
+		[]uint8{
+			0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0xff, 0x00,
+			0x00, 0x00, 0x00, 0x00,
+		},
+	},
+}
+
+func TestRotateOneColor(t *testing.T) {
+	for _, oc := range rotateOneColorTests {
+		src := oc.newSrc()
+		dst := oc.newDst()
+
+		if err := Rotate(dst, src, oc.opt.(*RotateOptions)); err != nil {
+			t.Errorf("rotate %s: %v", oc.desc, err)
+			continue
+		}
+		if !checkTransformTest(t, &oc, dst) {
+			continue
+		}
+	}
+}
+
+func TestRotateEmpty(t *testing.T) {
+	empty := image.NewRGBA(image.Rect(0, 0, 0, 0))
+	if err := Rotate(empty, empty, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRotateGopherSide(t *testing.T) {
+	src, err := graphicstest.LoadImage("../testdata/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	srcb := src.Bounds()
+	dst := image.NewRGBA(image.Rect(0, 0, srcb.Dy(), srcb.Dx()))
+	if err := Rotate(dst, src, &RotateOptions{math.Pi / 2.0}); err != nil {
+		t.Fatal(err)
+	}
+
+	cmp, err := graphicstest.LoadImage("../testdata/gopher-rotate-side.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0x101)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRotateGopherPartial(t *testing.T) {
+	src, err := graphicstest.LoadImage("../testdata/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	srcb := src.Bounds()
+	dst := image.NewRGBA(image.Rect(0, 0, srcb.Dx(), srcb.Dy()))
+	if err := Rotate(dst, src, &RotateOptions{math.Pi / 3.0}); err != nil {
+		t.Fatal(err)
+	}
+
+	cmp, err := graphicstest.LoadImage("../testdata/gopher-rotate-partial.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0x101)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale.go
new file mode 100644
index 000000000..7a7fe9696
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale.go
@@ -0,0 +1,31 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/interp"
+	"errors"
+	"image"
+	"image/draw"
+)
+
+// Scale produces a scaled version of the image using bilinear interpolation.
+func Scale(dst draw.Image, src image.Image) error {
+	if dst == nil {
+		return errors.New("graphics: dst is nil")
+	}
+	if src == nil {
+		return errors.New("graphics: src is nil")
+	}
+
+	b := dst.Bounds()
+	srcb := src.Bounds()
+	if b.Empty() || srcb.Empty() {
+		return nil
+	}
+	sx := float64(b.Dx()) / float64(srcb.Dx())
+	sy := float64(b.Dy()) / float64(srcb.Dy())
+	return I.Scale(sx, sy).Transform(dst, src, interp.Bilinear)
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale_test.go
new file mode 100644
index 000000000..9c2468f11
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/scale_test.go
@@ -0,0 +1,153 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/graphicstest"
+	"image"
+	"testing"
+
+	_ "image/png"
+)
+
+var scaleOneColorTests = []transformOneColorTest{
+	{
+		"down-half",
+		1, 1,
+		2, 2,
+		nil,
+		[]uint8{
+			0x80, 0x00,
+			0x00, 0x80,
+		},
+		[]uint8{
+			0x40,
+		},
+	},
+	{
+		"up-double",
+		4, 4,
+		2, 2,
+		nil,
+		[]uint8{
+			0x80, 0x00,
+			0x00, 0x80,
+		},
+		[]uint8{
+			0x80, 0x60, 0x20, 0x00,
+			0x60, 0x50, 0x30, 0x20,
+			0x20, 0x30, 0x50, 0x60,
+			0x00, 0x20, 0x60, 0x80,
+		},
+	},
+	{
+		"up-doublewidth",
+		4, 2,
+		2, 2,
+		nil,
+		[]uint8{
+			0x80, 0x00,
+			0x00, 0x80,
+		},
+		[]uint8{
+			0x80, 0x60, 0x20, 0x00,
+			0x00, 0x20, 0x60, 0x80,
+		},
+	},
+	{
+		"up-doubleheight",
+		2, 4,
+		2, 2,
+		nil,
+		[]uint8{
+			0x80, 0x00,
+			0x00, 0x80,
+		},
+		[]uint8{
+			0x80, 0x00,
+			0x60, 0x20,
+			0x20, 0x60,
+			0x00, 0x80,
+		},
+	},
+	{
+		"up-partial",
+		3, 3,
+		2, 2,
+		nil,
+		[]uint8{
+			0x80, 0x00,
+			0x00, 0x80,
+		},
+		[]uint8{
+			0x80, 0x40, 0x00,
+			0x40, 0x40, 0x40,
+			0x00, 0x40, 0x80,
+		},
+	},
+}
+
+func TestScaleOneColor(t *testing.T) {
+	for _, oc := range scaleOneColorTests {
+		dst := oc.newDst()
+		src := oc.newSrc()
+		if err := Scale(dst, src); err != nil {
+			t.Errorf("scale %s: %v", oc.desc, err)
+			continue
+		}
+
+		if !checkTransformTest(t, &oc, dst) {
+			continue
+		}
+	}
+}
+
+func TestScaleEmpty(t *testing.T) {
+	empty := image.NewRGBA(image.Rect(0, 0, 0, 0))
+	if err := Scale(empty, empty); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestScaleGopher(t *testing.T) {
+	dst := image.NewRGBA(image.Rect(0, 0, 100, 150))
+
+	src, err := graphicstest.LoadImage("../testdata/gopher.png")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	// Down-sample.
+	if err := Scale(dst, src); err != nil {
+		t.Fatal(err)
+	}
+	cmp, err := graphicstest.LoadImage("../testdata/gopher-100x150.png")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	// Up-sample.
+	dst = image.NewRGBA(image.Rect(0, 0, 500, 750))
+	if err := Scale(dst, src); err != nil {
+		t.Fatal(err)
+	}
+	cmp, err = graphicstest.LoadImage("../testdata/gopher-500x750.png")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/shared_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/shared_test.go
new file mode 100644
index 000000000..e1cd21fb3
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/shared_test.go
@@ -0,0 +1,69 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"bytes"
+	"code.google.com/p/graphics-go/graphics/graphicstest"
+	"image"
+	"image/color"
+	"testing"
+)
+
+type transformOneColorTest struct {
+	desc      string
+	dstWidth  int
+	dstHeight int
+	srcWidth  int
+	srcHeight int
+	opt       interface{}
+	src       []uint8
+	res       []uint8
+}
+
+func (oc *transformOneColorTest) newSrc() *image.RGBA {
+	b := image.Rect(0, 0, oc.srcWidth, oc.srcHeight)
+	src := image.NewRGBA(b)
+	i := 0
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			src.SetRGBA(x, y, color.RGBA{
+				R: oc.src[i],
+				G: oc.src[i],
+				B: oc.src[i],
+				A: oc.src[i],
+			})
+			i++
+		}
+	}
+	return src
+}
+
+func (oc *transformOneColorTest) newDst() *image.RGBA {
+	return image.NewRGBA(image.Rect(0, 0, oc.dstWidth, oc.dstHeight))
+}
+
+func checkTransformTest(t *testing.T, oc *transformOneColorTest, dst *image.RGBA) bool {
+	for ch := 0; ch < 4; ch++ {
+		i := 0
+		res := make([]byte, len(oc.res))
+		for y := 0; y < oc.dstHeight; y++ {
+			for x := 0; x < oc.dstWidth; x++ {
+				off := (y-dst.Rect.Min.Y)*dst.Stride + (x-dst.Rect.Min.X)*4
+				res[i] = dst.Pix[off+ch]
+				i++
+			}
+		}
+
+		if !bytes.Equal(res, oc.res) {
+			got := graphicstest.SprintBox(res, oc.dstWidth, oc.dstHeight)
+			want := graphicstest.SprintBox(oc.res, oc.dstWidth, oc.dstHeight)
+			t.Errorf("%s: ch=%d\n got\n%s\n want\n%s", oc.desc, ch, got, want)
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail.go
new file mode 100644
index 000000000..d3ad7e8f7
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail.go
@@ -0,0 +1,41 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"image"
+	"image/draw"
+)
+
+// Thumbnail scales and crops src so it fits in dst.
+func Thumbnail(dst draw.Image, src image.Image) error {
+	// Scale down src in the dimension that is closer to dst.
+	sb := src.Bounds()
+	db := dst.Bounds()
+	rx := float64(sb.Dx()) / float64(db.Dx())
+	ry := float64(sb.Dy()) / float64(db.Dy())
+	var b image.Rectangle
+	if rx < ry {
+		b = image.Rect(0, 0, db.Dx(), int(float64(sb.Dy())/rx))
+	} else {
+		b = image.Rect(0, 0, int(float64(sb.Dx())/ry), db.Dy())
+	}
+
+	buf := image.NewRGBA(b)
+	if err := Scale(buf, src); err != nil {
+		return err
+	}
+
+	// Crop.
+	// TODO(crawshaw): improve on center-alignment.
+	var pt image.Point
+	if rx < ry {
+		pt.Y = (b.Dy() - db.Dy()) / 2
+	} else {
+		pt.X = (b.Dx() - db.Dx()) / 2
+	}
+	draw.Draw(dst, db, buf, pt, draw.Src)
+	return nil
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail_test.go b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail_test.go
new file mode 100644
index 000000000..d12659f17
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/graphics-go/graphics/thumbnail_test.go
@@ -0,0 +1,53 @@
+// Copyright 2011 The Graphics-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package graphics
+
+import (
+	"code.google.com/p/graphics-go/graphics/graphicstest"
+	"image"
+	"testing"
+
+	_ "image/png"
+)
+
+func TestThumbnailGopher(t *testing.T) {
+	dst := image.NewRGBA(image.Rect(0, 0, 80, 80))
+
+	src, err := graphicstest.LoadImage("../testdata/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := Thumbnail(dst, src); err != nil {
+		t.Fatal(err)
+	}
+	cmp, err := graphicstest.LoadImage("../testdata/gopher-thumb-80x80.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestThumbnailLongGopher(t *testing.T) {
+	dst := image.NewRGBA(image.Rect(0, 0, 50, 150))
+
+	src, err := graphicstest.LoadImage("../testdata/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := Thumbnail(dst, src); err != nil {
+		t.Fatal(err)
+	}
+	cmp, err := graphicstest.LoadImage("../testdata/gopher-thumb-50x150.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = graphicstest.ImageWithinTolerance(dst, cmp, 0)
+	if err != nil {
+		t.Error(err)
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/README.md b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/README.md
new file mode 100644
index 000000000..b3bf5fa0e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/README.md
@@ -0,0 +1,4 @@
+
+To regenerate the regression test data, run `go generate` inside the exif
+package directory and commit the changes to *regress_expected_test.go*.
+
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/example_test.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/example_test.go
new file mode 100644
index 000000000..45fd5d4ad
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/example_test.go
@@ -0,0 +1,42 @@
+package exif_test
+
+import (
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/rwcarlsen/goexif/exif"
+	"github.com/rwcarlsen/goexif/mknote"
+)
+
+func ExampleDecode() {
+	fname := "sample1.jpg"
+
+	f, err := os.Open(fname)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Optionally register camera makenote data parsing - currently Nikon and
+	// Canon are supported.
+	exif.RegisterParsers(mknote.All...)
+
+	x, err := exif.Decode(f)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	camModel, _ := x.Get(exif.Model) // normally, don't ignore errors!
+	fmt.Println(camModel.StringVal())
+
+	focal, _ := x.Get(exif.FocalLength)
+	numer, denom, _ := focal.Rat2(0) // retrieve first (only) rat. value
+	fmt.Printf("%v/%v", numer, denom)
+
+	// Two convenience functions exist for date/time taken and GPS coords:
+	tm, _ := x.DateTime()
+	fmt.Println("Taken: ", tm)
+
+	lat, long, _ := x.LatLong()
+	fmt.Println("lat, long: ", lat, ", ", long)
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif.go
new file mode 100644
index 000000000..b420729da
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif.go
@@ -0,0 +1,619 @@
+// Package exif implements decoding of EXIF data as defined in the EXIF 2.2
+// specification (http://www.exif.org/Exif2-2.PDF).
+package exif
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/rwcarlsen/goexif/tiff"
+)
+
+const (
+	jpeg_APP1 = 0xE1
+
+	exifPointer    = 0x8769
+	gpsPointer     = 0x8825
+	interopPointer = 0xA005
+)
+
+// A decodeError is returned when the image cannot be decoded as a tiff image.
+type decodeError struct {
+	cause error
+}
+
+func (de decodeError) Error() string {
+	return fmt.Sprintf("exif: decode failed (%v) ", de.cause.Error())
+}
+
+// IsShortReadTagValueError identifies a ErrShortReadTagValue error.
+func IsShortReadTagValueError(err error) bool {
+	de, ok := err.(decodeError)
+	if ok {
+		return de.cause == tiff.ErrShortReadTagValue
+	}
+	return false
+}
+
+// A TagNotPresentError is returned when the requested field is not
+// present in the EXIF.
+type TagNotPresentError FieldName
+
+func (tag TagNotPresentError) Error() string {
+	return fmt.Sprintf("exif: tag %q is not present", string(tag))
+}
+
+func IsTagNotPresentError(err error) bool {
+	_, ok := err.(TagNotPresentError)
+	return ok
+}
+
+// Parser allows the registration of custom parsing and field loading
+// in the Decode function.
+type Parser interface {
+	// Parse should read data from x and insert parsed fields into x via
+	// LoadTags.
+	Parse(x *Exif) error
+}
+
+var parsers []Parser
+
+func init() {
+	RegisterParsers(&parser{})
+}
+
+// RegisterParsers registers one or more parsers to be automatically called
+// when decoding EXIF data via the Decode function.
+func RegisterParsers(ps ...Parser) {
+	parsers = append(parsers, ps...)
+}
+
+type parser struct{}
+
+type tiffErrors map[tiffError]string
+
+func (te tiffErrors) Error() string {
+	var allErrors []string
+	for k, v := range te {
+		allErrors = append(allErrors, fmt.Sprintf("%s: %v\n", stagePrefix[k], v))
+	}
+	return strings.Join(allErrors, "\n")
+}
+
+// IsCriticalError, given the error returned by Decode, reports whether the
+// returned *Exif may contain usable information.
+func IsCriticalError(err error) bool {
+	_, ok := err.(tiffErrors)
+	return !ok
+}
+
+// IsExifError reports whether the error happened while decoding the EXIF
+// sub-IFD.
+func IsExifError(err error) bool {
+	if te, ok := err.(tiffErrors); ok {
+		_, isExif := te[loadExif]
+		return isExif
+	}
+	return false
+}
+
+// IsGPSError reports whether the error happened while decoding the GPS sub-IFD.
+func IsGPSError(err error) bool {
+	if te, ok := err.(tiffErrors); ok {
+		_, isGPS := te[loadExif]
+		return isGPS
+	}
+	return false
+}
+
+// IsInteroperabilityError reports whether the error happened while decoding the
+// Interoperability sub-IFD.
+func IsInteroperabilityError(err error) bool {
+	if te, ok := err.(tiffErrors); ok {
+		_, isInterop := te[loadInteroperability]
+		return isInterop
+	}
+	return false
+}
+
+type tiffError int
+
+const (
+	loadExif tiffError = iota
+	loadGPS
+	loadInteroperability
+)
+
+var stagePrefix = map[tiffError]string{
+	loadExif:             "loading EXIF sub-IFD",
+	loadGPS:              "loading GPS sub-IFD",
+	loadInteroperability: "loading Interoperability sub-IFD",
+}
+
+// Parse reads data from the tiff data in x and populates the tags
+// in x. If parsing a sub-IFD fails, the error is recorded and
+// parsing continues with the remaining sub-IFDs.
+func (p *parser) Parse(x *Exif) error {
+	x.LoadTags(x.Tiff.Dirs[0], exifFields, false)
+
+	// thumbnails
+	if len(x.Tiff.Dirs) >= 2 {
+		x.LoadTags(x.Tiff.Dirs[1], thumbnailFields, false)
+	}
+
+	te := make(tiffErrors)
+
+	// recurse into exif, gps, and interop sub-IFDs
+	if err := loadSubDir(x, ExifIFDPointer, exifFields); err != nil {
+		te[loadExif] = err.Error()
+	}
+	if err := loadSubDir(x, GPSInfoIFDPointer, gpsFields); err != nil {
+		te[loadGPS] = err.Error()
+	}
+
+	if err := loadSubDir(x, InteroperabilityIFDPointer, interopFields); err != nil {
+		te[loadInteroperability] = err.Error()
+	}
+	if len(te) > 0 {
+		return te
+	}
+	return nil
+}
+
+func loadSubDir(x *Exif, ptr FieldName, fieldMap map[uint16]FieldName) error {
+	r := bytes.NewReader(x.Raw)
+
+	tag, err := x.Get(ptr)
+	if err != nil {
+		return nil
+	}
+	offset, err := tag.Int64(0)
+	if err != nil {
+		return nil
+	}
+
+	_, err = r.Seek(offset, 0)
+	if err != nil {
+		return fmt.Errorf("exif: seek to sub-IFD %s failed: %v", ptr, err)
+	}
+	subDir, _, err := tiff.DecodeDir(r, x.Tiff.Order)
+	if err != nil {
+		return fmt.Errorf("exif: sub-IFD %s decode failed: %v", ptr, err)
+	}
+	x.LoadTags(subDir, fieldMap, false)
+	return nil
+}
+
+// Exif provides access to decoded EXIF metadata fields and values.
+type Exif struct {
+	Tiff *tiff.Tiff
+	main map[FieldName]*tiff.Tag
+	Raw  []byte
+}
+
+// Decode parses EXIF-encoded data from r and returns a queryable Exif
+// object. After the exif data section is called and the tiff structure
+// decoded, each registered parser is called (in order of registration). If
+// one parser returns an error, decoding terminates and the remaining
+// parsers are not called.
+// The error can be inspected with functions such as IsCriticalError to
+// determine whether the returned object might still be usable.
+func Decode(r io.Reader) (*Exif, error) {
+	// EXIF data in JPEG is stored in the APP1 marker. EXIF data uses the TIFF
+	// format to store data.
+	// If we're parsing a TIFF image, we don't need to strip away any data.
+	// If we're parsing a JPEG image, we need to strip away the JPEG APP1
+	// marker and also the EXIF header.
+
+	header := make([]byte, 4)
+	n, err := r.Read(header)
+	if err != nil {
+		return nil, err
+	}
+	if n < len(header) {
+		return nil, errors.New("exif: short read on header")
+	}
+
+	var isTiff bool
+	switch string(header) {
+	case "II*\x00":
+		// TIFF - Little endian (Intel)
+		isTiff = true
+	case "MM\x00*":
+		// TIFF - Big endian (Motorola)
+		isTiff = true
+	default:
+		// Not TIFF, assume JPEG
+	}
+
+	// Put the header bytes back into the reader.
+	r = io.MultiReader(bytes.NewReader(header), r)
+	var (
+		er  *bytes.Reader
+		tif *tiff.Tiff
+	)
+
+	if isTiff {
+		// Functions below need the IFDs from the TIFF data to be stored in a
+		// *bytes.Reader.  We use TeeReader to get a copy of the bytes as a
+		// side-effect of tiff.Decode() doing its work.
+		b := &bytes.Buffer{}
+		tr := io.TeeReader(r, b)
+		tif, err = tiff.Decode(tr)
+		er = bytes.NewReader(b.Bytes())
+	} else {
+		// Locate the JPEG APP1 header.
+		var sec *appSec
+		sec, err = newAppSec(jpeg_APP1, r)
+		if err != nil {
+			return nil, err
+		}
+		// Strip away EXIF header.
+		er, err = sec.exifReader()
+		if err != nil {
+			return nil, err
+		}
+		tif, err = tiff.Decode(er)
+	}
+
+	if err != nil {
+		return nil, decodeError{cause: err}
+	}
+
+	er.Seek(0, 0)
+	raw, err := ioutil.ReadAll(er)
+	if err != nil {
+		return nil, decodeError{cause: err}
+	}
+
+	// build an exif structure from the tiff
+	x := &Exif{
+		main: map[FieldName]*tiff.Tag{},
+		Tiff: tif,
+		Raw:  raw,
+	}
+
+	for i, p := range parsers {
+		if err := p.Parse(x); err != nil {
+			if _, ok := err.(tiffErrors); ok {
+				return x, err
+			}
+			// This should never happen, as Parse always returns a tiffError
+			// for now, but that could change.
+			return x, fmt.Errorf("exif: parser %v failed (%v)", i, err)
+		}
+	}
+
+	return x, nil
+}
+
+// LoadTags loads tags into the available fields from the tiff Directory
+// using the given tagid-fieldname mapping.  Used to load makernote and
+// other meta-data.  If showMissing is true, tags in d that are not in the
+// fieldMap will be loaded with the FieldName UnknownPrefix followed by the
+// tag ID (in hex format).
+func (x *Exif) LoadTags(d *tiff.Dir, fieldMap map[uint16]FieldName, showMissing bool) {
+	for _, tag := range d.Tags {
+		name := fieldMap[tag.Id]
+		if name == "" {
+			if !showMissing {
+				continue
+			}
+			name = FieldName(fmt.Sprintf("%v%x", UnknownPrefix, tag.Id))
+		}
+		x.main[name] = tag
+	}
+}
+
+// Get retrieves the EXIF tag for the given field name.
+//
+// If the tag is not known or not present, an error is returned. If the
+// tag name is known, the error will be a TagNotPresentError.
+func (x *Exif) Get(name FieldName) (*tiff.Tag, error) {
+	if tg, ok := x.main[name]; ok {
+		return tg, nil
+	}
+	return nil, TagNotPresentError(name)
+}
+
+// Walker is the interface used to traverse all fields of an Exif object.
+type Walker interface {
+	// Walk is called for each non-nil EXIF field. Returning a non-nil
+	// error aborts the walk/traversal.
+	Walk(name FieldName, tag *tiff.Tag) error
+}
+
+// Walk calls the Walk method of w with the name and tag for every non-nil
+// EXIF field.  If w aborts the walk with an error, that error is returned.
+func (x *Exif) Walk(w Walker) error {
+	for name, tag := range x.main {
+		if err := w.Walk(name, tag); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// DateTime returns the EXIF's "DateTimeOriginal" field, which
+// is the creation time of the photo. If not found, it tries
+// the "DateTime" (which is meant as the modtime) instead.
+// The error will be TagNotPresentErr if none of those tags
+// were found, or a generic error if the tag value was
+// not a string, or the error returned by time.Parse.
+//
+// If the EXIF lacks timezone information or GPS time, the returned
+// time's Location will be time.Local.
+func (x *Exif) DateTime() (time.Time, error) {
+	var dt time.Time
+	tag, err := x.Get(DateTimeOriginal)
+	if err != nil {
+		tag, err = x.Get(DateTime)
+		if err != nil {
+			return dt, err
+		}
+	}
+	if tag.Format() != tiff.StringVal {
+		return dt, errors.New("DateTime[Original] not in string format")
+	}
+	exifTimeLayout := "2006:01:02 15:04:05"
+	dateStr := strings.TrimRight(string(tag.Val), "\x00")
+	// TODO(bradfitz,mpl): look for timezone offset, GPS time, etc.
+	// For now, just always return the time.Local timezone.
+	return time.ParseInLocation(exifTimeLayout, dateStr, time.Local)
+}
+
+func ratFloat(num, dem int64) float64 {
+	return float64(num) / float64(dem)
+}
+
+// Tries to parse a Geo degrees value from a string as it was found in some
+// EXIF data.
+// Supported formats so far:
+// - "52,00000,50,00000,34,01180" ==> 52 deg 50'34.0118"
+//   Probably due to locale the comma is used as decimal mark as well as the
+//   separator of three floats (degrees, minutes, seconds)
+//   http://en.wikipedia.org/wiki/Decimal_mark#Hindu.E2.80.93Arabic_numeral_system
+// - "52.0,50.0,34.01180" ==> 52deg50'34.0118"
+// - "52,50,34.01180"     ==> 52deg50'34.0118"
+func parseTagDegreesString(s string) (float64, error) {
+	const unparsableErrorFmt = "Unknown coordinate format: %s"
+	isSplitRune := func(c rune) bool {
+		return c == ',' || c == ';'
+	}
+	parts := strings.FieldsFunc(s, isSplitRune)
+	var degrees, minutes, seconds float64
+	var err error
+	switch len(parts) {
+	case 6:
+		degrees, err = strconv.ParseFloat(parts[0]+"."+parts[1], 64)
+		if err != nil {
+			return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+		}
+		minutes, err = strconv.ParseFloat(parts[2]+"."+parts[3], 64)
+		if err != nil {
+			return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+		}
+		minutes = math.Copysign(minutes, degrees)
+		seconds, err = strconv.ParseFloat(parts[4]+"."+parts[5], 64)
+		if err != nil {
+			return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+		}
+		seconds = math.Copysign(seconds, degrees)
+	case 3:
+		degrees, err = strconv.ParseFloat(parts[0], 64)
+		if err != nil {
+			return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+		}
+		minutes, err = strconv.ParseFloat(parts[1], 64)
+		if err != nil {
+			return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+		}
+		minutes = math.Copysign(minutes, degrees)
+		seconds, err = strconv.ParseFloat(parts[2], 64)
+		if err != nil {
+			return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+		}
+		seconds = math.Copysign(seconds, degrees)
+	default:
+		return 0.0, fmt.Errorf(unparsableErrorFmt, s)
+	}
+	return degrees + minutes/60.0 + seconds/3600.0, nil
+}
+
+func parse3Rat2(tag *tiff.Tag) ([3]float64, error) {
+	v := [3]float64{}
+	for i := range v {
+		num, den, err := tag.Rat2(i)
+		if err != nil {
+			return v, err
+		}
+		v[i] = ratFloat(num, den)
+		if tag.Count < uint32(i+2) {
+			break
+		}
+	}
+	return v, nil
+}
+
+func tagDegrees(tag *tiff.Tag) (float64, error) {
+	switch tag.Format() {
+	case tiff.RatVal:
+		// The usual case, according to the Exif spec
+		// (http://www.kodak.com/global/plugins/acrobat/en/service/digCam/exifStandard2.pdf,
+		// sec 4.6.6, p. 52 et seq.)
+		v, err := parse3Rat2(tag)
+		if err != nil {
+			return 0.0, err
+		}
+		return v[0] + v[1]/60 + v[2]/3600.0, nil
+	case tiff.StringVal:
+		// Encountered this weird case with a panorama picture taken with a HTC phone
+		s, err := tag.StringVal()
+		if err != nil {
+			return 0.0, err
+		}
+		return parseTagDegreesString(s)
+	default:
+		// don't know how to parse value, give up
+		return 0.0, fmt.Errorf("Malformed EXIF Tag Degrees")
+	}
+}
+
+// LatLong returns the latitude and longitude of the photo and
+// whether it was present.
+func (x *Exif) LatLong() (lat, long float64, err error) {
+	// All calls of x.Get might return an TagNotPresentError
+	longTag, err := x.Get(FieldName("GPSLongitude"))
+	if err != nil {
+		return
+	}
+	ewTag, err := x.Get(FieldName("GPSLongitudeRef"))
+	if err != nil {
+		return
+	}
+	latTag, err := x.Get(FieldName("GPSLatitude"))
+	if err != nil {
+		return
+	}
+	nsTag, err := x.Get(FieldName("GPSLatitudeRef"))
+	if err != nil {
+		return
+	}
+	if long, err = tagDegrees(longTag); err != nil {
+		return 0, 0, fmt.Errorf("Cannot parse longitude: %v", err)
+	}
+	if lat, err = tagDegrees(latTag); err != nil {
+		return 0, 0, fmt.Errorf("Cannot parse latitude: %v", err)
+	}
+	ew, err := ewTag.StringVal()
+	if err == nil && ew == "W" {
+		long *= -1.0
+	} else if err != nil {
+		return 0, 0, fmt.Errorf("Cannot parse longitude: %v", err)
+	}
+	ns, err := nsTag.StringVal()
+	if err == nil && ns == "S" {
+		lat *= -1.0
+	} else if err != nil {
+		return 0, 0, fmt.Errorf("Cannot parse longitude: %v", err)
+	}
+	return lat, long, nil
+}
+
+// String returns a pretty text representation of the decoded exif data.
+func (x *Exif) String() string {
+	var buf bytes.Buffer
+	for name, tag := range x.main {
+		fmt.Fprintf(&buf, "%s: %s\n", name, tag)
+	}
+	return buf.String()
+}
+
+// JpegThumbnail returns the jpeg thumbnail if it exists. If it doesn't exist,
+// TagNotPresentError will be returned
+func (x *Exif) JpegThumbnail() ([]byte, error) {
+	offset, err := x.Get(ThumbJPEGInterchangeFormat)
+	if err != nil {
+		return nil, err
+	}
+	start, err := offset.Int(0)
+	if err != nil {
+		return nil, err
+	}
+
+	length, err := x.Get(ThumbJPEGInterchangeFormatLength)
+	if err != nil {
+		return nil, err
+	}
+	l, err := length.Int(0)
+	if err != nil {
+		return nil, err
+	}
+
+	return x.Raw[start : start+l], nil
+}
+
+// MarshalJson implements the encoding/json.Marshaler interface providing output of
+// all EXIF fields present (names and values).
+func (x Exif) MarshalJSON() ([]byte, error) {
+	return json.Marshal(x.main)
+}
+
+type appSec struct {
+	marker byte
+	data   []byte
+}
+
+// newAppSec finds marker in r and returns the corresponding application data
+// section.
+func newAppSec(marker byte, r io.Reader) (*appSec, error) {
+	br := bufio.NewReader(r)
+	app := &appSec{marker: marker}
+	var dataLen int
+
+	// seek to marker
+	for dataLen == 0 {
+		if _, err := br.ReadBytes(0xFF); err != nil {
+			return nil, err
+		}
+		c, err := br.ReadByte()
+		if err != nil {
+			return nil, err
+		} else if c != marker {
+			continue
+		}
+
+		dataLenBytes := make([]byte, 2)
+		for k,_ := range dataLenBytes {
+			c, err := br.ReadByte()
+			if err != nil {
+				return nil, err
+			}
+			dataLenBytes[k] = c
+		}
+		dataLen = int(binary.BigEndian.Uint16(dataLenBytes)) - 2
+	}
+
+	// read section data
+	nread := 0
+	for nread < dataLen {
+		s := make([]byte, dataLen-nread)
+		n, err := br.Read(s)
+		nread += n
+		if err != nil && nread < dataLen {
+			return nil, err
+		}
+		app.data = append(app.data, s[:n]...)
+	}
+	return app, nil
+}
+
+// reader returns a reader on this appSec.
+func (app *appSec) reader() *bytes.Reader {
+	return bytes.NewReader(app.data)
+}
+
+// exifReader returns a reader on this appSec with the read cursor advanced to
+// the start of the exif's tiff encoded portion.
+func (app *appSec) exifReader() (*bytes.Reader, error) {
+	if len(app.data) < 6 {
+		return nil, errors.New("exif: failed to find exif intro marker")
+	}
+
+	// read/check for exif special mark
+	exif := app.data[:6]
+	if !bytes.Equal(exif, append([]byte("Exif"), 0x00, 0x00)) {
+		return nil, errors.New("exif: failed to find exif intro marker")
+	}
+	return bytes.NewReader(app.data[6:]), nil
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif_test.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif_test.go
new file mode 100644
index 000000000..c53f1ddda
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/exif_test.go
@@ -0,0 +1,202 @@
+package exif
+
+//go:generate go run regen_regress.go -- regress_expected_test.go
+//go:generate go fmt regress_expected_test.go
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/rwcarlsen/goexif/tiff"
+)
+
+var dataDir = flag.String("test_data_dir", ".", "Directory where the data files for testing are located")
+
+func TestDecode(t *testing.T) {
+	fpath := filepath.Join(*dataDir, "samples")
+	f, err := os.Open(fpath)
+	if err != nil {
+		t.Fatalf("Could not open sample directory '%s': %v", fpath, err)
+	}
+
+	names, err := f.Readdirnames(0)
+	if err != nil {
+		t.Fatalf("Could not read sample directory '%s': %v", fpath, err)
+	}
+
+	cnt := 0
+	for _, name := range names {
+		if !strings.HasSuffix(name, ".jpg") {
+			t.Logf("skipping non .jpg file %v", name)
+			continue
+		}
+		t.Logf("testing file %v", name)
+		f, err := os.Open(filepath.Join(fpath, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		x, err := Decode(f)
+		if err != nil {
+			t.Fatal(err)
+		} else if x == nil {
+			t.Fatalf("No error and yet %v was not decoded", name)
+		}
+
+		t.Logf("checking pic %v", name)
+		x.Walk(&walker{name, t})
+		cnt++
+	}
+	if cnt != len(regressExpected) {
+		t.Errorf("Did not process enough samples, got %d, want %d", cnt, len(regressExpected))
+	}
+}
+
+type walker struct {
+	picName string
+	t       *testing.T
+}
+
+func (w *walker) Walk(field FieldName, tag *tiff.Tag) error {
+	// this needs to be commented out when regenerating regress expected vals
+	pic := regressExpected[w.picName]
+	if pic == nil {
+		w.t.Errorf("   regression data not found")
+		return nil
+	}
+
+	exp, ok := pic[field]
+	if !ok {
+		w.t.Errorf("   regression data does not have field %v", field)
+		return nil
+	}
+
+	s := tag.String()
+	if tag.Count == 1 && s != "\"\"" {
+		s = fmt.Sprintf("[%s]", s)
+	}
+	got := tag.String()
+
+	if exp != got {
+		fmt.Println("s: ", s)
+		fmt.Printf("len(s)=%v\n", len(s))
+		w.t.Errorf("   field %v bad tag: expected '%s', got '%s'", field, exp, got)
+	}
+	return nil
+}
+
+func TestMarshal(t *testing.T) {
+	name := filepath.Join(*dataDir, "sample1.jpg")
+	f, err := os.Open(name)
+	if err != nil {
+		t.Fatalf("%v\n", err)
+	}
+	defer f.Close()
+
+	x, err := Decode(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if x == nil {
+		t.Fatal("bad err")
+	}
+
+	b, err := x.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Logf("%s", b)
+}
+
+func testSingleParseDegreesString(t *testing.T, s string, w float64) {
+	g, err := parseTagDegreesString(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if math.Abs(w-g) > 1e-10 {
+		t.Errorf("Wrong parsing result %s: Want %.12f, got %.12f", s, w, g)
+	}
+}
+
+func TestParseTagDegreesString(t *testing.T) {
+	// semicolon as decimal mark
+	testSingleParseDegreesString(t, "52,00000,50,00000,34,01180", 52.842781055556) // comma as separator
+	testSingleParseDegreesString(t, "52,00000;50,00000;34,01180", 52.842781055556) // semicolon as separator
+
+	// point as decimal mark
+	testSingleParseDegreesString(t, "14.00000,44.00000,34.01180", 14.742781055556) // comma as separator
+	testSingleParseDegreesString(t, "14.00000;44.00000;34.01180", 14.742781055556) // semicolon as separator
+	testSingleParseDegreesString(t, "14.00000;44.00000,34.01180", 14.742781055556) // mixed separators
+
+	testSingleParseDegreesString(t, "-008.0,30.0,03.6", -8.501) // leading zeros
+
+	// no decimal places
+	testSingleParseDegreesString(t, "-10,15,54", -10.265)
+	testSingleParseDegreesString(t, "-10;15;54", -10.265)
+
+	// incorrect mix of comma and point as decimal mark
+	s := "-17,00000,15.00000,04.80000"
+	if _, err := parseTagDegreesString(s); err == nil {
+		t.Error("parseTagDegreesString: false positive for " + s)
+	}
+}
+
+// Make sure we error out early when a tag had a count of MaxUint32
+func TestMaxUint32CountError(t *testing.T) {
+	name := filepath.Join(*dataDir, "corrupt/max_uint32_exif.jpg")
+	f, err := os.Open(name)
+	if err != nil {
+		t.Fatalf("%v\n", err)
+	}
+	defer f.Close()
+
+	_, err = Decode(f)
+	if err == nil {
+		t.Fatal("no error on bad exif data")
+	}
+	if !strings.Contains(err.Error(), "invalid Count offset") {
+		t.Fatal("wrong error:", err.Error())
+	}
+}
+
+// Make sure we error out early with tag data sizes larger than the image file
+func TestHugeTagError(t *testing.T) {
+	name := filepath.Join(*dataDir, "corrupt/huge_tag_exif.jpg")
+	f, err := os.Open(name)
+	if err != nil {
+		t.Fatalf("%v\n", err)
+	}
+	defer f.Close()
+
+	_, err = Decode(f)
+	if err == nil {
+		t.Fatal("no error on bad exif data")
+	}
+	if !strings.Contains(err.Error(), "short read") {
+		t.Fatal("wrong error:", err.Error())
+	}
+}
+
+// Check for a 0-length tag value
+func TestZeroLengthTagError(t *testing.T) {
+	name := filepath.Join(*dataDir, "corrupt/infinite_loop_exif.jpg")
+	f, err := os.Open(name)
+	if err != nil {
+		t.Fatalf("%v\n", err)
+	}
+	defer f.Close()
+
+	_, err = Decode(f)
+	if err == nil {
+		t.Fatal("no error on bad exif data")
+	}
+	if !strings.Contains(err.Error(), "zero length tag value") {
+		t.Fatal("wrong error:", err.Error())
+	}
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/fields.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/fields.go
new file mode 100644
index 000000000..0388d2390
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/fields.go
@@ -0,0 +1,293 @@
+package exif
+
+type FieldName string
+
+// UnknownPrefix is used as the first part of field names for decoded tags for
+// which there is no known/supported EXIF field.
+const UnknownPrefix = "UnknownTag_"
+
+// Primary EXIF fields
+const (
+	ImageWidth                 FieldName = "ImageWidth"
+	ImageLength                          = "ImageLength" // Image height called Length by EXIF spec
+	BitsPerSample                        = "BitsPerSample"
+	Compression                          = "Compression"
+	PhotometricInterpretation            = "PhotometricInterpretation"
+	Orientation                          = "Orientation"
+	SamplesPerPixel                      = "SamplesPerPixel"
+	PlanarConfiguration                  = "PlanarConfiguration"
+	YCbCrSubSampling                     = "YCbCrSubSampling"
+	YCbCrPositioning                     = "YCbCrPositioning"
+	XResolution                          = "XResolution"
+	YResolution                          = "YResolution"
+	ResolutionUnit                       = "ResolutionUnit"
+	DateTime                             = "DateTime"
+	ImageDescription                     = "ImageDescription"
+	Make                                 = "Make"
+	Model                                = "Model"
+	Software                             = "Software"
+	Artist                               = "Artist"
+	Copyright                            = "Copyright"
+	ExifIFDPointer                       = "ExifIFDPointer"
+	GPSInfoIFDPointer                    = "GPSInfoIFDPointer"
+	InteroperabilityIFDPointer           = "InteroperabilityIFDPointer"
+	ExifVersion                          = "ExifVersion"
+	FlashpixVersion                      = "FlashpixVersion"
+	ColorSpace                           = "ColorSpace"
+	ComponentsConfiguration              = "ComponentsConfiguration"
+	CompressedBitsPerPixel               = "CompressedBitsPerPixel"
+	PixelXDimension                      = "PixelXDimension"
+	PixelYDimension                      = "PixelYDimension"
+	MakerNote                            = "MakerNote"
+	UserComment                          = "UserComment"
+	RelatedSoundFile                     = "RelatedSoundFile"
+	DateTimeOriginal                     = "DateTimeOriginal"
+	DateTimeDigitized                    = "DateTimeDigitized"
+	SubSecTime                           = "SubSecTime"
+	SubSecTimeOriginal                   = "SubSecTimeOriginal"
+	SubSecTimeDigitized                  = "SubSecTimeDigitized"
+	ImageUniqueID                        = "ImageUniqueID"
+	ExposureTime                         = "ExposureTime"
+	FNumber                              = "FNumber"
+	ExposureProgram                      = "ExposureProgram"
+	SpectralSensitivity                  = "SpectralSensitivity"
+	ISOSpeedRatings                      = "ISOSpeedRatings"
+	OECF                                 = "OECF"
+	ShutterSpeedValue                    = "ShutterSpeedValue"
+	ApertureValue                        = "ApertureValue"
+	BrightnessValue                      = "BrightnessValue"
+	ExposureBiasValue                    = "ExposureBiasValue"
+	MaxApertureValue                     = "MaxApertureValue"
+	SubjectDistance                      = "SubjectDistance"
+	MeteringMode                         = "MeteringMode"
+	LightSource                          = "LightSource"
+	Flash                                = "Flash"
+	FocalLength                          = "FocalLength"
+	SubjectArea                          = "SubjectArea"
+	FlashEnergy                          = "FlashEnergy"
+	SpatialFrequencyResponse             = "SpatialFrequencyResponse"
+	FocalPlaneXResolution                = "FocalPlaneXResolution"
+	FocalPlaneYResolution                = "FocalPlaneYResolution"
+	FocalPlaneResolutionUnit             = "FocalPlaneResolutionUnit"
+	SubjectLocation                      = "SubjectLocation"
+	ExposureIndex                        = "ExposureIndex"
+	SensingMethod                        = "SensingMethod"
+	FileSource                           = "FileSource"
+	SceneType                            = "SceneType"
+	CFAPattern                           = "CFAPattern"
+	CustomRendered                       = "CustomRendered"
+	ExposureMode                         = "ExposureMode"
+	WhiteBalance                         = "WhiteBalance"
+	DigitalZoomRatio                     = "DigitalZoomRatio"
+	FocalLengthIn35mmFilm                = "FocalLengthIn35mmFilm"
+	SceneCaptureType                     = "SceneCaptureType"
+	GainControl                          = "GainControl"
+	Contrast                             = "Contrast"
+	Saturation                           = "Saturation"
+	Sharpness                            = "Sharpness"
+	DeviceSettingDescription             = "DeviceSettingDescription"
+	SubjectDistanceRange                 = "SubjectDistanceRange"
+	LensMake                             = "LensMake"
+	LensModel                            = "LensModel"
+)
+
+// thumbnail fields
+const (
+	ThumbJPEGInterchangeFormat       = "ThumbJPEGInterchangeFormat"       // offset to thumb jpeg SOI
+	ThumbJPEGInterchangeFormatLength = "ThumbJPEGInterchangeFormatLength" // byte length of thumb
+)
+
+// GPS fields
+const (
+	GPSVersionID        FieldName = "GPSVersionID"
+	GPSLatitudeRef                = "GPSLatitudeRef"
+	GPSLatitude                   = "GPSLatitude"
+	GPSLongitudeRef               = "GPSLongitudeRef"
+	GPSLongitude                  = "GPSLongitude"
+	GPSAltitudeRef                = "GPSAltitudeRef"
+	GPSAltitude                   = "GPSAltitude"
+	GPSTimeStamp                  = "GPSTimeStamp"
+	GPSSatelites                  = "GPSSatelites"
+	GPSStatus                     = "GPSStatus"
+	GPSMeasureMode                = "GPSMeasureMode"
+	GPSDOP                        = "GPSDOP"
+	GPSSpeedRef                   = "GPSSpeedRef"
+	GPSSpeed                      = "GPSSpeed"
+	GPSTrackRef                   = "GPSTrackRef"
+	GPSTrack                      = "GPSTrack"
+	GPSImgDirectionRef            = "GPSImgDirectionRef"
+	GPSImgDirection               = "GPSImgDirection"
+	GPSMapDatum                   = "GPSMapDatum"
+	GPSDestLatitudeRef            = "GPSDestLatitudeRef"
+	GPSDestLatitude               = "GPSDestLatitude"
+	GPSDestLongitudeRef           = "GPSDestLongitudeRef"
+	GPSDestLongitude              = "GPSDestLongitude"
+	GPSDestBearingRef             = "GPSDestBearingRef"
+	GPSDestBearing                = "GPSDestBearing"
+	GPSDestDistanceRef            = "GPSDestDistanceRef"
+	GPSDestDistance               = "GPSDestDistance"
+	GPSProcessingMethod           = "GPSProcessingMethod"
+	GPSAreaInformation            = "GPSAreaInformation"
+	GPSDateStamp                  = "GPSDateStamp"
+	GPSDifferential               = "GPSDifferential"
+)
+
+// interoperability fields
+const (
+	InteroperabilityIndex FieldName = "InteroperabilityIndex"
+)
+
+var exifFields = map[uint16]FieldName{
+	/////////////////////////////////////
+	////////// IFD 0 ////////////////////
+	/////////////////////////////////////
+
+	// image data structure for the thumbnail
+	0x0100: ImageWidth,
+	0x0101: ImageLength,
+	0x0102: BitsPerSample,
+	0x0103: Compression,
+	0x0106: PhotometricInterpretation,
+	0x0112: Orientation,
+	0x0115: SamplesPerPixel,
+	0x011C: PlanarConfiguration,
+	0x0212: YCbCrSubSampling,
+	0x0213: YCbCrPositioning,
+	0x011A: XResolution,
+	0x011B: YResolution,
+	0x0128: ResolutionUnit,
+
+	// Other tags
+	0x0132: DateTime,
+	0x010E: ImageDescription,
+	0x010F: Make,
+	0x0110: Model,
+	0x0131: Software,
+	0x013B: Artist,
+	0x8298: Copyright,
+
+	// private tags
+	exifPointer: ExifIFDPointer,
+
+	/////////////////////////////////////
+	////////// Exif sub IFD /////////////
+	/////////////////////////////////////
+
+	gpsPointer:     GPSInfoIFDPointer,
+	interopPointer: InteroperabilityIFDPointer,
+
+	0x9000: ExifVersion,
+	0xA000: FlashpixVersion,
+
+	0xA001: ColorSpace,
+
+	0x9101: ComponentsConfiguration,
+	0x9102: CompressedBitsPerPixel,
+	0xA002: PixelXDimension,
+	0xA003: PixelYDimension,
+
+	0x927C: MakerNote,
+	0x9286: UserComment,
+
+	0xA004: RelatedSoundFile,
+	0x9003: DateTimeOriginal,
+	0x9004: DateTimeDigitized,
+	0x9290: SubSecTime,
+	0x9291: SubSecTimeOriginal,
+	0x9292: SubSecTimeDigitized,
+
+	0xA420: ImageUniqueID,
+
+	// picture conditions
+	0x829A: ExposureTime,
+	0x829D: FNumber,
+	0x8822: ExposureProgram,
+	0x8824: SpectralSensitivity,
+	0x8827: ISOSpeedRatings,
+	0x8828: OECF,
+	0x9201: ShutterSpeedValue,
+	0x9202: ApertureValue,
+	0x9203: BrightnessValue,
+	0x9204: ExposureBiasValue,
+	0x9205: MaxApertureValue,
+	0x9206: SubjectDistance,
+	0x9207: MeteringMode,
+	0x9208: LightSource,
+	0x9209: Flash,
+	0x920A: FocalLength,
+	0x9214: SubjectArea,
+	0xA20B: FlashEnergy,
+	0xA20C: SpatialFrequencyResponse,
+	0xA20E: FocalPlaneXResolution,
+	0xA20F: FocalPlaneYResolution,
+	0xA210: FocalPlaneResolutionUnit,
+	0xA214: SubjectLocation,
+	0xA215: ExposureIndex,
+	0xA217: SensingMethod,
+	0xA300: FileSource,
+	0xA301: SceneType,
+	0xA302: CFAPattern,
+	0xA401: CustomRendered,
+	0xA402: ExposureMode,
+	0xA403: WhiteBalance,
+	0xA404: DigitalZoomRatio,
+	0xA405: FocalLengthIn35mmFilm,
+	0xA406: SceneCaptureType,
+	0xA407: GainControl,
+	0xA408: Contrast,
+	0xA409: Saturation,
+	0xA40A: Sharpness,
+	0xA40B: DeviceSettingDescription,
+	0xA40C: SubjectDistanceRange,
+	0xA433: LensMake,
+	0xA434: LensModel,
+}
+
+var gpsFields = map[uint16]FieldName{
+	/////////////////////////////////////
+	//// GPS sub-IFD ////////////////////
+	/////////////////////////////////////
+	0x0:  GPSVersionID,
+	0x1:  GPSLatitudeRef,
+	0x2:  GPSLatitude,
+	0x3:  GPSLongitudeRef,
+	0x4:  GPSLongitude,
+	0x5:  GPSAltitudeRef,
+	0x6:  GPSAltitude,
+	0x7:  GPSTimeStamp,
+	0x8:  GPSSatelites,
+	0x9:  GPSStatus,
+	0xA:  GPSMeasureMode,
+	0xB:  GPSDOP,
+	0xC:  GPSSpeedRef,
+	0xD:  GPSSpeed,
+	0xE:  GPSTrackRef,
+	0xF:  GPSTrack,
+	0x10: GPSImgDirectionRef,
+	0x11: GPSImgDirection,
+	0x12: GPSMapDatum,
+	0x13: GPSDestLatitudeRef,
+	0x14: GPSDestLatitude,
+	0x15: GPSDestLongitudeRef,
+	0x16: GPSDestLongitude,
+	0x17: GPSDestBearingRef,
+	0x18: GPSDestBearing,
+	0x19: GPSDestDistanceRef,
+	0x1A: GPSDestDistance,
+	0x1B: GPSProcessingMethod,
+	0x1C: GPSAreaInformation,
+	0x1D: GPSDateStamp,
+	0x1E: GPSDifferential,
+}
+
+var interopFields = map[uint16]FieldName{
+	/////////////////////////////////////
+	//// Interoperability sub-IFD ///////
+	/////////////////////////////////////
+	0x1: InteroperabilityIndex,
+}
+
+var thumbnailFields = map[uint16]FieldName{
+	0x0201: ThumbJPEGInterchangeFormat,
+	0x0202: ThumbJPEGInterchangeFormatLength,
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regen_regress.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regen_regress.go
new file mode 100644
index 000000000..17bac5287
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regen_regress.go
@@ -0,0 +1,79 @@
+// +build ignore
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/rwcarlsen/goexif/exif"
+	"github.com/rwcarlsen/goexif/tiff"
+)
+
+func main() {
+	flag.Parse()
+	fname := flag.Arg(0)
+
+	dst, err := os.Create(fname)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer dst.Close()
+
+	dir, err := os.Open("samples")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer dir.Close()
+
+	names, err := dir.Readdirnames(0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	for i, name := range names {
+		names[i] = filepath.Join("samples", name)
+	}
+	makeExpected(names, dst)
+}
+
+func makeExpected(files []string, w io.Writer) {
+	fmt.Fprintf(w, "package exif\n\n")
+	fmt.Fprintf(w, "var regressExpected = map[string]map[FieldName]string{\n")
+
+	for _, name := range files {
+		f, err := os.Open(name)
+		if err != nil {
+			continue
+		}
+
+		x, err := exif.Decode(f)
+		if err != nil {
+			f.Close()
+			continue
+		}
+
+		fmt.Fprintf(w, "\"%v\": map[FieldName]string{\n", filepath.Base(name))
+		x.Walk(&regresswalk{w})
+		fmt.Fprintf(w, "},\n")
+		f.Close()
+	}
+	fmt.Fprintf(w, "}")
+}
+
+type regresswalk struct {
+	wr io.Writer
+}
+
+func (w *regresswalk) Walk(name exif.FieldName, tag *tiff.Tag) error {
+	if strings.HasPrefix(string(name), exif.UnknownPrefix) {
+		fmt.Fprintf(w.wr, "\"%v\": `%v`,\n", name, tag.String())
+	} else {
+		fmt.Fprintf(w.wr, "%v: `%v`,\n", name, tag.String())
+	}
+	return nil
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regress_expected_test.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regress_expected_test.go
new file mode 100644
index 000000000..bf3998189
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/exif/regress_expected_test.go
@@ -0,0 +1,2293 @@
+package exif
+
+var regressExpected = map[string]map[FieldName]string{
+	"2004-01-11-22-45-15-sep-2004-01-11-22-45-15a.jpg": map[FieldName]string{
+		PixelXDimension:            `1600`,
+		InteroperabilityIFDPointer: `1009`,
+		SceneType:                  `""`,
+		InteroperabilityIndex:      `"R98"`,
+		Make:                       `"Samsung Techwin"`,
+		DateTimeOriginal:           `"2004:01:11 22:45:15"`,
+		DateTimeDigitized:          `"2004:01:11 22:45:15"`,
+		ImageDescription:           `"SAMSUNG DIGITAL CAMERA         "`,
+		ExifVersion:                `"0220"`,
+		MeteringMode:               `2`,
+		Flash:                      `1`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		FlashpixVersion:            `"0100"`,
+		YResolution:                `"72/1"`,
+		ThumbJPEGInterchangeFormat: `1039`,
+		MaxApertureValue:           `"32/10"`,
+		ExposureProgram:            `2`,
+		Software:                   `"M5011S-1031"`,
+		DateTime:                   `"2004:01:11 22:45:19"`,
+		FNumber:                    `"320/100"`,
+		ISOSpeedRatings:            `150`,
+		ComponentsConfiguration:    `""`,
+		CompressedBitsPerPixel:     `"2/1"`,
+		RelatedSoundFile:           `""`,
+		XResolution:                `"72/1"`,
+		ExifIFDPointer:             `251`,
+		ExposureTime:               `"1000/30000"`,
+		LightSource:                `0`,
+		FocalLength:                `"82/11"`,
+		ColorSpace:                 `1`,
+		PixelYDimension:            `1200`,
+		FileSource:                 `""`,
+		Model:                      `"U-CA 501"`,
+		ThumbJPEGInterchangeFormatLength: `3530`,
+		ExposureBiasValue:                `"95/10"`,
+	},
+	"2006-08-03-16-29-38-sep-2006-08-03-16-29-38a.jpg": map[FieldName]string{
+		ThumbJPEGInterchangeFormat:       `5108`,
+		ThumbJPEGInterchangeFormatLength: `4323`,
+		MaxApertureValue:                 `"95/32"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `196`,
+		ExposureTime:                     `"1/1500"`,
+		InteroperabilityIndex:            `"R98"`,
+		FocalPlaneXResolution:            `"2816000/225"`,
+		YResolution:                      `"180/1"`,
+		DateTime:                         `"2006:08:03 16:29:38"`,
+		ShutterSpeedValue:                `"338/32"`,
+		ApertureValue:                    `"95/32"`,
+		FocalLength:                      `"5800/1000"`,
+		FlashpixVersion:                  `"0100"`,
+		Make:                             `"Canon"`,
+		DateTimeOriginal:                 `"2006:08:03 16:29:38"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `2824`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		FNumber:                          `"28/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		SensingMethod:                    `2`,
+		DateTimeDigitized:                `"2006:08:03 16:29:38"`,
+		CompressedBitsPerPixel:           `"5/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		UserComment:                      `""`,
+		PixelXDimension:                  `2816`,
+		Model:                            `"Canon PowerShot SD600"`,
+		ExposureBiasValue:                `"0/3"`,
+		PixelYDimension:                  `2112`,
+		FocalPlaneResolutionUnit:         `2`,
+		DigitalZoomRatio:                 `"2816/2816"`,
+		Orientation:                      `6`,
+		XResolution:                      `"180/1"`,
+		ExifVersion:                      `"0220"`,
+		Flash:                            `24`,
+		FocalPlaneYResolution: `"2112000/169"`,
+		CustomRendered:        `0`,
+	},
+	"2006-11-11-19-17-56-sep-2006-11-11-19-17-56a.jpg": map[FieldName]string{
+		FNumber:                 `"28/10"`,
+		ExposureProgram:         `2`,
+		Software:                `"E3200v1.1"`,
+		DateTime:                `"2006:11:11 19:17:56"`,
+		ExposureTime:            `"10/601"`,
+		ISOSpeedRatings:         `50`,
+		ComponentsConfiguration: `""`,
+		CompressedBitsPerPixel:  `"4/1"`,
+		Saturation:              `0`,
+		XResolution:             `"300/1"`,
+		ExifIFDPointer:          `284`,
+		ExposureBiasValue:       `"0/10"`,
+		LightSource:             `0`,
+		FocalLength:             `"58/10"`,
+		ColorSpace:              `1`,
+		PixelYDimension:         `1536`,
+		FileSource:              `""`,
+		Model:                   `"E3200"`,
+		ThumbJPEGInterchangeFormatLength: `4546`,
+		DateTimeDigitized:                `"2006:11:11 19:17:56"`,
+		PixelXDimension:                  `2048`,
+		InteroperabilityIFDPointer:       `1026`,
+		SceneType:                        `""`,
+		DigitalZoomRatio:                 `"0/100"`,
+		GainControl:                      `0`,
+		Make:                             `"NIKON"`,
+		DateTimeOriginal:                 `"2006:11:11 19:17:56"`,
+		InteroperabilityIndex:            `"R98"`,
+		ImageDescription:                 `"          "`,
+		Sharpness:                        `0`,
+		YCbCrPositioning:                 `2`,
+		ExifVersion:                      `"0220"`,
+		MeteringMode:                     `5`,
+		Flash:                            `25`,
+		FocalLengthIn35mmFilm:      `38`,
+		SubjectDistanceRange:       `0`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		MaxApertureValue:           `"30/10"`,
+		FlashpixVersion:            `"0100"`,
+		WhiteBalance:               `0`,
+		YResolution:                `"300/1"`,
+		ThumbJPEGInterchangeFormat: `4596`,
+		CustomRendered:             `1`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		Contrast:                   `0`,
+		MakerNote:                  `""`,
+		UserComment:                `"                                                                                                                     "`,
+	},
+	"2006-12-10-23-58-20-sep-2006-12-10-23-58-20a.jpg": map[FieldName]string{
+		Model:                    `"Canon PowerShot A80"`,
+		ExposureBiasValue:        `"0/3"`,
+		PixelYDimension:          `1704`,
+		FocalPlaneResolutionUnit: `2`,
+		FocalPlaneYResolution:    `"1704000/210"`,
+		CustomRendered:           `0`,
+		DigitalZoomRatio:         `"2272/2272"`,
+		Orientation:              `1`,
+		XResolution:              `"180/1"`,
+		ExifVersion:              `"0220"`,
+		Flash:                    `24`,
+		ThumbJPEGInterchangeFormat:       `2036`,
+		ThumbJPEGInterchangeFormatLength: `6465`,
+		MaxApertureValue:                 `"95/32"`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `196`,
+		ExposureTime:                     `"1/80"`,
+		FocalLength:                      `"250/32"`,
+		FlashpixVersion:                  `"0100"`,
+		FocalPlaneXResolution:            `"2272000/280"`,
+		YResolution:                      `"180/1"`,
+		DateTime:                         `"2006:12:10 23:58:20"`,
+		ShutterSpeedValue:                `"202/32"`,
+		ApertureValue:                    `"95/32"`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		Make:                             `"Canon"`,
+		DateTimeOriginal:                 `"2006:12:10 23:58:20"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `1844`,
+		FNumber:                          `"28/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		UserComment:                      `""`,
+		PixelXDimension:                  `2272`,
+		SensingMethod:                    `2`,
+		DateTimeDigitized:                `"2006:12:10 23:58:20"`,
+		CompressedBitsPerPixel:           `"3/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+	},
+	"2006-12-17-07-09-14-sep-2006-12-17-07-09-14a.jpg": map[FieldName]string{
+		WhiteBalance:                     `0`,
+		YResolution:                      `"72/1"`,
+		ThumbJPEGInterchangeFormatLength: `7063`,
+		ExposureBiasValue:                `"0/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1536`,
+		ExposureMode:                     `0`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:                       `"PENTAX Corporation"`,
+		DateTimeDigitized:          `"2006:12:17 07:09:14"`,
+		PixelXDimension:            `2048`,
+		InteroperabilityIFDPointer: `31048`,
+		CustomRendered:             `0`,
+		DateTime:                   `"2006:12:17 07:09:14"`,
+		ExposureProgram:            `2`,
+		FocalLengthIn35mmFilm:      `38`,
+		Saturation:                 `0`,
+		XResolution:                `"72/1"`,
+		ISOSpeedRatings:            `64`,
+		ExifVersion:                `"0220"`,
+		CompressedBitsPerPixel:     `"5725504/3145728"`,
+		Flash: `24`,
+		Model: `"PENTAX Optio S6"`,
+		ThumbJPEGInterchangeFormat: `31172`,
+		MaxApertureValue:           `"27/10"`,
+		FocalLength:                `"62/10"`,
+		ColorSpace:                 `1`,
+		DateTimeOriginal:           `"2006:12:17 07:09:14"`,
+		MakerNote:                  `""`,
+		DigitalZoomRatio:           `"100/100"`,
+		SceneCaptureType:           `0`,
+		Contrast:                   `0`,
+		Software:                   `"Optio S6 Ver 1.00"`,
+		FNumber:                    `"270/100"`,
+		Sharpness:                  `0`,
+		ComponentsConfiguration:    `""`,
+		MeteringMode:               `5`,
+		SubjectDistanceRange:       `2`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		ExifIFDPointer:             `586`,
+		ExposureTime:               `"1/160"`,
+	},
+	"2006-12-21-15-55-26-sep-2006-12-21-15-55-26a.jpg": map[FieldName]string{
+		DateTimeDigitized:                `"2006:12:21 15:55:26"`,
+		CompressedBitsPerPixel:           `"8/1"`,
+		MeteringMode:                     `3`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `2592`,
+		Saturation:                       `0`,
+		ImageDescription:                 `"                               "`,
+		Model:                            `"DSC-W15"`,
+		ExposureBiasValue:                `"-20/10"`,
+		PixelYDimension:                  `1944`,
+		Orientation:                      `1`,
+		XResolution:                      `"72/1"`,
+		ISOSpeedRatings:                  `100`,
+		ExifVersion:                      `"0220"`,
+		Flash:                            `79`,
+		CustomRendered:                   `0`,
+		ThumbJPEGInterchangeFormat:       `2484`,
+		ThumbJPEGInterchangeFormatLength: `13571`,
+		ExposureProgram:                  `2`,
+		MaxApertureValue:                 `"48/16"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `256`,
+		ExposureTime:                     `"10/400"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		YResolution:                      `"72/1"`,
+		DateTime:                         `"2006:12:21 15:55:26"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"79/10"`,
+		FlashpixVersion:                  `"0100"`,
+		Contrast:                         `0`,
+		Make:                             `"SONY"`,
+		DateTimeOriginal:                 `"2006:12:21 15:55:26"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `2278`,
+		ExposureMode:                     `1`,
+		SceneCaptureType:                 `0`,
+		FNumber:                          `"28/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+	},
+	"2007-01-01-12-00-00-sep-2007-01-01-12-00-00a.jpg": map[FieldName]string{
+		MaxApertureValue:                 `"286/100"`,
+		ExposureIndex:                    `"200/1"`,
+		ThumbJPEGInterchangeFormat:       `13848`,
+		ThumbJPEGInterchangeFormatLength: `3436`,
+		ExposureProgram:                  `2`,
+		ExposureTime:                     `"8942/1000000"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `340`,
+		ApertureValue:                    `"286/100"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"60/10"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"480/1"`,
+		Software:                         `"KODAK EASYSHARE C713 ZOOM DIGITAL CAMERA"`,
+		ShutterSpeedValue:                `"680/100"`,
+		InteroperabilityIFDPointer:       `13816`,
+		ExposureMode:                     `0`,
+		FocalLengthIn35mmFilm:            `36`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		Make:                             `"EASTMAN KODAK COMPANY"`,
+		DateTimeOriginal:                 `"2007:01:01 12:00:00"`,
+		ComponentsConfiguration:          `""`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		FNumber:                          `"270/100"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		PixelXDimension:                  `1280`,
+		SensingMethod:                    `2`,
+		GainControl:                      `2`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+		DateTimeDigitized:                `"2007:01:01 12:00:00"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		Model:                            `"KODAK EASYSHARE C713 ZOOM DIGITAL CAMERA"`,
+		ExposureBiasValue:                `"0/10"`,
+		PixelYDimension:                  `960`,
+		ExifVersion:                      `"0221"`,
+		Flash:                            `25`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"0/10"`,
+		Orientation:                      `1`,
+		XResolution:                      `"480/1"`,
+		ISOSpeedRatings:                  `200`,
+	},
+	"2007-01-17-21-49-44-sep-2007-01-17-21-49-44a.jpg": map[FieldName]string{
+		XResolution:                      `"180/1"`,
+		ISOSpeedRatings:                  `50`,
+		ExifVersion:                      `"0220"`,
+		Flash:                            `24`,
+		CustomRendered:                   `0`,
+		Orientation:                      `1`,
+		ThumbJPEGInterchangeFormatLength: `7024`,
+		ExposureProgram:                  `2`,
+		MaxApertureValue:                 `"297/100"`,
+		ThumbJPEGInterchangeFormat:       `956`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `266`,
+		ExposureTime:                     `"1/30"`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		Software:                         `"1.00.018PR         "`,
+		DateTime:                         `"2007:01:17 21:49:44"`,
+		ShutterSpeedValue:                `"491/100"`,
+		ApertureValue:                    `"33/10"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"73/10"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"180/1"`,
+		DateTimeOriginal:                 `"2007:01:17 21:49:44"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `832`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		Make:                             `"Digital Camera                 "`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		FNumber:                          `"33/10"`,
+		MeteringMode:                     `2`,
+		MakerNote:                        `"6106789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456"`,
+		PixelXDimension:                  `2816`,
+		SensingMethod:                    `2`,
+		DateTimeDigitized:                `"2007:01:17 21:49:44"`,
+		Model:                            `"6MP-9Y8        "`,
+		ExposureBiasValue:                `"0/10"`,
+		PixelYDimension:                  `2112`,
+		ImageDescription:                 `"Digital image  "`,
+	},
+	"2007-02-02-18-13-29-sep-2007-02-02-18-13-29a.jpg": map[FieldName]string{
+		Software:                         `"Optio S5z Ver 1.00 "`,
+		FNumber:                          `"26/10"`,
+		Sharpness:                        `0`,
+		Orientation:                      `1`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `586`,
+		ExposureTime:                     `"1/60"`,
+		ComponentsConfiguration:          `""`,
+		MeteringMode:                     `5`,
+		SubjectDistanceRange:             `2`,
+		YResolution:                      `"72/1"`,
+		ThumbJPEGInterchangeFormatLength: `8800`,
+		ExposureBiasValue:                `"0/3"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1920`,
+		WhiteBalance:                     `0`,
+		Make:                             `"PENTAX Corporation "`,
+		DateTimeDigitized:                `"2007:02:02 18:13:29"`,
+		PixelXDimension:                  `2560`,
+		InteroperabilityIFDPointer:       `30974`,
+		CustomRendered:                   `0`,
+		ExposureMode:                     `0`,
+		InteroperabilityIndex:            `"R98"`,
+		DateTime:                         `"2007:02:02 18:13:29"`,
+		ExposureProgram:                  `2`,
+		XResolution:                      `"72/1"`,
+		ISOSpeedRatings:                  `200`,
+		ExifVersion:                      `"0220"`,
+		CompressedBitsPerPixel:           `"27033600/4915200"`,
+		Flash: `25`,
+		FocalLengthIn35mmFilm: `35`,
+		Saturation:            `0`,
+		Model:                 `"PENTAX Optio S5z "`,
+		ThumbJPEGInterchangeFormat: `31098`,
+		MaxApertureValue:           `"28/10"`,
+		FocalLength:                `"580/100"`,
+		ColorSpace:                 `1`,
+		DateTimeOriginal:           `"2007:02:02 18:13:29"`,
+		MakerNote:                  `""`,
+		DigitalZoomRatio:           `"0/0"`,
+		SceneCaptureType:           `0`,
+		Contrast:                   `0`,
+	},
+	"2007-05-02-17-02-21-sep-2007-05-02-17-02-21a.jpg": map[FieldName]string{
+		UserComment:              `""`,
+		PixelXDimension:          `1600`,
+		SensingMethod:            `2`,
+		DateTimeDigitized:        `"2007:05:02 17:02:21"`,
+		CompressedBitsPerPixel:   `"3/1"`,
+		MeteringMode:             `5`,
+		MakerNote:                `""`,
+		Model:                    `"Canon IXY DIGITAL 55"`,
+		ExposureBiasValue:        `"0/3"`,
+		PixelYDimension:          `1200`,
+		FocalPlaneResolutionUnit: `2`,
+		FocalPlaneYResolution:    `"1200000/168"`,
+		CustomRendered:           `0`,
+		DigitalZoomRatio:         `"2592/2592"`,
+		Orientation:              `1`,
+		XResolution:              `"180/1"`,
+		ExifVersion:              `"0220"`,
+		Flash:                    `9`,
+		ThumbJPEGInterchangeFormat:       `5108`,
+		ThumbJPEGInterchangeFormatLength: `6306`,
+		MaxApertureValue:                 `"107/32"`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `196`,
+		ExposureTime:                     `"1/60"`,
+		FocalLength:                      `"7109/1000"`,
+		FlashpixVersion:                  `"0100"`,
+		FocalPlaneXResolution:            `"1600000/225"`,
+		YResolution:                      `"180/1"`,
+		DateTime:                         `"2007:05:02 17:02:21"`,
+		ShutterSpeedValue:                `"189/32"`,
+		ApertureValue:                    `"107/32"`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		Make:                             `"Canon"`,
+		DateTimeOriginal:                 `"2007:05:02 17:02:21"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `2226`,
+		FNumber:                          `"32/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+	},
+	"2007-05-12-08-19-07-sep-2007-05-12-08-19-07a.jpg": map[FieldName]string{
+		Model:             `"EX-Z70     "`,
+		ExposureBiasValue: `"0/3"`,
+		PixelYDimension:   `480`,
+		CustomRendered:    `0`,
+		DigitalZoomRatio:  `"0/0"`,
+		Orientation:       `1`,
+		XResolution:       `"72/1"`,
+		ExifVersion:       `"0221"`,
+		Flash:             `16`,
+		ThumbJPEGInterchangeFormat:       `27422`,
+		ThumbJPEGInterchangeFormatLength: `8332`,
+		ExposureProgram:                  `2`,
+		MaxApertureValue:                 `"33/10"`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `282`,
+		ExposureTime:                     `"1/50"`,
+		FocalLength:                      `"630/100"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"72/1"`,
+		Software:                         `"1.00             "`,
+		DateTime:                         `"2007:06:17 22:56:38"`,
+		LightSource:                      `0`,
+		ExposureMode:                     `0`,
+		FocalLengthIn35mmFilm:            `38`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		Make:                             `"CASIO COMPUTER CO.,LTD."`,
+		DateTimeOriginal:                 `"2007:05:12 08:19:07"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `27298`,
+		Sharpness:                        `0`,
+		FNumber:                          `"31/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		PixelXDimension:                  `640`,
+		GainControl:                      `2`,
+		Saturation:                       `0`,
+		DateTimeDigitized:                `"2007:06:17 22:56:38"`,
+		CompressedBitsPerPixel:           `"252746/307200"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+	},
+	"2007-05-26-04-49-45-sep-2007-05-26-04-49-45a.jpg": map[FieldName]string{
+		ThumbJPEGInterchangeFormat:       `4596`,
+		ThumbJPEGInterchangeFormatLength: `10120`,
+		ExposureProgram:                  `2`,
+		MaxApertureValue:                 `"34/10"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `284`,
+		ExposureTime:                     `"10/3486"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		YResolution:                      `"300/1"`,
+		Software:                         `"COOLPIX L3v1.2"`,
+		DateTime:                         `"2007:05:26 04:49:45"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"63/10"`,
+		FlashpixVersion:                  `"0100"`,
+		Contrast:                         `0`,
+		Make:                             `"NIKON"`,
+		DateTimeOriginal:                 `"2007:05:26 04:49:45"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `1026`,
+		ExposureMode:                     `0`,
+		FocalLengthIn35mmFilm:            `38`,
+		SceneCaptureType:                 `2`,
+		FNumber:                          `"32/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		Saturation:                       `0`,
+		DateTimeDigitized:                `"2007:05:26 04:49:45"`,
+		CompressedBitsPerPixel:           `"4/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		UserComment:                      `"                                                                                                                     "`,
+		PixelXDimension:                  `2592`,
+		GainControl:                      `0`,
+		SubjectDistanceRange:             `0`,
+		ImageDescription:                 `"          "`,
+		Model:                            `"COOLPIX L3"`,
+		ExposureBiasValue:                `"0/10"`,
+		PixelYDimension:                  `1944`,
+		Orientation:                      `1`,
+		XResolution:                      `"300/1"`,
+		ISOSpeedRatings:                  `50`,
+		ExifVersion:                      `"0220"`,
+		Flash:                            `24`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"0/100"`,
+	},
+	"2007-05-30-14-28-01-sep-2007-05-30-14-28-01a.jpg": map[FieldName]string{
+		CompressedBitsPerPixel:           `"2/1"`,
+		MeteringMode:                     `5`,
+		UserComment:                      `"                                                                                                                     "`,
+		GainControl:                      `1`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+		ExifIFDPointer:                   `284`,
+		ExposureTime:                     `"10/40"`,
+		InteroperabilityIndex:            `"R98"`,
+		Software:                         `"COOLPIX S6V1.0"`,
+		ImageDescription:                 `"          "`,
+		Model:                            `"COOLPIX S6"`,
+		XResolution:                      `"300/1"`,
+		ISOSpeedRatings:                  `53`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `1026`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"0/100"`,
+		Make:                             `"NIKON"`,
+		Orientation:                      `1`,
+		Contrast:                         `0`,
+		FocalLengthIn35mmFilm:            `35`,
+		SceneCaptureType:                 `0`,
+		FileSource:                       `""`,
+		FNumber:                          `"30/10"`,
+		ExposureProgram:                  `2`,
+		DateTimeDigitized:                `"2007:05:30 14:28:01"`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `2816`,
+		SceneType:                        `""`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExposureBiasValue:                `"0/10"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"58/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `2112`,
+		YResolution:                      `"300/1"`,
+		DateTime:                         `"2007:05:30 14:28:01"`,
+		Flash:                            `16`,
+		ExposureMode:                     `0`,
+		ExifVersion:                      `"0220"`,
+		DateTimeOriginal:                 `"2007:05:30 14:28:01"`,
+		MaxApertureValue:                 `"32/10"`,
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ThumbJPEGInterchangeFormat:       `4596`,
+		ThumbJPEGInterchangeFormatLength: `5274`,
+	},
+	"2007-06-06-16-15-25-sep-2007-06-06-16-15-25a.jpg": map[FieldName]string{
+		ExifVersion:                      `"0220"`,
+		DateTimeOriginal:                 `"2007:06:06 16:15:25"`,
+		Flash:                            `24`,
+		ExposureMode:                     `0`,
+		ThumbJPEGInterchangeFormat:       `4596`,
+		ThumbJPEGInterchangeFormatLength: `5967`,
+		MaxApertureValue:                 `"30/10"`,
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ExifIFDPointer:                   `284`,
+		ExposureTime:                     `"10/2870"`,
+		CompressedBitsPerPixel:           `"2/1"`,
+		MeteringMode:                     `5`,
+		UserComment:                      `"                                                                                                                     "`,
+		GainControl:                      `0`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+		InteroperabilityIndex:            `"R98"`,
+		ImageDescription:                 `"          "`,
+		Model:                            `"E3700"`,
+		Software:                         `"E3700v1.2"`,
+		Make:                             `"NIKON"`,
+		Orientation:                      `1`,
+		XResolution:                      `"300/1"`,
+		ISOSpeedRatings:                  `50`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `1026`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"0/100"`,
+		FocalLengthIn35mmFilm:            `35`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		FNumber:                          `"48/10"`,
+		ExposureProgram:                  `2`,
+		FileSource:                       `""`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		DateTimeDigitized:                `"2007:06:06 16:15:25"`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `2048`,
+		SceneType:                        `""`,
+		YResolution:                      `"300/1"`,
+		DateTime:                         `"2007:06:06 16:15:25"`,
+		ExposureBiasValue:                `"0/10"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"54/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1536`,
+	},
+	"2007-06-26-10-13-04-sep-2007-06-26-10-13-04a.jpg": map[FieldName]string{
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		FNumber:                          `"3/1"`,
+		CompressedBitsPerPixel:           `"6389872/3145728"`,
+		MeteringMode:                     `2`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `2048`,
+		SensingMethod:                    `2`,
+		DateTimeDigitized:                `"2007:06:26 10:13:04"`,
+		Model:                            `"DV"`,
+		Copyright:                        `"Copyright2004"`,
+		ExposureBiasValue:                `"1/4"`,
+		PixelYDimension:                  `1536`,
+		ImageDescription:                 `"My beautiful picture"`,
+		XResolution:                      `"320/1"`,
+		ISOSpeedRatings:                  `100`,
+		ExifVersion:                      `"0210"`,
+		Flash:                            `0`,
+		Orientation:                      `1`,
+		ThumbJPEGInterchangeFormatLength: `6292`,
+		ExposureProgram:                  `3`,
+		MaxApertureValue:                 `"3/1"`,
+		ExposureIndex:                    `"146/1"`,
+		ThumbJPEGInterchangeFormat:       `1306`,
+		YCbCrPositioning:                 `2`,
+		ExposureTime:                     `"23697424/268435456"`,
+		ExifIFDPointer:                   `262`,
+		RelatedSoundFile:                 `"RelatedSound"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		Software:                         `"DVWare 1.0"`,
+		DateTime:                         `"2007:06:26 10:13:04"`,
+		ShutterSpeedValue:                `"7/1"`,
+		ApertureValue:                    `"3/1"`,
+		LightSource:                      `0`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"384/1"`,
+		DateTimeOriginal:                 `"2007:06:26 10:13:04"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `1170`,
+		Make: `"CEC"`,
+	},
+	"2007-07-13-17-02-30-sep-2007-07-13-17-02-30a.jpg": map[FieldName]string{
+		Software:                `"Ver 1.00    "`,
+		DateTime:                `"2007:07:13 17:02:30"`,
+		FNumber:                 `"48/10"`,
+		ExposureProgram:         `2`,
+		RelatedSoundFile:        `"            "`,
+		Saturation:              `0`,
+		XResolution:             `"72/1"`,
+		ExifIFDPointer:          `266`,
+		ExposureTime:            `"1/110"`,
+		ISOSpeedRatings:         `64`,
+		ComponentsConfiguration: `""`,
+		ColorSpace:              `1`,
+		PixelYDimension:         `2736`,
+		FileSource:              `""`,
+		Model:                   `"ViviCam X30 "`,
+		ThumbJPEGInterchangeFormatLength: `20544`,
+		ShutterSpeedValue:                `"678/100"`,
+		ExposureBiasValue:                `"0/10"`,
+		LightSource:                      `0`,
+		DigitalZoomRatio:                 `"100/100"`,
+		GainControl:                      `0`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:                       `"Vivitar"`,
+		DateTimeOriginal:           `"2007:07:13 17:02:30"`,
+		DateTimeDigitized:          `"2007:07:13 17:02:30"`,
+		PixelXDimension:            `3648`,
+		InteroperabilityIFDPointer: `1010`,
+		ImageDescription:           `"Digital StillCamera"`,
+		Sharpness:                  `0`,
+		Flash:                      `0`,
+		FocalLengthIn35mmFilm:      `35`,
+		SubjectDistanceRange:       `0`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		ExifVersion:                `"0220"`,
+		MeteringMode:               `2`,
+		WhiteBalance:               `0`,
+		YResolution:                `"72/1"`,
+		ThumbJPEGInterchangeFormat: `1156`,
+		ApertureValue:              `"45/10"`,
+		MaxApertureValue:           `"30/10"`,
+		FlashpixVersion:            `"0100"`,
+		MakerNote:                  `""`,
+		CustomRendered:             `0`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		Contrast:                   `0`,
+	},
+	"2007-08-15-14-42-46-sep-2007-08-15-14-42-46a.jpg": map[FieldName]string{
+		Model:                            `"KODAK C663 ZOOM DIGITAL CAMERA"`,
+		ShutterSpeedValue:                `"73/10"`,
+		DigitalZoomRatio:                 `"0/100"`,
+		FocalLengthIn35mmFilm:            `66`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		Make:                             `"EASTMAN KODAK COMPANY"`,
+		Orientation:                      `1`,
+		XResolution:                      `"230/1"`,
+		CustomRendered:                   `0`,
+		ISOSpeedRatings:                  `80`,
+		ComponentsConfiguration:          `""`,
+		FNumber:                          `"36/10"`,
+		ExposureProgram:                  `2`,
+		FileSource:                       `""`,
+		PixelXDimension:                  `2832`,
+		SensingMethod:                    `2`,
+		SceneType:                        `""`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		DateTimeDigitized:                `"2007:08:15 14:42:46"`,
+		MakerNote:                        `""`,
+		FocalLength:                      `"110/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `2128`,
+		YResolution:                      `"230/1"`,
+		ApertureValue:                    `"37/10"`,
+		ExposureBiasValue:                `"0/3"`,
+		LightSource:                      `0`,
+		ExposureMode:                     `0`,
+		ExifVersion:                      `"0221"`,
+		DateTimeOriginal:                 `"2007:08:15 14:42:46"`,
+		Flash:                            `24`,
+		MaxApertureValue:                 `"37/10"`,
+		ColorSpace:                       `1`,
+		ExposureIndex:                    `"80/1"`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ThumbJPEGInterchangeFormat:       `8472`,
+		ThumbJPEGInterchangeFormatLength: `3060`,
+		ExposureTime:                     `"1/160"`,
+		MeteringMode:                     `5`,
+		ExifIFDPointer:                   `320`,
+		GainControl:                      `0`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+	},
+	"2007-08-24-02-40-42-sep-2007-08-24-02-40-42a.jpg": map[FieldName]string{
+		ThumbJPEGInterchangeFormat:       `5108`,
+		ThumbJPEGInterchangeFormatLength: `2084`,
+		MaxApertureValue:                 `"147/32"`,
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `0`,
+		ExifIFDPointer:                   `196`,
+		ExposureTime:                     `"1/400"`,
+		CompressedBitsPerPixel:           `"5/1"`,
+		MeteringMode:                     `5`,
+		UserComment:                      `""`,
+		InteroperabilityIndex:            `"R98"`,
+		Model:                      `"Canon PowerShot SD450"`,
+		ShutterSpeedValue:          `"277/32"`,
+		FocalPlaneResolutionUnit:   `2`,
+		DigitalZoomRatio:           `"2592/2592"`,
+		Make:                       `"Canon"`,
+		Orientation:                `1`,
+		XResolution:                `"180/1"`,
+		ComponentsConfiguration:    `""`,
+		InteroperabilityIFDPointer: `2206`,
+		FocalPlaneYResolution:      `"1944000/168"`,
+		CustomRendered:             `0`,
+		SceneCaptureType:           `0`,
+		FNumber:                    `"100/10"`,
+		FileSource:                 `""`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `1`,
+		DateTimeDigitized:          `"2007:08:24 02:40:42"`,
+		MakerNote:                  `""`,
+		PixelXDimension:            `2592`,
+		SensingMethod:              `2`,
+		FocalPlaneXResolution:      `"2592000/225"`,
+		YResolution:                `"180/1"`,
+		DateTime:                   `"2007:08:24 02:40:42"`,
+		ApertureValue:              `"213/32"`,
+		ExposureBiasValue:          `"0/3"`,
+		FocalLength:                `"17400/1000"`,
+		FlashpixVersion:            `"0100"`,
+		PixelYDimension:            `1944`,
+		ExifVersion:                `"0220"`,
+		DateTimeOriginal:           `"2007:08:24 02:40:42"`,
+		Flash:                      `24`,
+		ExposureMode:               `0`,
+	},
+	"2007-11-07-11-40-44-sep-2007-11-07-11-40-44a.jpg": map[FieldName]string{
+		YResolution:                `"72/1"`,
+		Copyright:                  `"    "`,
+		ThumbJPEGInterchangeFormat: `1306`,
+		ApertureValue:              `"600/100"`,
+		MaxApertureValue:           `"360/100"`,
+		FlashpixVersion:            `"0100"`,
+		WhiteBalance:               `0`,
+		MakerNote:                  `""`,
+		SensingMethod:              `2`,
+		CustomRendered:             `1`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		Software:                   `"Digital Camera FinePix Z1      Ver1.00"`,
+		DateTime:                   `"2007:11:07 11:40:44"`,
+		FNumber:                    `"800/100"`,
+		ExposureProgram:            `2`,
+		XResolution:                `"72/1"`,
+		ExifIFDPointer:             `294`,
+		ExposureTime:               `"10/2000"`,
+		ISOSpeedRatings:            `64`,
+		ComponentsConfiguration:    `""`,
+		CompressedBitsPerPixel:     `"20/10"`,
+		PixelYDimension:            `1944`,
+		Model:                      `"FinePix Z1     "`,
+		ThumbJPEGInterchangeFormatLength: `9900`,
+		ShutterSpeedValue:                `"764/100"`,
+		ExposureBiasValue:                `"0/100"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"610/100"`,
+		ColorSpace:                       `1`,
+		FocalPlaneXResolution:            `"4442/1"`,
+		FileSource:                       `""`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:                       `"FUJIFILM"`,
+		DateTimeOriginal:           `"2007:11:07 11:40:44"`,
+		DateTimeDigitized:          `"2007:11:07 11:40:44"`,
+		BrightnessValue:            `"906/100"`,
+		PixelXDimension:            `2592`,
+		InteroperabilityIFDPointer: `1158`,
+		SceneType:                  `""`,
+		FocalPlaneResolutionUnit:   `3`,
+		Sharpness:                  `0`,
+		SubjectDistanceRange:       `0`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		ExifVersion:                `"0220"`,
+		MeteringMode:               `5`,
+		Flash:                      `16`,
+		FocalPlaneYResolution: `"4442/1"`,
+	},
+	"2008-06-02-10-03-57-sep-2008-06-02-10-03-57a.jpg": map[FieldName]string{
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		FNumber:                          `"2800/1000"`,
+		CompressedBitsPerPixel:           `"5896224/3145728"`,
+		MeteringMode:                     `4`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `2048`,
+		SensingMethod:                    `2`,
+		DateTimeDigitized:                `"2008:06:13 06:16:19"`,
+		Copyright:                        `"Copyright 2006"`,
+		ExposureBiasValue:                `"0/10"`,
+		PixelYDimension:                  `1536`,
+		Model:                            `"i533"`,
+		XResolution:                      `"288/3"`,
+		ISOSpeedRatings:                  `100`,
+		ExifVersion:                      `"0220"`,
+		Flash:                            `65`,
+		DigitalZoomRatio:                 `"100/100"`,
+		Orientation:                      `1`,
+		ThumbJPEGInterchangeFormatLength: `5972`,
+		ExposureProgram:                  `7`,
+		MaxApertureValue:                 `"2970/1000"`,
+		ThumbJPEGInterchangeFormat:       `3756`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `226`,
+		ExposureTime:                     `"10/600"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		Software:                         `"00.00.1240a"`,
+		DateTime:                         `"2008:06:13 06:16:19"`,
+		ShutterSpeedValue:                `"5907/1000"`,
+		ApertureValue:                    `"2970/1000"`,
+		LightSource:                      `4`,
+		FocalLength:                      `"6200/1000"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"288/3"`,
+		DateTimeOriginal:                 `"2008:06:02 10:03:57"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `3620`,
+		ExposureMode:                     `0`,
+		Make:                             `"Polaroid"`,
+	},
+	"2008-06-06-13-29-29-sep-2008-06-06-13-29-29a.jpg": map[FieldName]string{
+		PixelXDimension:            `1600`,
+		InteroperabilityIFDPointer: `3334`,
+		DigitalZoomRatio:           `"3072/3072"`,
+		InteroperabilityIndex:      `"R98"`,
+		Make:                     `"Canon"`,
+		DateTimeOriginal:         `"2008:06:06 13:29:29"`,
+		DateTimeDigitized:        `"2008:06:06 13:29:29"`,
+		FocalPlaneResolutionUnit: `2`,
+		ExifVersion:              `"0220"`,
+		MeteringMode:             `5`,
+		Flash:                    `16`,
+		FocalPlaneYResolution:      `"1200000/169"`,
+		Orientation:                `6`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `1`,
+		MaxApertureValue:           `"116/32"`,
+		FlashpixVersion:            `"0100"`,
+		WhiteBalance:               `0`,
+		YResolution:                `"180/1"`,
+		ThumbJPEGInterchangeFormat: `5108`,
+		ApertureValue:              `"116/32"`,
+		CustomRendered:             `0`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		MakerNote:                  `""`,
+		UserComment:                `""`,
+		SensingMethod:              `2`,
+		DateTime:                   `"2008:06:06 13:29:29"`,
+		FNumber:                    `"35/10"`,
+		ISOSpeedRatings:            `80`,
+		ComponentsConfiguration:    `""`,
+		CompressedBitsPerPixel:     `"5/1"`,
+		XResolution:                `"180/1"`,
+		ExifIFDPointer:             `196`,
+		ExposureTime:               `"1/320"`,
+		ExposureBiasValue:          `"0/3"`,
+		FocalLength:                `"8462/1000"`,
+		ColorSpace:                 `1`,
+		PixelYDimension:            `1200`,
+		FocalPlaneXResolution:      `"1600000/225"`,
+		Model: `"Canon DIGITAL IXUS 75"`,
+		ThumbJPEGInterchangeFormatLength: `6594`,
+		ShutterSpeedValue:                `"266/32"`,
+		FileSource:                       `""`,
+	},
+	"2008-06-17-01-21-30-sep-2008-06-17-01-21-30a.jpg": map[FieldName]string{
+		MaxApertureValue:                 `"30/10"`,
+		ThumbJPEGInterchangeFormat:       `1041`,
+		ThumbJPEGInterchangeFormatLength: `13506`,
+		ExposureProgram:                  `2`,
+		ExposureTime:                     `"10/326"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `253`,
+		LightSource:                      `0`,
+		FocalLength:                      `"645/100"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"72/1"`,
+		Software:                         `"A520_CT019"`,
+		DateTime:                         `"2008:06:17 01:22:13"`,
+		InteroperabilityIFDPointer:       `1011`,
+		Make:                    `"Polaroid"`,
+		DateTimeOriginal:        `"2008:06:17 01:21:30"`,
+		ComponentsConfiguration: `""`,
+		FNumber:                 `"28/10"`,
+		ColorSpace:              `1`,
+		FileSource:              `""`,
+		UserComment:             `""`,
+		PixelXDimension:         `2592`,
+		DateTimeDigitized:       `"2008:06:17 01:21:30"`,
+		CompressedBitsPerPixel:  `"2/1"`,
+		MeteringMode:            `2`,
+		PixelYDimension:         `1944`,
+		ImageDescription:        `"DCFC1247.JPG                   "`,
+		Model:                   `"5MP Digital Camera"`,
+		ExposureBiasValue:       `"0/10"`,
+		ExifVersion:             `"0220"`,
+		Flash:                   `0`,
+		Orientation:             `1`,
+		XResolution:             `"72/1"`,
+		ISOSpeedRatings:         `100`,
+	},
+	"2008-09-02-17-43-48-sep-2008-09-02-17-43-48a.jpg": map[FieldName]string{
+		ImageDescription:                 `"                               "`,
+		Model:                            `"Z550a"`,
+		YResolution:                      `"72/1"`,
+		Software:                         `"R6GA004     prgCXC1250583_GENERIC_M 2.0"`,
+		DateTime:                         `"2008:09:02 17:43:48"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1024`,
+		Make:                             `"Sony Ericsson"`,
+		Orientation:                      `1`,
+		XResolution:                      `"72/1"`,
+		ExifVersion:                      `"0220"`,
+		DateTimeOriginal:                 `"2008:09:02 17:43:48"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `612`,
+		ThumbJPEGInterchangeFormat:       `748`,
+		ThumbJPEGInterchangeFormatLength: `4641`,
+		ColorSpace:                       `1`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `302`,
+		DateTimeDigitized:                `"2008:09:02 17:43:48"`,
+		PixelXDimension:                  `1280`,
+		InteroperabilityIndex:            `"R98"`,
+	},
+	"2009-03-26-09-23-20-sep-2009-03-26-09-23-20a.jpg": map[FieldName]string{
+		FocalLength:           `"5800/1000"`,
+		ColorSpace:            `1`,
+		PixelYDimension:       `2304`,
+		FocalPlaneXResolution: `"3072000/225"`,
+		Model: `"Canon PowerShot SD750"`,
+		ThumbJPEGInterchangeFormatLength: `5513`,
+		ShutterSpeedValue:                `"287/32"`,
+		ExposureBiasValue:                `"0/3"`,
+		FileSource:                       `""`,
+		InteroperabilityIFDPointer:       `3334`,
+		DigitalZoomRatio:                 `"3072/3072"`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:                     `"Canon"`,
+		DateTimeOriginal:         `"2009:03:26 09:23:20"`,
+		DateTimeDigitized:        `"2009:03:26 09:23:20"`,
+		PixelXDimension:          `3072`,
+		FocalPlaneResolutionUnit: `2`,
+		MeteringMode:             `5`,
+		Flash:                    `24`,
+		FocalPlaneYResolution:      `"2304000/169"`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `1`,
+		ExifVersion:                `"0220"`,
+		FlashpixVersion:            `"0100"`,
+		WhiteBalance:               `0`,
+		YResolution:                `"180/1"`,
+		ThumbJPEGInterchangeFormat: `5108`,
+		ApertureValue:              `"95/32"`,
+		MaxApertureValue:           `"95/32"`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		MakerNote:                  `""`,
+		UserComment:                `""`,
+		SensingMethod:              `2`,
+		CustomRendered:             `0`,
+		DateTime:                   `"2009:03:26 09:23:20"`,
+		FNumber:                    `"28/10"`,
+		ComponentsConfiguration:    `""`,
+		CompressedBitsPerPixel:     `"5/1"`,
+		XResolution:                `"180/1"`,
+		ExifIFDPointer:             `196`,
+		ExposureTime:               `"1/500"`,
+		ISOSpeedRatings:            `160`,
+	},
+	"2009-04-11-03-01-38-sep-2009-04-11-03-01-38a.jpg": map[FieldName]string{
+		ThumbJPEGInterchangeFormat:       `33660`,
+		MaxApertureValue:                 `"30/10"`,
+		FlashpixVersion:                  `"0100"`,
+		WhiteBalance:                     `0`,
+		YResolution:                      `"300/1"`,
+		UserComment:                      `"       "`,
+		CustomRendered:                   `0`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		MakerNote:                        `""`,
+		DateTime:                         `"2009:04:11 03:01:38"`,
+		FNumber:                          `"28/10"`,
+		ExposureProgram:                  `2`,
+		Software:                         `"COOLPIX L18 V1.1"`,
+		ExifIFDPointer:                   `230`,
+		ExposureTime:                     `"1/250"`,
+		ISOSpeedRatings:                  `227`,
+		ComponentsConfiguration:          `""`,
+		CompressedBitsPerPixel:           `"4/1"`,
+		Saturation:                       `0`,
+		XResolution:                      `"300/1"`,
+		ThumbJPEGInterchangeFormatLength: `9697`,
+		ExposureBiasValue:                `"0/10"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"5700/1000"`,
+		ColorSpace:                       `1`,
+		PixelYDimension:                  `2448`,
+		FileSource:                       `""`,
+		Model:                            `"COOLPIX L18"`,
+		DateTimeOriginal:                 `"2009:04:11 03:01:38"`,
+		DateTimeDigitized:                `"2009:04:11 03:01:38"`,
+		PixelXDimension:                  `3264`,
+		InteroperabilityIFDPointer:       `33536`,
+		SceneType:                        `""`,
+		DigitalZoomRatio:                 `"0/100"`,
+		GainControl:                      `1`,
+		Make:                             `"NIKON"`,
+		InteroperabilityIndex: `"R98"`,
+		Sharpness:             `1`,
+		ImageDescription:      `"          "`,
+		ResolutionUnit:        `2`,
+		YCbCrPositioning:      `2`,
+		ExifVersion:           `"0220"`,
+		MeteringMode:          `5`,
+		Flash:                 `24`,
+		FocalLengthIn35mmFilm: `35`,
+		SubjectDistanceRange:  `0`,
+		Orientation:           `1`,
+	},
+	"2009-04-23-07-21-35-sep-2009-04-23-07-21-35a.jpg": map[FieldName]string{
+		Sharpness:    `0`,
+		MeteringMode: `5`,
+		Flash:        `9`,
+		FocalLengthIn35mmFilm:      `35`,
+		SubjectDistanceRange:       `3`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		ExifVersion:                `"0220"`,
+		WhiteBalance:               `0`,
+		YResolution:                `"72/1"`,
+		ThumbJPEGInterchangeFormat: `31176`,
+		MaxApertureValue:           `"28/10"`,
+		FlashpixVersion:            `"0100"`,
+		Contrast:                   `0`,
+		MakerNote:                  `""`,
+		CustomRendered:             `0`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		Software:                   `"Optio S50 Ver 1.00"`,
+		DateTime:                   `"2009:04:23 07:21:35"`,
+		FNumber:                    `"26/10"`,
+		ComponentsConfiguration:    `""`,
+		CompressedBitsPerPixel:     `"13301888/4915200"`,
+		Saturation:                 `0`,
+		XResolution:                `"72/1"`,
+		ExifIFDPointer:             `590`,
+		ExposureTime:               `"1/40"`,
+		ISOSpeedRatings:            `100`,
+		ColorSpace:                 `1`,
+		PixelYDimension:            `1920`,
+		Model:                      `"PENTAX Optio S50"`,
+		ThumbJPEGInterchangeFormatLength: `6015`,
+		ExposureBiasValue:                `"0/10"`,
+		FocalLength:                      `"58/10"`,
+		InteroperabilityIFDPointer:       `31040`,
+		DigitalZoomRatio:                 `"0/100"`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:              `"PENTAX Corporation"`,
+		DateTimeOriginal:  `"2009:04:23 07:21:35"`,
+		DateTimeDigitized: `"2009:04:23 07:21:35"`,
+		PixelXDimension:   `2560`,
+	},
+	"2009-06-11-19-23-18-sep-2009-06-11-19-23-18a.jpg": map[FieldName]string{
+		ThumbJPEGInterchangeFormat:       `606`,
+		ThumbJPEGInterchangeFormatLength: `7150`,
+		ExposureProgram:                  `1`,
+		ColorSpace:                       `65535`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `264`,
+		ExposureTime:                     `"1/4"`,
+		DateTimeDigitized:                `"2009:06:11 19:23:18"`,
+		MeteringMode:                     `1`,
+		PixelXDimension:                  `1400`,
+		PixelYDimension:                  `2100`,
+		Model:                            `"Canon EOS DIGITAL REBEL XTi"`,
+		YResolution:                      `"3500000/10000"`,
+		Software:                         `"Adobe Photoshop CS3 Macintosh"`,
+		DateTime:                         `"2009:06:23 18:42:05"`,
+		ApertureValue:                    `"11257/1627"`,
+		ExposureBiasValue:                `"0/1"`,
+		FocalLength:                      `"47/1"`,
+		Make:                             `"Canon"`,
+		Orientation:                      `1`,
+		XResolution:                      `"3500000/10000"`,
+		ISOSpeedRatings:                  `200`,
+		ExifVersion:                      `"0220"`,
+		DateTimeOriginal:                 `"2009:06:11 19:23:18"`,
+		Flash:                            `16`,
+	},
+	"2009-06-20-07-59-05-sep-2009-06-20-07-59-05a.jpg": map[FieldName]string{
+		DateTimeOriginal:                 `"2009:06:20 07:59:05"`,
+		Flash:                            `89`,
+		ExposureMode:                     `0`,
+		ExifVersion:                      `"0221"`,
+		ThumbJPEGInterchangeFormatLength: `4569`,
+		MaxApertureValue:                 `"36/10"`,
+		ColorSpace:                       `1`,
+		ExposureIndex:                    `"160/1"`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ThumbJPEGInterchangeFormat:       `9032`,
+		ExposureTime:                     `"1/500"`,
+		MeteringMode:                     `5`,
+		GainControl:                      `2`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+		InteroperabilityIndex:            `"R98"`,
+		ExifIFDPointer:                   `514`,
+		ShutterSpeedValue:                `"9/1"`,
+		Model:                            `"KODAK EASYSHARE Z710 ZOOM DIGITAL CAMERA"`,
+		Orientation:                      `1`,
+		XResolution:                      `"480/1"`,
+		ISOSpeedRatings:                  `160`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `8728`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"0/100"`,
+		Make:                             `"EASTMAN KODAK COMPANY"`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		FocalLengthIn35mmFilm:            `337`,
+		ExposureProgram:                  `2`,
+		FileSource:                       `""`,
+		FNumber:                          `"35/10"`,
+		YCbCrPositioning:                 `1`,
+		DateTimeDigitized:                `"2009:06:20 07:59:05"`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `3072`,
+		SensingMethod:                    `2`,
+		SceneType:                        `""`,
+		ResolutionUnit:                   `2`,
+		ApertureValue:                    `"36/10"`,
+		ExposureBiasValue:                `"0/3"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"559/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `2304`,
+		YResolution:                      `"480/1"`,
+	},
+	"2009-08-05-08-11-31-sep-2009-08-05-08-11-31a.jpg": map[FieldName]string{
+		XResolution:                `"72/1"`,
+		ISOSpeedRatings:            `100`,
+		ComponentsConfiguration:    `""`,
+		InteroperabilityIFDPointer: `1158`,
+		FocalPlaneYResolution:      `"5292/1"`,
+		CustomRendered:             `0`,
+		Make:                       `"FUJIFILM"`,
+		Orientation:                `1`,
+		SceneCaptureType:           `0`,
+		FileSource:                 `""`,
+		FNumber:                    `"400/100"`,
+		ExposureProgram:            `2`,
+		DateTimeDigitized:          `"2009:08:05 08:11:31"`,
+		MakerNote:                  `"FUJIFILM0130" !"#,012NORMAL d"`,
+		PixelXDimension:            `2848`,
+		SensingMethod:              `2`,
+		SceneType:                  `""`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		Copyright:                  `"    "`,
+		ApertureValue:              `"400/100"`,
+		ExposureBiasValue:          `"0/100"`,
+		LightSource:                `0`,
+		FocalLength:                `"720/100"`,
+		FlashpixVersion:            `"0100"`,
+		YResolution:                `"72/1"`,
+		DateTime:                   `"2009:08:05 08:11:31"`,
+		PixelYDimension:            `2136`,
+		FocalPlaneXResolution:      `"5292/1"`,
+		Flash:                            `16`,
+		ExposureMode:                     `0`,
+		ExifVersion:                      `"0220"`,
+		DateTimeOriginal:                 `"2009:08:05 08:11:31"`,
+		MaxApertureValue:                 `"300/100"`,
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `1`,
+		Sharpness:                        `0`,
+		ThumbJPEGInterchangeFormat:       `1306`,
+		ThumbJPEGInterchangeFormatLength: `8596`,
+		CompressedBitsPerPixel:           `"20/10"`,
+		BrightnessValue:                  `"719/100"`,
+		MeteringMode:                     `5`,
+		SubjectDistanceRange:             `0`,
+		InteroperabilityIndex:            `"R98"`,
+		ExifIFDPointer:                   `294`,
+		ExposureTime:                     `"10/3000"`,
+		ShutterSpeedValue:                `"820/100"`,
+		FocalPlaneResolutionUnit:         `3`,
+		Model:    `"FinePix E550   "`,
+		Software: `"Digital Camera FinePix E550    Ver1.00"`,
+	},
+	"2010-06-08-04-44-24-sep-2010-06-08-04-44-24a.jpg": map[FieldName]string{
+		CompressedBitsPerPixel:           `"8/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `2816`,
+		Saturation:                       `0`,
+		DateTimeDigitized:                `"2010:06:08 04:44:24"`,
+		Model:                            `"DSC-S600"`,
+		ExposureBiasValue:                `"0/10"`,
+		PixelYDimension:                  `2112`,
+		ImageDescription:                 `"                               "`,
+		XResolution:                      `"72/1"`,
+		ISOSpeedRatings:                  `80`,
+		ExifVersion:                      `"0221"`,
+		Flash:                            `31`,
+		CustomRendered:                   `0`,
+		Orientation:                      `1`,
+		ThumbJPEGInterchangeFormatLength: `4029`,
+		ExposureProgram:                  `2`,
+		MaxApertureValue:                 `"48/16"`,
+		ThumbJPEGInterchangeFormat:       `6892`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `2314`,
+		ExposureTime:                     `"10/400"`,
+		SceneType:                        `""`,
+		ResolutionUnit:                   `2`,
+		DateTime:                         `"2010:06:08 04:44:24"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"51/10"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"72/1"`,
+		DateTimeOriginal:                 `"2010:06:08 04:44:24"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `6640`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		Make:                             `"SONY"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		FNumber:                          `"28/10"`,
+	},
+	"2010-06-20-20-07-39-sep-2010-06-20-20-07-39a.jpg": map[FieldName]string{
+		FocalPlaneYResolution: `"2736000/181"`,
+		CustomRendered:        `0`,
+		DigitalZoomRatio:      `"3648/3648"`,
+		Orientation:           `1`,
+		XResolution:           `"4718592/65536"`,
+		ISOSpeedRatings:       `800`,
+		ExifVersion:           `"0220"`,
+		Flash:                 `16`,
+		ThumbJPEGInterchangeFormat:       `3408`,
+		ThumbJPEGInterchangeFormatLength: `5126`,
+		MaxApertureValue:                 `"116/32"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `302`,
+		ExposureTime:                     `"1/10"`,
+		FocalLength:                      `"9681/1000"`,
+		FlashpixVersion:                  `"0100"`,
+		FocalPlaneXResolution:            `"3648000/241"`,
+		YResolution:                      `"4718592/65536"`,
+		Software:                         `"QuickTime 7.6.6"`,
+		DateTime:                         `"2010:10:31 22:39:25"`,
+		ShutterSpeedValue:                `"106/32"`,
+		ApertureValue:                    `"116/32"`,
+		Make:                             `"Canon"`,
+		DateTimeOriginal:                 `"2010:06:20 20:07:39"`,
+		ComponentsConfiguration:          `""`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		FNumber:                          `"35/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		PixelXDimension:                  `3648`,
+		SensingMethod:                    `2`,
+		DateTimeDigitized:                `"2010:06:20 20:07:39"`,
+		CompressedBitsPerPixel:           `"3/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		UserComment:                      `""`,
+		ImageDescription:                 `"                               "`,
+		Model:                            `"Canon PowerShot SD1200 IS"`,
+		ExposureBiasValue:                `"0/3"`,
+		PixelYDimension:                  `2736`,
+		FocalPlaneResolutionUnit:         `2`,
+	},
+	"2010-09-02-08-43-02-sep-2010-09-02-08-43-02a.jpg": map[FieldName]string{
+		DateTime:               `"2010:09:02 08:43:02"`,
+		ExposureProgram:        `5`,
+		ExifVersion:            `"0221"`,
+		CompressedBitsPerPixel: `"1/1"`,
+		Flash:            `65`,
+		Saturation:       `0`,
+		XResolution:      `"72/1"`,
+		ISOSpeedRatings:  `800`,
+		MaxApertureValue: `"362/100"`,
+		LightSource:      `0`,
+		FocalLength:      `"210/10"`,
+		ColorSpace:       `1`,
+		Model:            `"FE370,X880,C575        "`,
+		ThumbJPEGInterchangeFormat:       `9204`,
+		SceneType:                        `""`,
+		DigitalZoomRatio:                 `"0/100"`,
+		SceneCaptureType:                 `3`,
+		GainControl:                      `2`,
+		Contrast:                         `0`,
+		DateTimeOriginal:                 `"2010:09:02 08:43:02"`,
+		MakerNote:                        `""`,
+		FNumber:                          `"53/10"`,
+		Sharpness:                        `0`,
+		ImageDescription:                 `"OLYMPUS DIGITAL CAMERA         "`,
+		Software:                         `"Version 1.0                    "`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `996`,
+		ExposureTime:                     `"10/500"`,
+		ComponentsConfiguration:          `""`,
+		MeteringMode:                     `5`,
+		Orientation:                      `1`,
+		ResolutionUnit:                   `2`,
+		ExposureBiasValue:                `"0/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `2448`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		YResolution:                      `"72/1"`,
+		ThumbJPEGInterchangeFormatLength: `3562`,
+		UserComment:                      `"                                                                                                                             "`,
+		PixelXDimension:                  `3264`,
+		InteroperabilityIFDPointer:       `1714`,
+		CustomRendered:                   `0`,
+		ExposureMode:                     `0`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:              `"OLYMPUS IMAGING CORP.  "`,
+		DateTimeDigitized: `"2010:09:02 08:43:02"`,
+	},
+	"2011-01-24-22-06-02-sep-2011-01-24-22-06-02a.jpg": map[FieldName]string{
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `0`,
+		ThumbJPEGInterchangeFormat:       `25601`,
+		ThumbJPEGInterchangeFormatLength: `3385`,
+		ExifIFDPointer:                   `157`,
+		PixelXDimension:                  `1200`,
+		MakerNote:                        `""`,
+		DateTimeDigitized:                `"2011:01:24 22:06:02"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		Software:                         `"V 12.40"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1600`,
+		Model:                            `"6350"`,
+		YResolution:                      `"300/1"`,
+		XResolution:                      `"300/1"`,
+		ExifVersion:                      `"0220"`,
+		ComponentsConfiguration:          `""`,
+		CustomRendered:                   `0`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		Make:                             `"Nokia"`,
+		Orientation:                      `1`,
+		DigitalZoomRatio:                 `"1024/1024"`,
+		DateTimeOriginal:                 `"2011:01:24 22:06:02"`,
+	},
+	"2011-03-07-09-28-03-sep-2011-03-07-09-28-03a.jpg": map[FieldName]string{
+		Model:                            `"GU295"`,
+		Software:                         `"GU295-MSM1530032L-V10i-APR-22-2010-ATT-US"`,
+		Make:                             `"LG Elec."`,
+		Orientation:                      `1`,
+		XResolution:                      `"72/1"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `538`,
+		CustomRendered:                   `1`,
+		DigitalZoomRatio:                 `"0/0"`,
+		Contrast:                         `0`,
+		ExposureProgram:                  `2`,
+		FileSource:                       `""`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		DateTimeDigitized:                `"2011:03:07 09:28:03"`,
+		PixelXDimension:                  `1280`,
+		SceneType:                        `""`,
+		YResolution:                      `"72/1"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `960`,
+		ExifVersion:                      `"0220"`,
+		DateTimeOriginal:                 `"2011:03:07 09:28:03"`,
+		ExposureMode:                     `0`,
+		ThumbJPEGInterchangeFormat:       `662`,
+		ThumbJPEGInterchangeFormatLength: `9850`,
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ExifIFDPointer:                   `224`,
+		BrightnessValue:                  `"0/1024"`,
+		MeteringMode:                     `2`,
+		Saturation:                       `0`,
+		InteroperabilityIndex:            `"R98"`,
+	},
+	"2011-05-07-13-02-49-sep-2011-05-07-13-02-49a.jpg": map[FieldName]string{
+		DateTimeOriginal:                 `"2011:05:07 13:02:49"`,
+		SceneType:                        `""`,
+		Contrast:                         `0`,
+		Software:                         `"M7500BSAAAAAAD3050"`,
+		GPSVersionID:                     `[2,2,0,0]`,
+		GPSLatitudeRef:                   `"N"`,
+		GPSAltitude:                      `"0/1"`,
+		Orientation:                      `1`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		ExifIFDPointer:                   `218`,
+		GPSInfoIFDPointer:                `502`,
+		ComponentsConfiguration:          `""`,
+		GPSLongitudeRef:                  `"E"`,
+		GPSTimeStamp:                     `["19/1","3/1","43/1"]`,
+		GPSDateStamp:                     `"2011:05:07 "`,
+		YResolution:                      `"72/1"`,
+		ThumbJPEGInterchangeFormatLength: `22806`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1536`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		GPSAltitudeRef:                   `0`,
+		Make:                             `"HTC"`,
+		DateTimeDigitized:                `"2011:05:07 13:02:49"`,
+		PixelXDimension:                  `2048`,
+		InteroperabilityIFDPointer:       `472`,
+		GPSLatitude:                      `["0/1","0/1","0/100"]`,
+		InteroperabilityIndex:            `"R98"`,
+		GPSLongitude:                     `["0/1","0/1","0/100"]`,
+		XResolution:                      `"72/1"`,
+		ExifVersion:                      `"0220"`,
+		GPSProcessingMethod:              `"ASCIIHYBRID-FIX"`,
+		Model:                            `"RAPH800"`,
+		ThumbJPEGInterchangeFormat: `920`,
+		ColorSpace:                 `1`,
+		GPSMapDatum:                `"WGS-84"`,
+	},
+	"2011-08-07-19-22-57-sep-2011-08-07-19-22-57a.jpg": map[FieldName]string{
+		ResolutionUnit:                   `2`,
+		DateTimeDigitized:                `"2011:08:07 19:22:57"`,
+		SensingMethod:                    `2`,
+		SceneType:                        `""`,
+		YResolution:                      `"300/1"`,
+		DateTime:                         `"2011:08:11 09:46:32"`,
+		ApertureValue:                    `"433985/100000"`,
+		ExposureBiasValue:                `"2/6"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"620/10"`,
+		ExifVersion:                      `"0221"`,
+		DateTimeOriginal:                 `"2011:08:07 19:22:57"`,
+		Flash:                            `7`,
+		ExposureMode:                     `0`,
+		ThumbJPEGInterchangeFormat:       `802`,
+		ThumbJPEGInterchangeFormatLength: `9117`,
+		MaxApertureValue:                 `"43/10"`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ExifIFDPointer:                   `186`,
+		ExposureTime:                     `"1/30"`,
+		MeteringMode:                     `2`,
+		GainControl:                      `1`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+		Model:                            `"NIKON D200"`,
+		Software:                         `"Ver.1.00"`,
+		ShutterSpeedValue:                `"4906891/1000000"`,
+		SubSecTimeOriginal:               `"65"`,
+		SubSecTimeDigitized:              `"65"`,
+		FocalLengthIn35mmFilm:            `93`,
+		SceneCaptureType:                 `0`,
+		Make:                             `"NIKON CORPORATION"`,
+		XResolution:                      `"300/1"`,
+		ISOSpeedRatings:                  `400`,
+		CFAPattern:                       `""`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"1/1"`,
+		Contrast:                         `0`,
+		FNumber:                          `"45/10"`,
+		ExposureProgram:                  `3`,
+		SubjectDistance:                  `"63/100"`,
+		FileSource:                       `""`,
+	},
+	"2011-10-28-17-50-18-sep-2011-10-28-17-50-18a.jpg": map[FieldName]string{
+		SubSecTime:                       `"92"`,
+		CustomRendered:                   `0`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		UserComment:                      `""`,
+		DateTime:                         `"2011:11:08 07:27:55"`,
+		FNumber:                          `"4/1"`,
+		ExposureProgram:                  `2`,
+		SubSecTimeOriginal:               `"92"`,
+		GPSVersionID:                     `[2,2,0,0]`,
+		Software:                         `"Adobe Photoshop CS4 Macintosh"`,
+		ExifIFDPointer:                   `364`,
+		ExposureTime:                     `"1/60"`,
+		ISOSpeedRatings:                  `800`,
+		ComponentsConfiguration:          `""`,
+		XResolution:                      `"720000/10000"`,
+		ThumbJPEGInterchangeFormatLength: `6186`,
+		ShutterSpeedValue:                `"393216/65536"`,
+		ExposureBiasValue:                `"0/1"`,
+		FocalLength:                      `"34/1"`,
+		ColorSpace:                       `65535`,
+		PixelYDimension:                  `864`,
+		FocalPlaneXResolution:            `"5616000/1459"`,
+		Model:                      `"Canon EOS 5D Mark II"`,
+		DateTimeOriginal:           `"2011:10:28 17:50:18"`,
+		DateTimeDigitized:          `"2011:10:28 17:50:18"`,
+		PixelXDimension:            `576`,
+		InteroperabilityIFDPointer: `1120`,
+		InteroperabilityIndex:      `"R03"`,
+		Make: `"Canon"`,
+		FocalPlaneResolutionUnit: `2`,
+		ResolutionUnit:           `2`,
+		YCbCrPositioning:         `2`,
+		GPSInfoIFDPointer:        `1152`,
+		ExifVersion:              `"0221"`,
+		MeteringMode:             `5`,
+		Flash:                    `9`,
+		FocalPlaneYResolution:      `"3744000/958"`,
+		Orientation:                `1`,
+		ThumbJPEGInterchangeFormat: `1266`,
+		ApertureValue:              `"262144/65536"`,
+		SubSecTimeDigitized:        `"92"`,
+		FlashpixVersion:            `"0100"`,
+		WhiteBalance:               `1`,
+		YResolution:                `"720000/10000"`,
+	},
+	"2011-10-28-18-25-43-sep-2011-10-28-18-25-43.jpg": map[FieldName]string{
+		SubSecTimeOriginal:               `"50"`,
+		DateTime:                         `"2011:10:28 18:25:43"`,
+		ISOSpeedRatings:                  `1250`,
+		ComponentsConfiguration:          `""`,
+		Saturation:                       `0`,
+		XResolution:                      `"300/1"`,
+		ExposureTime:                     `"10/600"`,
+		ColorSpace:                       `1`,
+		ThumbJPEGInterchangeFormatLength: `3670`,
+		LightSource:                      `0`,
+		FocalLength:                      `"800/10"`,
+		CFAPattern:                       `""`,
+		DigitalZoomRatio:                 `"1/1"`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:                       `"NIKON CORPORATION"`,
+		DateTimeOriginal:           `"2011:10:28 18:25:43"`,
+		InteroperabilityIFDPointer: `3604`,
+		Sharpness:                  `0`,
+		ExifVersion:                `"0221"`,
+		MeteringMode:               `5`,
+		Flash:                      `31`,
+		FocalLengthIn35mmFilm:      `120`,
+		Orientation:                `1`,
+		YCbCrPositioning:           `2`,
+		SubSecTimeDigitized:        `"50"`,
+		WhiteBalance:               `0`,
+		ThumbJPEGInterchangeFormat: `3728`,
+		SensingMethod:              `2`,
+		CustomRendered:             `0`,
+		SubSecTime:                 `"50"`,
+		ExposureProgram:            `0`,
+		Software:                   `"Ver.1.11 "`,
+		FNumber:                    `"56/10"`,
+		CompressedBitsPerPixel:     `"2/1"`,
+		ExifIFDPointer:             `208`,
+		FileSource:                 `""`,
+		Model:                      `"NIKON D80"`,
+		ExposureBiasValue:          `"0/6"`,
+		PixelYDimension:            `537`,
+		GainControl:                `2`,
+		DateTimeDigitized:          `"2011:10:28 18:25:43"`,
+		PixelXDimension:            `800`,
+		SceneType:                  `""`,
+		ImageUniqueID:              `"7fa4f6d028df5f2fc1bad8102be81064"`,
+		SubjectDistanceRange:       `0`,
+		ResolutionUnit:             `2`,
+		FlashpixVersion:            `"0100"`,
+		YResolution:                `"300/1"`,
+		MaxApertureValue:           `"50/10"`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		Contrast:                   `0`,
+		MakerNote:                  `""`,
+		UserComment:                `"ASCII                                    "`,
+	},
+	"2011-11-18-15-38-34-sep-Photo11181538.jpg": map[FieldName]string{
+		WhiteBalance:               `0`,
+		YResolution:                `"72/1"`,
+		ThumbJPEGInterchangeFormat: `642`,
+		FlashpixVersion:            `"0100"`,
+		CustomRendered:             `1`,
+		ExposureMode:               `0`,
+		Contrast:                   `1`,
+		Software:                   `"M6290A-KPVMZL-2.6.0140T"`,
+		ExposureProgram:            `2`,
+		Saturation:                 `0`,
+		XResolution:                `"72/1"`,
+		ExifIFDPointer:             `204`,
+		ComponentsConfiguration:    `""`,
+		PixelYDimension:            `1200`,
+		FileSource:                 `""`,
+		Model:                      `"P2020"`,
+		ThumbJPEGInterchangeFormatLength: `12226`,
+		ColorSpace:                       `1`,
+		BrightnessValue:                  `"0/1024"`,
+		PixelXDimension:                  `1600`,
+		InteroperabilityIFDPointer:       `518`,
+		SceneType:                        `""`,
+		DigitalZoomRatio:                 `"0/0"`,
+		Make:                             `"PANTECH"`,
+		DateTimeOriginal:                 `"2011:11:18 15:38:34"`,
+		DateTimeDigitized:                `"2011:11:18 15:38:34"`,
+		InteroperabilityIndex:            `"R98"`,
+		Sharpness:                        `0`,
+		ExifVersion:                      `"0220"`,
+		MeteringMode:                     `2`,
+		Orientation:                      `1`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+	},
+	"2012-06-02-10-12-28-sep-2012-06-02-10-12-28.jpg": map[FieldName]string{
+		YResolution:                      `"180/1"`,
+		Software:                         `"Ver.1.0  "`,
+		DateTime:                         `"2012:06:02 10:12:28"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"50/10"`,
+		FlashpixVersion:                  `"0100"`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		Make:                             `"Panasonic"`,
+		DateTimeOriginal:                 `"2012:06:02 10:12:28"`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `10506`,
+		ExposureMode:                     `0`,
+		FocalLengthIn35mmFilm:            `28`,
+		FNumber:                          `"33/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		GainControl:                      `0`,
+		Saturation:                       `0`,
+		DateTimeDigitized:                `"2012:06:02 10:12:28"`,
+		CompressedBitsPerPixel:           `"4/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `4608`,
+		SensingMethod:                    `2`,
+		Model:                            `"DMC-FH25"`,
+		ExposureBiasValue:                `"0/100"`,
+		PixelYDimension:                  `3456`,
+		DigitalZoomRatio:                 `"0/10"`,
+		Orientation:                      `1`,
+		XResolution:                      `"180/1"`,
+		ISOSpeedRatings:                  `100`,
+		ExifVersion:                      `"0230"`,
+		Flash:                            `16`,
+		CustomRendered:                   `0`,
+		ThumbJPEGInterchangeFormat:       `11764`,
+		ThumbJPEGInterchangeFormatLength: `7486`,
+		ExposureProgram:                  `2`,
+		MaxApertureValue:                 `"441/128"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `636`,
+		ExposureTime:                     `"10/4000"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+	},
+	"2012-09-21-22-07-34-sep-2012-09-21-22-07-34.jpg": map[FieldName]string{
+		ThumbJPEGInterchangeFormat:       `5108`,
+		ThumbJPEGInterchangeFormatLength: `4855`,
+		MaxApertureValue:                 `"95/32"`,
+		ColorSpace:                       `1`,
+		WhiteBalance:                     `0`,
+		ExifIFDPointer:                   `240`,
+		ExposureTime:                     `"1/60"`,
+		CompressedBitsPerPixel:           `"3/1"`,
+		MeteringMode:                     `5`,
+		UserComment:                      `""`,
+		InteroperabilityIndex:            `"R98"`,
+		ImageDescription:                 `"                               "`,
+		Model:                            `"Canon PowerShot SD940 IS"`,
+		ShutterSpeedValue:                `"189/32"`,
+		FocalPlaneResolutionUnit:         `2`,
+		CustomRendered:                   `0`,
+		Make:                             `"Canon"`,
+		Orientation:                      `1`,
+		XResolution:                      `"180/1"`,
+		ISOSpeedRatings:                  `500`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `3288`,
+		FocalPlaneYResolution:            `"2448000/183"`,
+		DigitalZoomRatio:                 `"4000/4000"`,
+		SceneCaptureType:                 `2`,
+		FNumber:                          `"28/10"`,
+		FileSource:                       `""`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		DateTimeDigitized:                `"2012:09:21 22:07:34"`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `3264`,
+		SensingMethod:                    `2`,
+		FocalPlaneXResolution:            `"3264000/244"`,
+		YResolution:                      `"180/1"`,
+		DateTime:                         `"2012:09:21 22:07:34"`,
+		ApertureValue:                    `"95/32"`,
+		ExposureBiasValue:                `"0/3"`,
+		FocalLength:                      `"5000/1000"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `2448`,
+		ExifVersion:                      `"0221"`,
+		DateTimeOriginal:                 `"2012:09:21 22:07:34"`,
+		Flash:                            `25`,
+		ExposureMode:                     `0`,
+	},
+	"2012-12-19-21-38-40-sep-temple_square1.jpg": map[FieldName]string{
+		InteroperabilityIFDPointer: `322`,
+		GPSLatitude:                `["40/1","46/1","1322/100"]`,
+		InteroperabilityIndex:      `"R98"`,
+		Make:                       `"HTC"`,
+		DateTimeOriginal:           `"2012:12:19 21:38:40"`,
+		DateTimeDigitized:          `"2012:12:19 21:38:40"`,
+		PixelXDimension:            `3264`,
+		GPSLatitudeRef:             `"N"`,
+		GPSLongitude:               `["111/1","53/1","2840/100"]`,
+		GPSLongitudeRef:            `"W"`,
+		GPSProcessingMethod:        `"ASCIIGPS"`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `1`,
+		GPSInfoIFDPointer:          `352`,
+		ExifVersion:                `"0220"`,
+		GPSMapDatum:                `"WGS-84"`,
+		YResolution:                `"72/1"`,
+		ThumbJPEGInterchangeFormat: `696`,
+		FlashpixVersion:            `"0100"`,
+		GPSAltitudeRef:             `0`,
+		GPSVersionID:               `[2,2,0]`,
+		GPSAltitude:                `"1334/1"`,
+		GPSTimeStamp:               `["4/1","38/1","40/1"]`,
+		XResolution:                `"72/1"`,
+		ExifIFDPointer:             `136`,
+		ISOSpeedRatings:            `801`,
+		ComponentsConfiguration:    `""`,
+		PixelYDimension:            `1952`,
+		GPSDateStamp:               `"2012:12:20"`,
+		Model:                      `"ADR6400L"`,
+		ThumbJPEGInterchangeFormatLength: `38469`,
+		FocalLength:                      `"457/100"`,
+		ColorSpace:                       `1`,
+	},
+	"2012-12-21-11-15-19-sep-IMG_0001.jpg": map[FieldName]string{
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+		ExifIFDPointer:             `360`,
+		ExposureTime:               `"1/30"`,
+		InteroperabilityIndex:      `"R98"`,
+		SubSecTimeDigitized:        `"00"`,
+		FlashpixVersion:            `"0100"`,
+		FocalPlaneXResolution:      `"5184000/894"`,
+		YResolution:                `"72/1"`,
+		DateTime:                   `"2012:12:21 11:15:19"`,
+		ShutterSpeedValue:          `"327680/65536"`,
+		ApertureValue:              `"286720/65536"`,
+		FocalLength:                `"24/1"`,
+		LensModel:                  `"EF-S18-55mm f/3.5-5.6 IS II"`,
+		GPSVersionID:               `[2,3,0,0]`,
+		InteroperabilityIFDPointer: `8806`,
+		ExposureMode:               `0`,
+		SceneCaptureType:           `0`,
+		Make:                       `"Canon"`,
+		GPSInfoIFDPointer:          `9034`,
+		DateTimeOriginal:           `"2012:12:21 11:15:19"`,
+		ComponentsConfiguration:    `""`,
+		SubSecTime:                 `"00"`,
+		Artist:                     `""`,
+		FNumber:                    `"45/10"`,
+		ColorSpace:                 `1`,
+		WhiteBalance:               `0`,
+		DateTimeDigitized:          `"2012:12:21 11:15:19"`,
+		MeteringMode:               `5`,
+		MakerNote:                  `""`,
+		UserComment:                `""`,
+		PixelXDimension:            `5184`,
+		FocalPlaneResolutionUnit:   `2`,
+		Model:                 `"Canon EOS REBEL T4i"`,
+		Copyright:             `""`,
+		ExposureBiasValue:     `"0/1"`,
+		SubSecTimeOriginal:    `"00"`,
+		PixelYDimension:       `3456`,
+		FocalPlaneYResolution: `"3456000/597"`,
+		CustomRendered:        `0`,
+		Orientation:           `1`,
+		XResolution:           `"72/1"`,
+		ISOSpeedRatings:       `1600`,
+		ExifVersion:           `"0230"`,
+		Flash:                 `16`,
+		ThumbJPEGInterchangeFormat:       `10924`,
+		ThumbJPEGInterchangeFormatLength: `14327`,
+		ExposureProgram:                  `0`,
+	},
+	"2013-02-05-23-12-09-sep-DSCI0001.jpg": map[FieldName]string{
+		ApertureValue:                    `"3072/1000"`,
+		ExposureBiasValue:                `"0/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `1200`,
+		FileSource:                       `""`,
+		YResolution:                      `"288/3"`,
+		ThumbJPEGInterchangeFormatLength: `5863`,
+		ShutterSpeedValue:                `"5907/1000"`,
+		WhiteBalance:                     `0`,
+		InteroperabilityIFDPointer:       `4838`,
+		ExposureMode:                     `0`,
+		InteroperabilityIndex:            `"R98"`,
+		Make:                   `"Polaroid"`,
+		DateTimeDigitized:      `"2013:02:05 23:12:09"`,
+		PixelXDimension:        `1600`,
+		DateTime:               `"2013:02:05 23:12:09"`,
+		ExposureProgram:        `2`,
+		CompressedBitsPerPixel: `"3766184/1920000"`,
+		Flash: `1`,
+		FocalLengthIn35mmFilm:      `35`,
+		XResolution:                `"288/3"`,
+		ISOSpeedRatings:            `100`,
+		ExifVersion:                `"0210"`,
+		MaxApertureValue:           `"3072/1000"`,
+		LightSource:                `0`,
+		FocalLength:                `"5954/1000"`,
+		ColorSpace:                 `1`,
+		Model:                      `"Polaroid i532"`,
+		Copyright:                  `"Copyright 2005"`,
+		ThumbJPEGInterchangeFormat: `4974`,
+		SceneType:                  `""`,
+		DigitalZoomRatio:           `"100/100"`,
+		SceneCaptureType:           `0`,
+		DateTimeOriginal:           `"2013:02:05 23:12:09"`,
+		MakerNote:                  `" BARCODE:A265KS008000; ZP:812; FP:124; AWB:235,679; PWB:476,304; PMF:12,11610; LV:493; LUM:3-8-9-8-1-11;20;26;19;10;A:1,F1:6,F2:18;ET:145, W:2, F:3 ;FV:        41FV:        36FV:        43FV:       223FV:       258FV:         9FV:       466FV:       216FP: 10FP:  8FP:  6FP:  6FP:  6FP:  0FP:  8FP:  8AFS: 110"`,
+		SensingMethod:              `2`,
+		Sharpness:                  `0`,
+		ImageDescription:           `""`,
+		Software:                   `"  1.0"`,
+		FNumber:                    `"28/10"`,
+		ExifIFDPointer:             `240`,
+		ExposureTime:               `"1/60"`,
+		ComponentsConfiguration:    `""`,
+		MeteringMode:               `3`,
+		Orientation:                `1`,
+		ResolutionUnit:             `2`,
+		YCbCrPositioning:           `2`,
+	},
+	"2099-08-12-19-59-29-sep-2099-08-12-19-59-29a.jpg": map[FieldName]string{
+		Model:              `"NIKON D70s"`,
+		ExposureBiasValue:  `"0/6"`,
+		SubSecTimeOriginal: `"00"`,
+		PixelYDimension:    `2000`,
+		CFAPattern:         `""`,
+		CustomRendered:     `0`,
+		DigitalZoomRatio:   `"1/1"`,
+		Orientation:        `1`,
+		XResolution:        `"300/1"`,
+		ExifVersion:        `"0221"`,
+		Flash:              `31`,
+		ThumbJPEGInterchangeFormat:       `28588`,
+		ThumbJPEGInterchangeFormatLength: `8886`,
+		ExposureProgram:                  `0`,
+		MaxApertureValue:                 `"36/10"`,
+		SceneType:                        `""`,
+		InteroperabilityIndex:            `"R98"`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `2`,
+		ExifIFDPointer:                   `216`,
+		ExposureTime:                     `"10/600"`,
+		FocalLength:                      `"180/10"`,
+		SubSecTimeDigitized:              `"00"`,
+		FlashpixVersion:                  `"0100"`,
+		YResolution:                      `"300/1"`,
+		Software:                         `"Ver.1.00 "`,
+		DateTime:                         `"2099:08:12 19:59:29"`,
+		LightSource:                      `0`,
+		InteroperabilityIFDPointer:       `28448`,
+		ExposureMode:                     `0`,
+		FocalLengthIn35mmFilm:            `27`,
+		SceneCaptureType:                 `0`,
+		Make:                             `"NIKON CORPORATION"`,
+		DateTimeOriginal:                 `"2099:08:12 19:59:29"`,
+		ComponentsConfiguration:          `""`,
+		SubSecTime:                       `"00"`,
+		Contrast:                         `1`,
+		Sharpness:                        `0`,
+		FNumber:                          `"35/10"`,
+		ColorSpace:                       `1`,
+		FileSource:                       `""`,
+		WhiteBalance:                     `0`,
+		UserComment:                      `"ASCII                                    "`,
+		PixelXDimension:                  `3008`,
+		SensingMethod:                    `2`,
+		GainControl:                      `0`,
+		DateTimeDigitized:                `"2099:08:12 19:59:29"`,
+		CompressedBitsPerPixel:           `"2/1"`,
+		MeteringMode:                     `5`,
+		MakerNote:                        `""`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+	},
+	"2216-11-15-11-46-51-sep-2216-11-15-11-46-51a.jpg": map[FieldName]string{
+		ExposureProgram:                  `2`,
+		FileSource:                       `""`,
+		FNumber:                          `"480/100"`,
+		YCbCrPositioning:                 `2`,
+		DateTimeDigitized:                `"2216:11:15 11:46:51"`,
+		MakerNote:                        `""`,
+		PixelXDimension:                  `3296`,
+		SensingMethod:                    `2`,
+		SceneType:                        `""`,
+		ResolutionUnit:                   `2`,
+		ApertureValue:                    `"452/100"`,
+		ExposureBiasValue:                `"0/10"`,
+		LightSource:                      `0`,
+		FocalLength:                      `"60/10"`,
+		FlashpixVersion:                  `"0100"`,
+		PixelYDimension:                  `2472`,
+		YResolution:                      `"480/1"`,
+		DateTimeOriginal:                 `"2216:11:15 11:46:51"`,
+		Flash:                            `24`,
+		ExposureMode:                     `0`,
+		ExifVersion:                      `"0221"`,
+		ThumbJPEGInterchangeFormatLength: `5175`,
+		MaxApertureValue:                 `"286/100"`,
+		ColorSpace:                       `1`,
+		ExposureIndex:                    `"80/1"`,
+		WhiteBalance:                     `0`,
+		Sharpness:                        `0`,
+		ThumbJPEGInterchangeFormat:       `17818`,
+		ExposureTime:                     `"1016/1000000"`,
+		MeteringMode:                     `5`,
+		GainControl:                      `0`,
+		Saturation:                       `0`,
+		SubjectDistanceRange:             `0`,
+		ExifIFDPointer:                   `2316`,
+		Software:                         `"KODAK EASYSHARE C813 ZOOM DIGITAL CAMERA"`,
+		ShutterSpeedValue:                `"994/100"`,
+		Model:                            `"KODAK EASYSHARE C813 ZOOM DIGITAL CAMERA"`,
+		Orientation:                      `1`,
+		XResolution:                      `"480/1"`,
+		ISOSpeedRatings:                  `80`,
+		ComponentsConfiguration:          `""`,
+		InteroperabilityIFDPointer:       `17674`,
+		CustomRendered:                   `0`,
+		DigitalZoomRatio:                 `"0/10"`,
+		Make:                             `"EASTMAN KODAK COMPANY"`,
+		SceneCaptureType:                 `0`,
+		Contrast:                         `0`,
+		FocalLengthIn35mmFilm:            `36`,
+	},
+	"FailedHash-NoDate-sep-remembory.jpg": map[FieldName]string{
+		Model:           `"MFC-7840W"`,
+		YResolution:     `"150/1"`,
+		Software:        `"Apple Image Capture"`,
+		PixelYDimension: `1626`,
+		ExifIFDPointer:  `192`,
+		PixelXDimension: `1232`,
+		Make:            `"Brother"`,
+		Orientation:     `1`,
+		XResolution:     `"150/1"`,
+		ResolutionUnit:  `2`,
+	},
+	"f1-exif.jpg": map[FieldName]string{
+		PixelXDimension:         `0`,
+		Orientation:             `1`,
+		XResolution:             `"72/1"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		ExifIFDPointer:          `134`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:02"`,
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+		PixelYDimension:         `0`,
+	},
+	"f2-exif.jpg": map[FieldName]string{
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+		PixelYDimension:         `0`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		ExifIFDPointer:          `134`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `2`,
+		XResolution:             `"72/1"`,
+	},
+	"f3-exif.jpg": map[FieldName]string{
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+		PixelYDimension:         `0`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		ExifIFDPointer:          `134`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `3`,
+		XResolution:             `"72/1"`,
+	},
+	"f4-exif.jpg": map[FieldName]string{
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `4`,
+		XResolution:             `"72/1"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		ExifIFDPointer:          `134`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+		PixelYDimension:         `0`,
+	},
+	"f5-exif.jpg": map[FieldName]string{
+		ExifIFDPointer:          `134`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `5`,
+		XResolution:             `"72/1"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		PixelYDimension:         `0`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+	},
+	"f6-exif.jpg": map[FieldName]string{
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+		PixelYDimension:         `0`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `6`,
+		XResolution:             `"72/1"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		ExifIFDPointer:          `134`,
+	},
+	"f7-exif.jpg": map[FieldName]string{
+		ExifIFDPointer:          `134`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `7`,
+		XResolution:             `"72/1"`,
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		PixelYDimension:         `0`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+	},
+	"f8-exif.jpg": map[FieldName]string{
+		ResolutionUnit:          `2`,
+		YCbCrPositioning:        `1`,
+		ExifIFDPointer:          `134`,
+		ExifVersion:             `"0210"`,
+		ComponentsConfiguration: `""`,
+		PixelXDimension:         `0`,
+		Orientation:             `8`,
+		XResolution:             `"72/1"`,
+		FlashpixVersion:         `"0100"`,
+		ColorSpace:              `65535`,
+		PixelYDimension:         `0`,
+		YResolution:             `"72/1"`,
+		DateTime:                `"2012:11:04 05:42:32"`,
+	},
+	"geodegrees_as_string.jpg": map[FieldName]string{
+		GPSAltitudeRef:                   `0`,
+		ThumbJPEGInterchangeFormat:       `539`,
+		ThumbJPEGInterchangeFormatLength: `13132`,
+		WhiteBalance:                     `0`,
+		ExposureProgram:                  `0`,
+		Sharpness:                        `2`,
+		ExifIFDPointer:                   `114`,
+		ExposureTime:                     `"0/1024"`,
+		Saturation:                       `0`,
+		GPSLatitude:                      `"52,00000,50,00000,34,01180"`,
+		GPSTimeStamp:                     `"17,00000,8,00000,29,00000"`,
+		Model:                            `"HTC One_M8"`,
+		ApertureValue:                    `"2048/1024"`,
+		FocalLength:                      `"3072/1024"`,
+		GPSLatitudeRef:                   `"N"`,
+		GPSLongitude:                     `"11,00000,10,00000,58,28360"`,
+		GPSAltitude:                      `"0/1024"`,
+		GPSLongitudeRef:                  `"E"`,
+		GPSProcessingMethod:              `"ASCII"`,
+		GPSInfoIFDPointer:                `317`,
+		Make:                             `"HTC"`,
+		DateTimeOriginal:                 `"2014:04:26 19:09:19"`,
+		ISOSpeedRatings:                  `125`,
+		Contrast:                         `0`,
+	},
+	"has-lens-info.jpg": map[FieldName]string{
+		LensModel: `"iPhone 4S back camera 4.28mm f/2.4"`,
+		Model:     `"iPhone 4S"`,
+		ThumbJPEGInterchangeFormatLength: `10875`,
+		ShutterSpeedValue:                `"106906/10353"`,
+		FocalLength:                      `"107/25"`,
+		SubjectArea:                      `[1631,1223,881,881]`,
+		ColorSpace:                       `1`,
+		PixelYDimension:                  `2448`,
+		GPSLatitude:                      `["59/1","19/1","5717/100"]`,
+		Make:                             `"Apple"`,
+		DateTimeOriginal:                 `"2014:09:01 15:03:47"`,
+		DateTimeDigitized:                `"2014:09:01 15:03:47"`,
+		BrightnessValue:                  `"3927/419"`,
+		PixelXDimension:                  `3264`,
+		SceneType:                        `""`,
+		LensMake:                         `"Apple"`,
+		GPSLatitudeRef:                   `"N"`,
+		GPSLongitude:                     `["18/1","3/1","5379/100"]`,
+		FocalLengthIn35mmFilm:            `35`,
+		Orientation:                      `6`,
+		ResolutionUnit:                   `2`,
+		YCbCrPositioning:                 `1`,
+		GPSInfoIFDPointer:                `948`,
+		ExifVersion:                      `"0221"`,
+		MeteringMode:                     `5`,
+		Flash:                            `16`,
+		GPSLongitudeRef:                  `"E"`,
+		YResolution:                      `"72/1"`,
+		ThumbJPEGInterchangeFormat:       `1244`,
+		ApertureValue:                    `"4845/1918"`,
+		SubSecTimeDigitized:              `"880"`,
+		FlashpixVersion:                  `"0100"`,
+		WhiteBalance:                     `0`,
+		GPSAltitudeRef:                   `0`,
+		MakerNote:                        `""`,
+		SensingMethod:                    `2`,
+		ExposureMode:                     `0`,
+		SceneCaptureType:                 `0`,
+		GPSImgDirection:                  `"18329/175"`,
+		Software:                         `"7.1.1"`,
+		DateTime:                         `"2014:09:01 15:03:47"`,
+		FNumber:                          `"12/5"`,
+		ExposureProgram:                  `2`,
+		SubSecTimeOriginal:               `"880"`,
+		GPSImgDirectionRef:               `"T"`,
+		XResolution:                      `"72/1"`,
+		ExifIFDPointer:                   `204`,
+		ExposureTime:                     `"1/1284"`,
+		ISOSpeedRatings:                  `50`,
+		ComponentsConfiguration:          `""`,
+		GPSAltitude:                      `"29/1"`,
+		GPSTimeStamp:                     `["13/1","3/1","4279/100"]`,
+	},
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tag.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tag.go
new file mode 100644
index 000000000..66b68e334
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tag.go
@@ -0,0 +1,438 @@
+package tiff
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// Format specifies the Go type equivalent used to represent the basic
+// tiff data types.
+type Format int
+
+const (
+	IntVal Format = iota
+	FloatVal
+	RatVal
+	StringVal
+	UndefVal
+	OtherVal
+)
+
+var ErrShortReadTagValue = errors.New("tiff: short read of tag value")
+
+var formatNames = map[Format]string{
+	IntVal:    "int",
+	FloatVal:  "float",
+	RatVal:    "rational",
+	StringVal: "string",
+	UndefVal:  "undefined",
+	OtherVal:  "other",
+}
+
+// DataType represents the basic tiff tag data types.
+type DataType uint16
+
+const (
+	DTByte      DataType = 1
+	DTAscii              = 2
+	DTShort              = 3
+	DTLong               = 4
+	DTRational           = 5
+	DTSByte              = 6
+	DTUndefined          = 7
+	DTSShort             = 8
+	DTSLong              = 9
+	DTSRational          = 10
+	DTFloat              = 11
+	DTDouble             = 12
+)
+
+var typeNames = map[DataType]string{
+	DTByte:      "byte",
+	DTAscii:     "ascii",
+	DTShort:     "short",
+	DTLong:      "long",
+	DTRational:  "rational",
+	DTSByte:     "signed byte",
+	DTUndefined: "undefined",
+	DTSShort:    "signed short",
+	DTSLong:     "signed long",
+	DTSRational: "signed rational",
+	DTFloat:     "float",
+	DTDouble:    "double",
+}
+
+// typeSize specifies the size in bytes of each type.
+var typeSize = map[DataType]uint32{
+	DTByte:      1,
+	DTAscii:     1,
+	DTShort:     2,
+	DTLong:      4,
+	DTRational:  8,
+	DTSByte:     1,
+	DTUndefined: 1,
+	DTSShort:    2,
+	DTSLong:     4,
+	DTSRational: 8,
+	DTFloat:     4,
+	DTDouble:    8,
+}
+
+// Tag reflects the parsed content of a tiff IFD tag.
+type Tag struct {
+	// Id is the 2-byte tiff tag identifier.
+	Id uint16
+	// Type is an integer (1 through 12) indicating the tag value's data type.
+	Type DataType
+	// Count is the number of type Type stored in the tag's value (i.e. the
+	// tag's value is an array of type Type and length Count).
+	Count uint32
+	// Val holds the bytes that represent the tag's value.
+	Val []byte
+	// ValOffset holds byte offset of the tag value w.r.t. the beginning of the
+	// reader it was decoded from. Zero if the tag value fit inside the offset
+	// field.
+	ValOffset uint32
+
+	order     binary.ByteOrder
+	intVals   []int64
+	floatVals []float64
+	ratVals   [][]int64
+	strVal    string
+	format    Format
+}
+
+// DecodeTag parses a tiff-encoded IFD tag from r and returns a Tag object. The
+// first read from r should be the first byte of the tag. ReadAt offsets should
+// generally be relative to the beginning of the tiff structure (not relative
+// to the beginning of the tag).
+func DecodeTag(r ReadAtReader, order binary.ByteOrder) (*Tag, error) {
+	t := new(Tag)
+	t.order = order
+
+	err := binary.Read(r, order, &t.Id)
+	if err != nil {
+		return nil, errors.New("tiff: tag id read failed: " + err.Error())
+	}
+
+	err = binary.Read(r, order, &t.Type)
+	if err != nil {
+		return nil, errors.New("tiff: tag type read failed: " + err.Error())
+	}
+
+	err = binary.Read(r, order, &t.Count)
+	if err != nil {
+		return nil, errors.New("tiff: tag component count read failed: " + err.Error())
+	}
+
+	// There seems to be a relatively common corrupt tag which has a Count of
+	// MaxUint32. This is probably not a valid value, so return early.
+	if t.Count == 1<<32-1 {
+		return t, errors.New("invalid Count offset in tag")
+	}
+
+	valLen := typeSize[t.Type] * t.Count
+	if valLen == 0 {
+		return t, errors.New("zero length tag value")
+	}
+
+	if valLen > 4 {
+		binary.Read(r, order, &t.ValOffset)
+
+		// Use a bytes.Buffer so we don't allocate a huge slice if the tag
+		// is corrupt.
+		var buff bytes.Buffer
+		sr := io.NewSectionReader(r, int64(t.ValOffset), int64(valLen))
+		n, err := io.Copy(&buff, sr)
+		if err != nil {
+			return t, errors.New("tiff: tag value read failed: " + err.Error())
+		} else if n != int64(valLen) {
+			return t, ErrShortReadTagValue
+		}
+		t.Val = buff.Bytes()
+
+	} else {
+		val := make([]byte, valLen)
+		if _, err = io.ReadFull(r, val); err != nil {
+			return t, errors.New("tiff: tag offset read failed: " + err.Error())
+		}
+		// ignore padding.
+		if _, err = io.ReadFull(r, make([]byte, 4-valLen)); err != nil {
+			return t, errors.New("tiff: tag offset read failed: " + err.Error())
+		}
+
+		t.Val = val
+	}
+
+	return t, t.convertVals()
+}
+
+func (t *Tag) convertVals() error {
+	r := bytes.NewReader(t.Val)
+
+	switch t.Type {
+	case DTAscii:
+		if len(t.Val) > 0 {
+			t.strVal = string(t.Val[:len(t.Val)-1]) // ignore the last byte (NULL).
+		}
+	case DTByte:
+		var v uint8
+		t.intVals = make([]int64, int(t.Count))
+		for i := range t.intVals {
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.intVals[i] = int64(v)
+		}
+	case DTShort:
+		var v uint16
+		t.intVals = make([]int64, int(t.Count))
+		for i := range t.intVals {
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.intVals[i] = int64(v)
+		}
+	case DTLong:
+		var v uint32
+		t.intVals = make([]int64, int(t.Count))
+		for i := range t.intVals {
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.intVals[i] = int64(v)
+		}
+	case DTSByte:
+		var v int8
+		t.intVals = make([]int64, int(t.Count))
+		for i := range t.intVals {
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.intVals[i] = int64(v)
+		}
+	case DTSShort:
+		var v int16
+		t.intVals = make([]int64, int(t.Count))
+		for i := range t.intVals {
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.intVals[i] = int64(v)
+		}
+	case DTSLong:
+		var v int32
+		t.intVals = make([]int64, int(t.Count))
+		for i := range t.intVals {
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.intVals[i] = int64(v)
+		}
+	case DTRational:
+		t.ratVals = make([][]int64, int(t.Count))
+		for i := range t.ratVals {
+			var n, d uint32
+			err := binary.Read(r, t.order, &n)
+			if err != nil {
+				return err
+			}
+			err = binary.Read(r, t.order, &d)
+			if err != nil {
+				return err
+			}
+			t.ratVals[i] = []int64{int64(n), int64(d)}
+		}
+	case DTSRational:
+		t.ratVals = make([][]int64, int(t.Count))
+		for i := range t.ratVals {
+			var n, d int32
+			err := binary.Read(r, t.order, &n)
+			if err != nil {
+				return err
+			}
+			err = binary.Read(r, t.order, &d)
+			if err != nil {
+				return err
+			}
+			t.ratVals[i] = []int64{int64(n), int64(d)}
+		}
+	case DTFloat: // float32
+		t.floatVals = make([]float64, int(t.Count))
+		for i := range t.floatVals {
+			var v float32
+			err := binary.Read(r, t.order, &v)
+			if err != nil {
+				return err
+			}
+			t.floatVals[i] = float64(v)
+		}
+	case DTDouble:
+		t.floatVals = make([]float64, int(t.Count))
+		for i := range t.floatVals {
+			var u float64
+			err := binary.Read(r, t.order, &u)
+			if err != nil {
+				return err
+			}
+			t.floatVals[i] = u
+		}
+	}
+
+	switch t.Type {
+	case DTByte, DTShort, DTLong, DTSByte, DTSShort, DTSLong:
+		t.format = IntVal
+	case DTRational, DTSRational:
+		t.format = RatVal
+	case DTFloat, DTDouble:
+		t.format = FloatVal
+	case DTAscii:
+		t.format = StringVal
+	case DTUndefined:
+		t.format = UndefVal
+	default:
+		t.format = OtherVal
+	}
+
+	return nil
+}
+
+// Format returns a value indicating which method can be called to retrieve the
+// tag's value properly typed (e.g. integer, rational, etc.).
+func (t *Tag) Format() Format { return t.format }
+
+func (t *Tag) typeErr(to Format) error {
+	return &wrongFmtErr{typeNames[t.Type], formatNames[to]}
+}
+
+// Rat returns the tag's i'th value as a rational number. It returns a nil and
+// an error if this tag's Format is not RatVal.  It panics for zero deminators
+// or if i is out of range.
+func (t *Tag) Rat(i int) (*big.Rat, error) {
+	n, d, err := t.Rat2(i)
+	if err != nil {
+		return nil, err
+	}
+	return big.NewRat(n, d), nil
+}
+
+// Rat2 returns the tag's i'th value as a rational number represented by a
+// numerator-denominator pair. It returns an error if the tag's Format is not
+// RatVal. It panics if i is out of range.
+func (t *Tag) Rat2(i int) (num, den int64, err error) {
+	if t.format != RatVal {
+		return 0, 0, t.typeErr(RatVal)
+	}
+	return t.ratVals[i][0], t.ratVals[i][1], nil
+}
+
+// Int64 returns the tag's i'th value as an integer. It returns an error if the
+// tag's Format is not IntVal. It panics if i is out of range.
+func (t *Tag) Int64(i int) (int64, error) {
+	if t.format != IntVal {
+		return 0, t.typeErr(IntVal)
+	}
+	return t.intVals[i], nil
+}
+
+// Int returns the tag's i'th value as an integer. It returns an error if the
+// tag's Format is not IntVal. It panics if i is out of range.
+func (t *Tag) Int(i int) (int, error) {
+	if t.format != IntVal {
+		return 0, t.typeErr(IntVal)
+	}
+	return int(t.intVals[i]), nil
+}
+
+// Float returns the tag's i'th value as a float. It returns an error if the
+// tag's Format is not IntVal.  It panics if i is out of range.
+func (t *Tag) Float(i int) (float64, error) {
+	if t.format != FloatVal {
+		return 0, t.typeErr(FloatVal)
+	}
+	return t.floatVals[i], nil
+}
+
+// StringVal returns the tag's value as a string. It returns an error if the
+// tag's Format is not StringVal. It panics if i is out of range.
+func (t *Tag) StringVal() (string, error) {
+	if t.format != StringVal {
+		return "", t.typeErr(StringVal)
+	}
+	return t.strVal, nil
+}
+
+// String returns a nicely formatted version of the tag.
+func (t *Tag) String() string {
+	data, err := t.MarshalJSON()
+	if err != nil {
+		return "ERROR: " + err.Error()
+	}
+
+	if t.Count == 1 {
+		return strings.Trim(fmt.Sprintf("%s", data), "[]")
+	}
+	return fmt.Sprintf("%s", data)
+}
+
+func (t *Tag) MarshalJSON() ([]byte, error) {
+	switch t.format {
+	case StringVal, UndefVal:
+		return nullString(t.Val), nil
+	case OtherVal:
+		return []byte(fmt.Sprintf("unknown tag type '%v'", t.Type)), nil
+	}
+
+	rv := []string{}
+	for i := 0; i < int(t.Count); i++ {
+		switch t.format {
+		case RatVal:
+			n, d, _ := t.Rat2(i)
+			rv = append(rv, fmt.Sprintf(`"%v/%v"`, n, d))
+		case FloatVal:
+			v, _ := t.Float(i)
+			rv = append(rv, fmt.Sprintf("%v", v))
+		case IntVal:
+			v, _ := t.Int(i)
+			rv = append(rv, fmt.Sprintf("%v", v))
+		}
+	}
+	return []byte(fmt.Sprintf(`[%s]`, strings.Join(rv, ","))), nil
+}
+
+func nullString(in []byte) []byte {
+	rv := bytes.Buffer{}
+	rv.WriteByte('"')
+	for _, b := range in {
+		if unicode.IsPrint(rune(b)) {
+			rv.WriteByte(b)
+		}
+	}
+	rv.WriteByte('"')
+	rvb := rv.Bytes()
+	if utf8.Valid(rvb) {
+		return rvb
+	}
+	return []byte(`""`)
+}
+
+type wrongFmtErr struct {
+	From, To string
+}
+
+func (e *wrongFmtErr) Error() string {
+	return fmt.Sprintf("cannot convert tag type '%v' into '%v'", e.From, e.To)
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff.go
new file mode 100644
index 000000000..771e91878
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff.go
@@ -0,0 +1,153 @@
+// Package tiff implements TIFF decoding as defined in TIFF 6.0 specification at
+// http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf
+package tiff
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+)
+
+// ReadAtReader is used when decoding Tiff tags and directories
+type ReadAtReader interface {
+	io.Reader
+	io.ReaderAt
+}
+
+// Tiff provides access to a decoded tiff data structure.
+type Tiff struct {
+	// Dirs is an ordered slice of the tiff's Image File Directories (IFDs).
+	// The IFD at index 0 is IFD0.
+	Dirs []*Dir
+	// The tiff's byte-encoding (i.e. big/little endian).
+	Order binary.ByteOrder
+}
+
+// Decode parses tiff-encoded data from r and returns a Tiff struct that
+// reflects the structure and content of the tiff data. The first read from r
+// should be the first byte of the tiff-encoded data and not necessarily the
+// first byte of an os.File object.
+func Decode(r io.Reader) (*Tiff, error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, errors.New("tiff: could not read data")
+	}
+	buf := bytes.NewReader(data)
+
+	t := new(Tiff)
+
+	// read byte order
+	bo := make([]byte, 2)
+	if _, err = io.ReadFull(buf, bo); err != nil {
+		return nil, errors.New("tiff: could not read tiff byte order")
+	}
+	if string(bo) == "II" {
+		t.Order = binary.LittleEndian
+	} else if string(bo) == "MM" {
+		t.Order = binary.BigEndian
+	} else {
+		return nil, errors.New("tiff: could not read tiff byte order")
+	}
+
+	// check for special tiff marker
+	var sp int16
+	err = binary.Read(buf, t.Order, &sp)
+	if err != nil || 42 != sp {
+		return nil, errors.New("tiff: could not find special tiff marker")
+	}
+
+	// load offset to first IFD
+	var offset int32
+	err = binary.Read(buf, t.Order, &offset)
+	if err != nil {
+		return nil, errors.New("tiff: could not read offset to first IFD")
+	}
+
+	// load IFD's
+	var d *Dir
+	prev := offset
+	for offset != 0 {
+		// seek to offset
+		_, err := buf.Seek(int64(offset), 0)
+		if err != nil {
+			return nil, errors.New("tiff: seek to IFD failed")
+		}
+
+		if buf.Len() == 0 {
+			return nil, errors.New("tiff: seek offset after EOF")
+		}
+
+		// load the dir
+		d, offset, err = DecodeDir(buf, t.Order)
+		if err != nil {
+			return nil, err
+		}
+
+		if offset == prev {
+			return nil, errors.New("tiff: recursive IFD")
+		}
+		prev = offset
+
+		t.Dirs = append(t.Dirs, d)
+	}
+
+	return t, nil
+}
+
+func (tf *Tiff) String() string {
+	var buf bytes.Buffer
+	fmt.Fprint(&buf, "Tiff{")
+	for _, d := range tf.Dirs {
+		fmt.Fprintf(&buf, "%s, ", d.String())
+	}
+	fmt.Fprintf(&buf, "}")
+	return buf.String()
+}
+
+// Dir provides access to the parsed content of a tiff Image File Directory (IFD).
+type Dir struct {
+	Tags []*Tag
+}
+
+// DecodeDir parses a tiff-encoded IFD from r and returns a Dir object.  offset
+// is the offset to the next IFD.  The first read from r should be at the first
+// byte of the IFD. ReadAt offsets should generally be relative to the
+// beginning of the tiff structure (not relative to the beginning of the IFD).
+func DecodeDir(r ReadAtReader, order binary.ByteOrder) (d *Dir, offset int32, err error) {
+	d = new(Dir)
+
+	// get num of tags in ifd
+	var nTags int16
+	err = binary.Read(r, order, &nTags)
+	if err != nil {
+		return nil, 0, errors.New("tiff: failed to read IFD tag count: " + err.Error())
+	}
+
+	// load tags
+	for n := 0; n < int(nTags); n++ {
+		t, err := DecodeTag(r, order)
+		if err != nil {
+			return nil, 0, err
+		}
+		d.Tags = append(d.Tags, t)
+	}
+
+	// get offset to next ifd
+	err = binary.Read(r, order, &offset)
+	if err != nil {
+		return nil, 0, errors.New("tiff: falied to read offset to next IFD: " + err.Error())
+	}
+
+	return d, offset, nil
+}
+
+func (d *Dir) String() string {
+	s := "Dir{"
+	for _, t := range d.Tags {
+		s += t.String() + ", "
+	}
+	return s + "}"
+}
diff --git a/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff_test.go b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff_test.go
new file mode 100644
index 000000000..5db348dc8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/rwcarlsen/goexif/tiff/tiff_test.go
@@ -0,0 +1,235 @@
+package tiff
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"flag"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+var dataDir = flag.String("test_data_dir", ".", "Directory where the data files for testing are located")
+
+type input struct {
+	tgId   string
+	tpe    string
+	nVals  string
+	offset string
+	val    string
+}
+
+type output struct {
+	id    uint16
+	typ   DataType
+	count uint32
+	val   []byte
+}
+
+type tagTest struct {
+	big    input // big endian
+	little input // little endian
+	out    output
+}
+
+///////////////////////////////////////////////
+//// Big endian Tests /////////////////////////
+///////////////////////////////////////////////
+var set1 = []tagTest{
+	//////////// string type //////////////
+	tagTest{
+		//   {"TgId", "TYPE", "N-VALUES", "OFFSET--", "VAL..."},
+		input{"0003", "0002", "00000002", "11000000", ""},
+		input{"0300", "0200", "02000000", "11000000", ""},
+		output{0x0003, DataType(0x0002), 0x0002, []byte{0x11, 0x00}},
+	},
+	tagTest{
+		input{"0001", "0002", "00000006", "00000012", "111213141516"},
+		input{"0100", "0200", "06000000", "12000000", "111213141516"},
+		output{0x0001, DataType(0x0002), 0x0006, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16}},
+	},
+	//////////// int (1-byte) type ////////////////
+	tagTest{
+		input{"0001", "0001", "00000001", "11000000", ""},
+		input{"0100", "0100", "01000000", "11000000", ""},
+		output{0x0001, DataType(0x0001), 0x0001, []byte{0x11}},
+	},
+	tagTest{
+		input{"0001", "0001", "00000005", "00000010", "1112131415"},
+		input{"0100", "0100", "05000000", "10000000", "1112131415"},
+		output{0x0001, DataType(0x0001), 0x0005, []byte{0x11, 0x12, 0x13, 0x14, 0x15}},
+	},
+	tagTest{
+		input{"0001", "0006", "00000001", "11000000", ""},
+		input{"0100", "0600", "01000000", "11000000", ""},
+		output{0x0001, DataType(0x0006), 0x0001, []byte{0x11}},
+	},
+	tagTest{
+		input{"0001", "0006", "00000005", "00000010", "1112131415"},
+		input{"0100", "0600", "05000000", "10000000", "1112131415"},
+		output{0x0001, DataType(0x0006), 0x0005, []byte{0x11, 0x12, 0x13, 0x14, 0x15}},
+	},
+	//////////// int (2-byte) types ////////////////
+	tagTest{
+		input{"0001", "0003", "00000002", "11111212", ""},
+		input{"0100", "0300", "02000000", "11111212", ""},
+		output{0x0001, DataType(0x0003), 0x0002, []byte{0x11, 0x11, 0x12, 0x12}},
+	},
+	tagTest{
+		input{"0001", "0003", "00000003", "00000010", "111213141516"},
+		input{"0100", "0300", "03000000", "10000000", "111213141516"},
+		output{0x0001, DataType(0x0003), 0x0003, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16}},
+	},
+	tagTest{
+		input{"0001", "0008", "00000001", "11120000", ""},
+		input{"0100", "0800", "01000000", "11120000", ""},
+		output{0x0001, DataType(0x0008), 0x0001, []byte{0x11, 0x12}},
+	},
+	tagTest{
+		input{"0001", "0008", "00000003", "00000100", "111213141516"},
+		input{"0100", "0800", "03000000", "00100000", "111213141516"},
+		output{0x0001, DataType(0x0008), 0x0003, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16}},
+	},
+	//////////// int (4-byte) types ////////////////
+	tagTest{
+		input{"0001", "0004", "00000001", "11121314", ""},
+		input{"0100", "0400", "01000000", "11121314", ""},
+		output{0x0001, DataType(0x0004), 0x0001, []byte{0x11, 0x12, 0x13, 0x14}},
+	},
+	tagTest{
+		input{"0001", "0004", "00000002", "00000010", "1112131415161718"},
+		input{"0100", "0400", "02000000", "10000000", "1112131415161718"},
+		output{0x0001, DataType(0x0004), 0x0002, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}},
+	},
+	tagTest{
+		input{"0001", "0009", "00000001", "11121314", ""},
+		input{"0100", "0900", "01000000", "11121314", ""},
+		output{0x0001, DataType(0x0009), 0x0001, []byte{0x11, 0x12, 0x13, 0x14}},
+	},
+	tagTest{
+		input{"0001", "0009", "00000002", "00000011", "1112131415161819"},
+		input{"0100", "0900", "02000000", "11000000", "1112131415161819"},
+		output{0x0001, DataType(0x0009), 0x0002, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x19}},
+	},
+	//////////// rational types ////////////////////
+	tagTest{
+		input{"0001", "0005", "00000001", "00000010", "1112131415161718"},
+		input{"0100", "0500", "01000000", "10000000", "1112131415161718"},
+		output{0x0001, DataType(0x0005), 0x0001, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}},
+	},
+	tagTest{
+		input{"0001", "000A", "00000001", "00000011", "1112131415161819"},
+		input{"0100", "0A00", "01000000", "11000000", "1112131415161819"},
+		output{0x0001, DataType(0x000A), 0x0001, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x19}},
+	},
+	//////////// float types ///////////////////////
+	tagTest{
+		input{"0001", "0005", "00000001", "00000010", "1112131415161718"},
+		input{"0100", "0500", "01000000", "10000000", "1112131415161718"},
+		output{0x0001, DataType(0x0005), 0x0001, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}},
+	},
+	tagTest{
+		input{"0101", "000A", "00000001", "00000011", "1112131415161819"},
+		input{"0101", "0A00", "01000000", "11000000", "1112131415161819"},
+		output{0x0101, DataType(0x000A), 0x0001, []byte{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18, 0x19}},
+	},
+}
+
+func TestDecodeTag(t *testing.T) {
+	for i, tst := range set1 {
+		testSingle(t, binary.BigEndian, tst.big, tst.out, i)
+		testSingle(t, binary.LittleEndian, tst.little, tst.out, i)
+	}
+}
+
+func testSingle(t *testing.T, order binary.ByteOrder, in input, out output, i int) {
+	data := buildInput(in, order)
+	buf := bytes.NewReader(data)
+	tg, err := DecodeTag(buf, order)
+	if err != nil {
+		t.Errorf("(%v) tag %v%+v decode failed: %v", order, i, in, err)
+		return
+	}
+
+	if tg.Id != out.id {
+		t.Errorf("(%v) tag %v id decode: expected %v, got %v", order, i, out.id, tg.Id)
+	}
+	if tg.Type != out.typ {
+		t.Errorf("(%v) tag %v type decode: expected %v, got %v", order, i, out.typ, tg.Type)
+	}
+	if tg.Count != out.count {
+		t.Errorf("(%v) tag %v component count decode: expected %v, got %v", order, i, out.count, tg.Count)
+	}
+	if !bytes.Equal(tg.Val, out.val) {
+		t.Errorf("(%v) tag %v value decode: expected %v, got %v", order, i, out.val, tg.Val)
+	}
+}
+
+// buildInputBig creates a byte-slice based on big-endian ordered input
+func buildInput(in input, order binary.ByteOrder) []byte {
+	data := make([]byte, 0)
+	d, _ := hex.DecodeString(in.tgId)
+	data = append(data, d...)
+	d, _ = hex.DecodeString(in.tpe)
+	data = append(data, d...)
+	d, _ = hex.DecodeString(in.nVals)
+	data = append(data, d...)
+	d, _ = hex.DecodeString(in.offset)
+	data = append(data, d...)
+
+	if in.val != "" {
+		off := order.Uint32(d)
+		for i := 0; i < int(off)-12; i++ {
+			data = append(data, 0xFF)
+		}
+
+		d, _ = hex.DecodeString(in.val)
+		data = append(data, d...)
+	}
+
+	return data
+}
+
+func TestDecode(t *testing.T) {
+	name := filepath.Join(*dataDir, "sample1.tif")
+	f, err := os.Open(name)
+	if err != nil {
+		t.Fatalf("%v\n", err)
+	}
+
+	tif, err := Decode(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(tif)
+}
+
+func TestDecodeTag_blob(t *testing.T) {
+	buf := bytes.NewReader(data())
+	buf.Seek(10, 1)
+	tg, err := DecodeTag(buf, binary.LittleEndian)
+	if err != nil {
+		t.Fatalf("tag decode failed: %v", err)
+	}
+
+	t.Logf("tag: %v+\n", tg)
+	n, d, err := tg.Rat2(0)
+	if err != nil {
+		t.Fatalf("tag decoded wrong type: %v", err)
+	}
+	t.Logf("tag rat val: %v/%v\n", n, d)
+}
+
+func data() []byte {
+	s1 := "49492A000800000002001A0105000100"
+	s1 += "00002600000069870400010000001102"
+	s1 += "0000000000004800000001000000"
+
+	dat, err := hex.DecodeString(s1)
+	if err != nil {
+		panic("invalid string fixture")
+	}
+	return dat
+}
-- 
cgit v1.2.3-1-g7c22