├── .gitignore
├── LICENSE
├── README.md
├── cmd
    └── diff-image
    │   └── main.go
├── diff.go
├── example.png
├── test.sh
└── testdata
    └── 1
        ├── after.png
        ├── before.png
        └── diff.png


/.gitignore:
--------------------------------------------------------------------------------
1 | /tmp
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Naoki YAGUCHI
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # go-diff-image
 2 | 
 3 | A diff tool for images.
 4 | 
 5 | ## Installation
 6 | ```
 7 | $ go get -u github.com/murooka/go-diff-image/...
 8 | ```
 9 | 
10 | ## Usage
11 | ```bash
12 | diff-image -o=diff.png before.png after.png
13 | # open diff.png
14 | ```
15 | ## Example
16 | 
17 | ![example](https://raw.githubusercontent.com/murooka/go-diff-image/master/example.png)
18 | 


--------------------------------------------------------------------------------
/cmd/diff-image/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"fmt"
 6 | 	"image"
 7 | 	"image/png"
 8 | 	"log"
 9 | 	"os"
10 | 
11 | 	diffimage "github.com/murooka/go-diff-image"
12 | )
13 | 
14 | func mustOpen(filename string) *os.File {
15 | 	f, err := os.Open(filename)
16 | 	if err != nil {
17 | 		log.Fatal(err)
18 | 	}
19 | 
20 | 	return f
21 | }
22 | 
23 | func mustLoadImage(filename string) image.Image {
24 | 	f := mustOpen(filename)
25 | 	defer f.Close()
26 | 
27 | 	img, _, err := image.Decode(f)
28 | 	if err != nil {
29 | 		log.Fatal(err)
30 | 	}
31 | 
32 | 	return img
33 | }
34 | 
35 | func mustSaveImage(img image.Image, output string) {
36 | 	f, err := os.OpenFile(output, os.O_WRONLY|os.O_CREATE, 0644)
37 | 	defer f.Close()
38 | 	if err != nil {
39 | 		log.Fatal(err)
40 | 	}
41 | 
42 | 	png.Encode(f, img)
43 | }
44 | 
45 | func rate16(c uint32, r float64) uint16 {
46 | 	fc := float64(c)
47 | 	return uint16(65535 - (65535-fc)*r)
48 | }
49 | 
50 | func main() {
51 | 	var (
52 | 		output string
53 | 	)
54 | 	flag.StringVar(&output, "output", "diff.png", "output filename")
55 | 	flag.StringVar(&output, "o", "diff.png", "output filename")
56 | 	flag.Parse()
57 | 	args := flag.Args()
58 | 	if len(args) != 2 {
59 | 		fmt.Println("usage: imagediff [<option>...] <image1> <image2>")
60 | 		os.Exit(1)
61 | 	}
62 | 
63 | 	img1 := mustLoadImage(args[0])
64 | 	img2 := mustLoadImage(args[1])
65 | 
66 | 	dst := diffimage.DiffImage(img1, img2)
67 | 
68 | 	mustSaveImage(dst, output)
69 | }
70 | 


--------------------------------------------------------------------------------
/diff.go:
--------------------------------------------------------------------------------
  1 | package diffimage
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"encoding/base64"
  6 | 	"image"
  7 | 	"image/color"
  8 | 	"io"
  9 | 	"log"
 10 | 	"strings"
 11 | 
 12 | 	"github.com/sergi/go-diff/diffmatchpatch"
 13 | )
 14 | 
 15 | type HashLines struct {
 16 | 	Lines []string
 17 | }
 18 | 
 19 | func writeUint32(w io.Writer, n uint32) {
 20 | 	w.Write([]byte{
 21 | 		byte((n >> 24) & 0xff),
 22 | 		byte((n >> 16) & 0xff),
 23 | 		byte((n >> 8) & 0xff),
 24 | 		byte((n >> 0) & 0xff),
 25 | 	})
 26 | }
 27 | 
 28 | func readUint32(r io.Reader) uint32 {
 29 | 	var bs [4]byte
 30 | 	r.Read(bs[:])
 31 | 	n := uint32(bs[0])
 32 | 	for i := 1; i < 4; i++ {
 33 | 		n = n << 8
 34 | 		n += uint32(bs[i])
 35 | 	}
 36 | 
 37 | 	return n
 38 | }
 39 | 
 40 | func encodeLine(img image.Image, y int) string {
 41 | 	buf := &bytes.Buffer{}
 42 | 	w := img.Bounds().Size().X
 43 | 	for x := 0; x < w; x++ {
 44 | 		r, g, b, a := img.At(x, y).RGBA()
 45 | 		writeUint32(buf, r)
 46 | 		writeUint32(buf, g)
 47 | 		writeUint32(buf, b)
 48 | 		writeUint32(buf, a)
 49 | 	}
 50 | 
 51 | 	return base64.RawURLEncoding.EncodeToString(buf.Bytes())
 52 | }
 53 | 
 54 | func decodeLine(s string) []color.Color {
 55 | 	bs, err := base64.RawURLEncoding.DecodeString(s)
 56 | 	if err != nil {
 57 | 		log.Fatal(err)
 58 | 	}
 59 | 
 60 | 	buf := bytes.NewBuffer(bs)
 61 | 	colors := make([]color.Color, 0)
 62 | 	for buf.Len() != 0 {
 63 | 		r := readUint32(buf)
 64 | 		g := readUint32(buf)
 65 | 		b := readUint32(buf)
 66 | 		a := readUint32(buf)
 67 | 		c := color.NRGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
 68 | 		colors = append(colors, c)
 69 | 	}
 70 | 
 71 | 	return colors
 72 | }
 73 | 
 74 | func disassembleDiffs(diffs []diffmatchpatch.Diff) []diffmatchpatch.Diff {
 75 | 	res := make([]diffmatchpatch.Diff, 0, len(diffs))
 76 | 
 77 | 	for _, diff := range diffs {
 78 | 		lines := strings.Split(diff.Text, "\n")
 79 | 		for _, line := range lines {
 80 | 			res = append(res, diffmatchpatch.Diff{Type: diff.Type, Text: line})
 81 | 		}
 82 | 	}
 83 | 
 84 | 	return res
 85 | }
 86 | 
 87 | func diff(from, to []string) []diffmatchpatch.Diff {
 88 | 	dmp := diffmatchpatch.New()
 89 | 	a, b, c := dmp.DiffLinesToChars(strings.Join(from, "\n"), strings.Join(to, "\n"))
 90 | 	diffs := dmp.DiffMain(a, b, false)
 91 | 	result := dmp.DiffCharsToLines(diffs, c)
 92 | 
 93 | 	return disassembleDiffs(result)
 94 | }
 95 | 
 96 | func blend(dst, src color.Color) color.Color {
 97 | 	srcR, srcG, srcB, srcA := src.RGBA()
 98 | 	dstR, dstG, dstB, _ := dst.RGBA()
 99 | 	srcAp := float64(srcA) / 0xffff
100 | 
101 | 	outR := float64(srcR)*srcAp + float64(dstR)*(1-srcAp)
102 | 	outG := float64(srcG)*srcAp + float64(dstG)*(1-srcAp)
103 | 	outB := float64(srcB)*srcAp + float64(dstB)*(1-srcAp)
104 | 
105 | 	return color.NRGBA64{
106 | 		uint16(outR),
107 | 		uint16(outG),
108 | 		uint16(outB),
109 | 		0xffff,
110 | 	}
111 | }
112 | 
113 | func max(a, b int) int {
114 | 	if a > b {
115 | 		return a
116 | 	}
117 | 	return b
118 | }
119 | 
120 | func DiffImage(img1, img2 image.Image) image.Image {
121 | 	sz1 := img1.Bounds().Size()
122 | 	sz2 := img2.Bounds().Size()
123 | 	w := max(sz1.X, sz2.X)
124 | 
125 | 	lines1 := make([]string, 0, sz1.Y)
126 | 	for y := 0; y < sz1.Y; y++ {
127 | 		lines1 = append(lines1, encodeLine(img1, y))
128 | 	}
129 | 
130 | 	lines2 := make([]string, 0, sz2.Y)
131 | 	for y := 0; y < sz2.Y; y++ {
132 | 		lines2 = append(lines2, encodeLine(img2, y))
133 | 	}
134 | 
135 | 	diffs := diff(lines1, lines2)
136 | 	diffImg := image.NewRGBA(image.Rect(0, 0, w, len(diffs)))
137 | 	for y, diff := range diffs {
138 | 		colors := decodeLine(diff.Text)
139 | 
140 | 		switch diff.Type {
141 | 		case diffmatchpatch.DiffDelete:
142 | 			red := color.RGBA64{0xffff, 0, 0, 0x4000}
143 | 			for x, c := range colors {
144 | 				diffImg.Set(x, y, blend(c, red))
145 | 			}
146 | 		case diffmatchpatch.DiffInsert:
147 | 			green := color.RGBA64{0, 0xffff, 0, 0x4000}
148 | 			for x, c := range colors {
149 | 				diffImg.Set(x, y, blend(c, green))
150 | 			}
151 | 		case diffmatchpatch.DiffEqual:
152 | 			for x, c := range colors {
153 | 				diffImg.Set(x, y, c)
154 | 			}
155 | 		}
156 | 	}
157 | 
158 | 	return diffImg
159 | }
160 | 


--------------------------------------------------------------------------------
/example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murooka/go-diff-image/8c413ad9b24caecff3d9ab1be105c6506260c86f/example.png


--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | for dir in testdata/*; do
4 |   echo $dir
5 |   diff-image -o=$dir/diff.png $dir/before.png $dir/after.png
6 | done
7 | 


--------------------------------------------------------------------------------
/testdata/1/after.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murooka/go-diff-image/8c413ad9b24caecff3d9ab1be105c6506260c86f/testdata/1/after.png


--------------------------------------------------------------------------------
/testdata/1/before.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murooka/go-diff-image/8c413ad9b24caecff3d9ab1be105c6506260c86f/testdata/1/before.png


--------------------------------------------------------------------------------
/testdata/1/diff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murooka/go-diff-image/8c413ad9b24caecff3d9ab1be105c6506260c86f/testdata/1/diff.png


--------------------------------------------------------------------------------