Open platform to collect and prioritize feedback
refactoring: use external dependency for imaging (#695)
Guilherme Oenning67661a499bd2
diff --git a/Gopkg.lock b/Gopkg.lockindex c18a2a8ae..55839c34f 100644--- a/Gopkg.lock+++ b/Gopkg.lock@@ -60,6 +60,14 @@revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"version = "v3.2.0"+[[projects]]+ digest = "1:2694597a20d303502ad1b7f1cc688977c7dc34da732ccf4d27e98b552cceed5b"+ name = "github.com/disintegration/imaging"+ packages = ["."]+ pruneopts = "UT"+ revision = "0bd5694c78c9c3d9a3cd06a706a8f3c59296a9ac"+ version = "v1.5.0"+[[projects]]branch = "master"digest = "1:c7073f7f18a2be8b8a31e8e23fe16c2141c3cbd0170c3eacea8f167438f3b655"@@ -159,13 +167,16 @@[[projects]]branch = "master"- digest = "1:47469b46cc6c4cd691dbab8d43899b9afddb2855600719ed5db91bf1532cf772"+ digest = "1:3f27b2eb37fc7c73de41226ec8b21066019934150c96d87f6e76354945a6f005"name = "golang.org/x/image"packages = [+ "bmp","draw","font","math/f64","math/fixed",+ "tiff",+ "tiff/lzw",]pruneopts = "UT"revision = "e20db36d77bd0cb36cea8fe49d5c37d82d21591f"@@ -226,6 +237,7 @@"github.com/aws/aws-sdk-go/aws/session","github.com/aws/aws-sdk-go/service/s3","github.com/dgrijalva/jwt-go",+ "github.com/disintegration/imaging","github.com/goenning/letteravatar","github.com/gosimple/slug","github.com/joeshaw/envdecode",diff --git a/Gopkg.toml b/Gopkg.tomlindex dc30484a9..a9c649287 100644--- a/Gopkg.toml+++ b/Gopkg.toml@@ -41,6 +41,10 @@ ignored = ["github.com/magefile/mage/mg","github.com/magefile/mage/sh"]version = "v1.16.3"name = "github.com/aws/aws-sdk-go"+[[constraint]]+ version = "v1.5.0"+ name = "github.com/disintegration/imaging"+[[constraint]]branch = "master"name = "github.com/joeshaw/envdecode"diff --git a/app/cmd/routes.go b/app/cmd/routes.goindex 8ebfb84e0..3d1bfc593 100644--- a/app/cmd/routes.go+++ b/app/cmd/routes.go@@ -31,7 +31,7 @@ func routes(r *web.Engine) *web.Engine {{assets.Use(middlewares.CORS())assets.Use(middlewares.ClientCache(365 * 24 * time.Hour))- assets.Get("/favicon/:size", handlers.Favicon())+ assets.Get("/favicon", handlers.Favicon())assets.Static("/assets/*filepath", "dist")}@@ -67,8 +67,8 @@ func routes(r *web.Engine) *web.Engine {tenantAssets.Get("/avatars/:size/:id/:name", handlers.Avatar())tenantAssets.Use(middlewares.ClientCache(30 * 24 * time.Hour))- tenantAssets.Get("/favicon/:size/*bkey", handlers.Favicon())- tenantAssets.Get("/images/:size/*bkey", handlers.ViewUploadedImage())+ tenantAssets.Get("/favicon/*bkey", handlers.Favicon())+ tenantAssets.Get("/images/*bkey", handlers.ViewUploadedImage())tenantAssets.Get("/custom/:md5.css", func(c web.Context) error {return c.Blob(http.StatusOK, "text/css", []byte(c.Tenant().CustomCSS))})diff --git a/app/handlers/images.go b/app/handlers/images.goindex f05315935..f6bf1554c 100644--- a/app/handlers/images.go+++ b/app/handlers/images.go@@ -89,21 +89,24 @@ func Favicon() web.HandlerFunc {}}- size, err := c.ParamAsInt("size")+ size, err := c.QueryParamAsInt("size")if err != nil {- return c.NotFound()+ return c.Failure(err)}- bytes, err = img.Resize(bytes, size, 5)- if err != nil {- return c.Failure(err)+ opts := []img.ImageOperation{}+ if size > 0 {+ opts = append(opts, img.Padding(size*10/100))+ opts = append(opts, img.Resize(size))}if c.QueryParam("bg") != "" {- bytes, err = img.ChangeBackground(bytes, color.White)- if err != nil {- return c.Failure(err)- }+ opts = append(opts, img.ChangeBackground(color.White))+ }++ bytes, err = img.Apply(bytes, opts...)+ if err != nil {+ return c.Failure(err)}return c.Image(contentType, bytes)@@ -115,9 +118,9 @@ func ViewUploadedImage() web.HandlerFunc {return func(c web.Context) error {bkey := c.Param("bkey")- size, err := c.ParamAsInt("size")+ size, err := c.QueryParamAsInt("size")if err != nil {- return c.NotFound()+ return c.Failure(err)}logo, err := c.Services().Blobs.Get(bkey)@@ -125,9 +128,12 @@ func ViewUploadedImage() web.HandlerFunc {return c.Failure(err)}- bytes, err := img.Resize(logo.Object, size, 0)- if err != nil {- return c.Failure(err)+ bytes := logo.Object+ if size > 0 {+ bytes, err = img.Apply(bytes, img.Resize(size))+ if err != nil {+ return c.Failure(err)+ }}return c.Image(logo.ContentType, bytes)diff --git a/app/pkg/img/img.go b/app/pkg/img/img.goindex b6d2361c3..fb55666e3 100644--- a/app/pkg/img/img.go+++ b/app/pkg/img/img.go@@ -5,12 +5,11 @@ import ("image""image/color"- "image/gif"- "image/jpeg""image/png"stdError "errors"+ "github.com/disintegration/imaging""github.com/getfider/fider/app/pkg/errors""golang.org/x/image/draw")@@ -29,8 +28,8 @@ type File struct {func Parse(file []byte) (*File, error) {reader := bytes.NewReader(file)- image, _, err := image.DecodeConfig(reader)- if err != nil {+ image, format, err := image.DecodeConfig(reader)+ if err != nil || (format != "png" && format != "gif" && format != "jpeg") {return nil, ErrNotSupported}@@ -41,45 +40,63 @@ func Parse(file []byte) (*File, error) {}, nil}+//ImageOperation is an operation that can be performed on an image and retun a modified version of it+type ImageOperation func(image.Image, string) image.Image+//ChangeBackground will change given image transparent background to given color-func ChangeBackground(file []byte, bgColor color.Color) ([]byte, error) {- src, format, err := decode(file)- if err != nil {- return nil, err+func ChangeBackground(bgColor color.Color) ImageOperation {+ return func(src image.Image, format string) image.Image {+ if format != "png" {+ return src+ }++ dst := image.NewRGBA(src.Bounds())+ draw.Draw(dst, dst.Bounds(), &image.Uniform{bgColor}, image.Point{}, draw.Src)+ draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Over)+ return dst}+}- if format != "png" {- return file, nil- }+//Padding adds a padding based on given value+func Padding(padding int) ImageOperation {+ return func(src image.Image, format string) image.Image {+ if padding == 0 {+ return src+ }- dst := image.NewRGBA(src.Bounds())- draw.Draw(dst, dst.Bounds(), &image.Uniform{bgColor}, image.Point{}, draw.Src)- draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Over)- return encode(dst, format)+ srcBounds := src.Bounds()+ srcW, srcH := srcBounds.Dx(), srcBounds.Dy()++ dst := image.NewRGBA(image.Rect(0, 0, srcW+padding, srcH+padding))+ draw.Draw(dst, dst.Bounds(), src, image.Pt(-padding/2, -padding/2), draw.Src)+ return dst+ }}//Resize image based on given size-func Resize(file []byte, size int, padding int) ([]byte, error) {- src, format, err := decode(file)+func Resize(size int) ImageOperation {+ return func(src image.Image, format string) image.Image {+ b := src.Bounds()+ srcW, srcH := b.Dx(), b.Dy()+ if size >= srcH && size >= srcW {+ return src+ }+ return imaging.Resize(src, size, 0, imaging.Lanczos)+ }+}++// Apply a list of operations on a given image+func Apply(input []byte, operations ...ImageOperation) ([]byte, error) {+ img, format, err := decode(input)if err != nil {return nil, err}- //TODO: Very slow to resize images with aspect ratio different than 1:1-- srcBounds := src.Bounds()- srcW, srcH := srcBounds.Dx(), srcBounds.Dy()- if (srcW <= size && srcH <= size) || srcW != srcH {- size = srcW+ for _, op := range operations {+ img = op(img, format)}- padding = size * padding / 100- dst := image.NewRGBA(image.Rect(0, 0, size, size))- dstBounds := image.Rect(padding, padding, size-padding, size-padding)- srcBounds = image.Rect(0, 0, srcBounds.Max.X, srcBounds.Max.Y)- draw.CatmullRom.Scale(dst, dstBounds, src, srcBounds, draw.Src, nil)-- return encode(dst, format)+ return encode(img, format)}func decode(file []byte) (image.Image, string, error) {@@ -91,19 +108,16 @@ func decode(file []byte) (image.Image, string, error) {}func encode(img image.Image, format string) ([]byte, error) {- var err errorwriter := new(bytes.Buffer)- if format == "png" {- err = png.Encode(writer, img)- } else if format == "jpeg" {- err = jpeg.Encode(writer, img, nil)- } else if format == "gif" {- err = gif.Encode(writer, img, nil)- }+ f, _ := imaging.FormatFromExtension(format)+ err := imaging.Encode(+ writer, img, f,+ imaging.PNGCompressionLevel(png.BestCompression),+ imaging.JPEGQuality(95),+ )if err != nil {return nil, errors.Wrap(err, "failed to encode image to '%s'", format)}-return writer.Bytes(), nil}diff --git a/app/pkg/img/img_test.go b/app/pkg/img/img_test.goindex bb3a27f7c..44bfd40fc 100644--- a/app/pkg/img/img_test.go+++ b/app/pkg/img/img_test.go@@ -3,6 +3,7 @@ package img_testimport ("image/color""io/ioutil"+ "os""testing". "github.com/getfider/fider/app/pkg/assert"@@ -51,26 +52,36 @@ var resizeTestCases = []struct {resizedFileName stringsize intpadding int+ skipCI bool}{- {"/app/pkg/img/testdata/logo1.png", "/app/pkg/img/testdata/logo1-200x200.png", 200, 0},- //TODO: Very slow to resize images with aspect ratio different than 1:1- // {"/app/pkg/img/testdata/logo2.jpg", "/app/pkg/img/testdata/logo2-200x200.jpg", 200, 0},- // {"/app/pkg/img/testdata/logo3.gif", "/app/pkg/img/testdata/logo3-200x200.gif", 200, 0},- {"/app/pkg/img/testdata/logo4.png", "/app/pkg/img/testdata/logo4-100x100.png", 100, 0},- {"/app/pkg/img/testdata/logo5.png", "/app/pkg/img/testdata/logo5-200x200.png", 200, 0},- {"/app/pkg/img/testdata/logo6.jpg", "/app/pkg/img/testdata/logo6-200x200.jpg", 200, 0},- {"/app/pkg/img/testdata/logo7.gif", "/app/pkg/img/testdata/logo7-200x200.gif", 200, 0},- {"/app/pkg/img/testdata/logo7.gif", "/app/pkg/img/testdata/logo7-1000-1000.gif", 1000, 0},+ {"/app/pkg/img/testdata/logo1.png", "/app/pkg/img/testdata/logo1-200x200.png", 200, 0, false},+ {"/app/pkg/img/testdata/logo2.jpg", "/app/pkg/img/testdata/logo2-200w.jpg", 200, 0, true},+ {"/app/pkg/img/testdata/logo2.jpg", "/app/pkg/img/testdata/logo2-200w-pad20.jpg", 200, 20, true},+ {"/app/pkg/img/testdata/logo3.gif", "/app/pkg/img/testdata/logo3-200w.gif", 200, 0, true},+ {"/app/pkg/img/testdata/logo4.png", "/app/pkg/img/testdata/logo4-100x100.png", 100, 0, false},+ {"/app/pkg/img/testdata/logo5.png", "/app/pkg/img/testdata/logo5-200x200.png", 200, 0, false},+ {"/app/pkg/img/testdata/logo6.jpg", "/app/pkg/img/testdata/logo6-200x200.jpg", 200, 0, false},+ {"/app/pkg/img/testdata/logo7.gif", "/app/pkg/img/testdata/logo7-200x200.gif", 200, 0, false},+ {"/app/pkg/img/testdata/logo7.gif", "/app/pkg/img/testdata/logo7-1000-1000.gif", 1000, 0, false},}func TestImageResize(t *testing.T) {RegisterT(t)for _, testCase := range resizeTestCases {+ // we don't run it on CI because it's way too slow, we need to investigate why+ if testCase.skipCI && os.Getenv("CI") == "true" {+ continue+ }+bytes, err := ioutil.ReadFile(env.Path(testCase.fileName))Expect(err).IsNil()- resized, err := img.Resize(bytes, testCase.size, testCase.padding)+ resized, err := img.Apply(+ bytes,+ img.Resize(testCase.size),+ img.Padding(testCase.padding),+ )Expect(err).IsNil()expected, err := ioutil.ReadFile(env.Path(testCase.resizedFileName))@@ -96,7 +107,7 @@ func TestImageChangeBackground(t *testing.T) {bytes, err := ioutil.ReadFile(env.Path(testCase.fileName))Expect(err).IsNil()- withColor, err := img.ChangeBackground(bytes, testCase.bgColor)+ withColor, err := img.Apply(bytes, img.ChangeBackground(testCase.bgColor))Expect(err).IsNil()expected, err := ioutil.ReadFile(env.Path(testCase.whiteColorFileName))diff --git a/app/pkg/img/testdata/logo1-200x200.png b/app/pkg/img/testdata/logo1-200x200.pngindex 385c48aa7..92f361640 100755Binary files a/app/pkg/img/testdata/logo1-200x200.png and b/app/pkg/img/testdata/logo1-200x200.png differdiff --git a/app/pkg/img/testdata/logo1-black.png b/app/pkg/img/testdata/logo1-black.pngindex f7f0042aa..3d8eaf8a1 100755Binary files a/app/pkg/img/testdata/logo1-black.png and b/app/pkg/img/testdata/logo1-black.png differdiff --git a/app/pkg/img/testdata/logo1-white.png b/app/pkg/img/testdata/logo1-white.pngindex 50e0b781f..41b97a530 100755Binary files a/app/pkg/img/testdata/logo1-white.png and b/app/pkg/img/testdata/logo1-white.png differdiff --git a/app/pkg/img/testdata/logo2-200w-pad20.jpg b/app/pkg/img/testdata/logo2-200w-pad20.jpgnew file mode 100755index 000000000..bb2fb057bBinary files /dev/null and b/app/pkg/img/testdata/logo2-200w-pad20.jpg differdiff --git a/app/pkg/img/testdata/logo2-200w.jpg b/app/pkg/img/testdata/logo2-200w.jpgnew file mode 100755index 000000000..c21c208d6Binary files /dev/null and b/app/pkg/img/testdata/logo2-200w.jpg differdiff --git a/app/pkg/img/testdata/logo2-200x200.jpg b/app/pkg/img/testdata/logo2-200x200.jpgdeleted file mode 100755index 76c4ec57f..000000000Binary files a/app/pkg/img/testdata/logo2-200x200.jpg and /dev/null differdiff --git a/app/pkg/img/testdata/logo3-200w.gif b/app/pkg/img/testdata/logo3-200w.gifnew file mode 100755index 000000000..61ed1f9b0Binary files /dev/null and b/app/pkg/img/testdata/logo3-200w.gif differdiff --git a/app/pkg/img/testdata/logo3-200x200.gif b/app/pkg/img/testdata/logo3-200x200.gifdeleted file mode 100755index 4c2fc35f7..000000000Binary files a/app/pkg/img/testdata/logo3-200x200.gif and /dev/null differdiff --git a/app/pkg/img/testdata/logo4-100x100.png b/app/pkg/img/testdata/logo4-100x100.pngindex 3c593b798..00855d298 100755Binary files a/app/pkg/img/testdata/logo4-100x100.png and b/app/pkg/img/testdata/logo4-100x100.png differdiff --git a/app/pkg/img/testdata/logo5-200x200.png b/app/pkg/img/testdata/logo5-200x200.pngindex f647ece27..e48d06c3b 100755Binary files a/app/pkg/img/testdata/logo5-200x200.png and b/app/pkg/img/testdata/logo5-200x200.png differdiff --git a/app/pkg/img/testdata/logo6-200x200.jpg b/app/pkg/img/testdata/logo6-200x200.jpgindex 449aa2729..ce2ebe113 100755Binary files a/app/pkg/img/testdata/logo6-200x200.jpg and b/app/pkg/img/testdata/logo6-200x200.jpg differdiff --git a/app/pkg/img/testdata/logo7-1000-1000.gif b/app/pkg/img/testdata/logo7-1000-1000.gifindex da4eba819..00202032f 100755Binary files a/app/pkg/img/testdata/logo7-1000-1000.gif and b/app/pkg/img/testdata/logo7-1000-1000.gif differdiff --git a/app/pkg/img/testdata/logo7-200x200.gif b/app/pkg/img/testdata/logo7-200x200.gifindex 2cfce3cbb..6997d307c 100755Binary files a/app/pkg/img/testdata/logo7-200x200.gif and b/app/pkg/img/testdata/logo7-200x200.gif differdiff --git a/app/pkg/web/context.go b/app/pkg/web/context.goindex 19c6ac6e4..bbe1e9515 100644--- a/app/pkg/web/context.go+++ b/app/pkg/web/context.go@@ -433,6 +433,19 @@ func (ctx *Context) QueryParam(key string) string {return ctx.Request.URL.Query().Get(key)}+//QueryParamAsInt returns querystring parameter for given key+func (ctx *Context) QueryParamAsInt(key string) (int, error) {+ value := ctx.QueryParam(key)+ if value == "" {+ return 0, nil+ }+ intValue, err := strconv.Atoi(value)+ if err != nil {+ return 0, errors.Wrap(err, "failed to parse %s to integer", value)+ }+ return intValue, nil+}+//QueryParamAsArray returns querystring parameter for given key as an arrayfunc (ctx *Context) QueryParamAsArray(key string) []string {param := ctx.QueryParam(key)@@ -557,7 +570,7 @@ func (ctx *Context) TenantAssetsURL(path string, a ...interface{}) string {// LogoURL return the full URL to the tenant-specific logo URLfunc (ctx *Context) LogoURL() string {if ctx.Tenant() != nil && ctx.Tenant().LogoBlobKey != "" {- return ctx.TenantAssetsURL("/images/200/%s", ctx.Tenant().LogoBlobKey)+ return ctx.TenantAssetsURL("/images/%s?size=200", ctx.Tenant().LogoBlobKey)}return "https://getfider.com/images/logo-100x100.png"}@@ -565,9 +578,9 @@ func (ctx *Context) LogoURL() string {// FaviconURL return the full URL to the tenant-specific favicon URLfunc (ctx *Context) FaviconURL() string {if ctx.Tenant() != nil && ctx.Tenant().LogoBlobKey != "" {- return ctx.TenantAssetsURL("/favicon/:size/%s", ctx.Tenant().LogoBlobKey)+ return ctx.TenantAssetsURL("/favicon/%s", ctx.Tenant().LogoBlobKey)}- return ctx.GlobalAssetsURL("/favicon/:size")+ return ctx.GlobalAssetsURL("/favicon")}// SetCanonicalURL sets the canonical link on the HTTP Response Headersdiff --git a/app/pkg/web/testdata/basic.html b/app/pkg/web/testdata/basic.htmlindex a7d701ab1..12d96431b 100755--- a/app/pkg/web/testdata/basic.html+++ b/app/pkg/web/testdata/basic.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/64' sizes="64x64" type="image/png">- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/192' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon/180?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon?size=180&bg=white' sizes="180x180" type="image/png">@@ -38,7 +38,7 @@<script id="server-data" type="application/json">- {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon/:size","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"Fider"}+ {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"Fider"}</script><script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=default,fetch" crossorigin="anonymous"></script>diff --git a/app/pkg/web/testdata/canonical.html b/app/pkg/web/testdata/canonical.htmlindex 349ee2dda..cb9ba5ff8 100755--- a/app/pkg/web/testdata/canonical.html+++ b/app/pkg/web/testdata/canonical.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/64' sizes="64x64" type="image/png">- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/192' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon/180?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon?size=180&bg=white' sizes="180x180" type="image/png"><link rel="canonical" href="http://feedback.demo.org" />@@ -40,7 +40,7 @@<script id="server-data" type="application/json">- {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__canonicalURL":"http://feedback.demo.org","__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon/:size","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"Fider"}+ {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__canonicalURL":"http://feedback.demo.org","__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"Fider"}</script><script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=default,fetch" crossorigin="anonymous"></script>diff --git a/app/pkg/web/testdata/chunk.html b/app/pkg/web/testdata/chunk.htmlindex 39e294085..a99ee7f0c 100644--- a/app/pkg/web/testdata/chunk.html+++ b/app/pkg/web/testdata/chunk.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/64' sizes="64x64" type="image/png">- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/192' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon/180?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon?size=180&bg=white' sizes="180x180" type="image/png">@@ -45,7 +45,7 @@<script id="server-data" type="application/json">- {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__chunkAssets":{"CSS":["/assets/css/Test.page.css"],"JS":["/assets/js/Test.page.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon/:size","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"Fider"}+ {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__chunkAssets":{"CSS":["/assets/css/Test.page.css"],"JS":["/assets/js/Test.page.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"Fider"}</script><script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=default,fetch" crossorigin="anonymous"></script>diff --git a/app/pkg/web/testdata/props.html b/app/pkg/web/testdata/props.htmlindex bdb947b12..fb3a7ec8f 100755--- a/app/pkg/web/testdata/props.html+++ b/app/pkg/web/testdata/props.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/64' sizes="64x64" type="image/png">- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/192' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon/180?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon?size=180&bg=white' sizes="180x180" type="image/png">@@ -38,7 +38,7 @@<script id="server-data" type="application/json">- {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__description":"My Page Description","__favicon":"https://demo.test.fider.io:3000/favicon/:size","__logo":"https://getfider.com/images/logo-100x100.png","__props":{"array":["1","2"],"number":2,"object":{"key1":"value1","key2":"value2"}},"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"My Page Title · Fider"}+ {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__description":"My Page Description","__favicon":"https://demo.test.fider.io:3000/favicon","__logo":"https://getfider.com/images/logo-100x100.png","__props":{"array":["1","2"],"number":2,"object":{"key1":"value1","key2":"value2"}},"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"My Page Title · Fider"}</script><script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=default,fetch" crossorigin="anonymous"></script>diff --git a/app/pkg/web/testdata/tenant.html b/app/pkg/web/testdata/tenant.htmlindex 158913ad9..86bb48ee6 100755--- a/app/pkg/web/testdata/tenant.html+++ b/app/pkg/web/testdata/tenant.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/64' sizes="64x64" type="image/png">- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/192' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon/180?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon?size=180&bg=white' sizes="180x180" type="image/png">@@ -40,7 +40,7 @@<script id="server-data" type="application/json">- {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon/:size","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":{"id":0,"name":"Game of Thrones","subdomain":"","invitation":"","welcomeMessage":"","cname":"","isPrivate":false,"logoBlobKey":""},"__title":"Game of Thrones"}+ {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__favicon":"https://demo.test.fider.io:3000/favicon","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":{"id":0,"name":"Game of Thrones","subdomain":"","invitation":"","welcomeMessage":"","cname":"","isPrivate":false,"logoBlobKey":""},"__title":"Game of Thrones"}</script><script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=default,fetch" crossorigin="anonymous"></script>diff --git a/app/pkg/web/testdata/user.html b/app/pkg/web/testdata/user.htmlindex 6bdf6b0af..3d9293deb 100755--- a/app/pkg/web/testdata/user.html+++ b/app/pkg/web/testdata/user.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/64' sizes="64x64" type="image/png">- <link rel="icon" href='https://demo.test.fider.io:3000/favicon/192' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon/180?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='https://demo.test.fider.io:3000/favicon?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='https://demo.test.fider.io:3000/favicon?size=180&bg=white' sizes="180x180" type="image/png">@@ -38,7 +38,7 @@<script id="server-data" type="application/json">- {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__description":"My Page Description","__favicon":"https://demo.test.fider.io:3000/favicon/:size","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"My Page Title · Fider","__user":{"email":"[email protected]","id":0,"isAdministrator":true,"isCollaborator":true,"name":"Jon Snow","role":"administrator","status":"active"}}+ {"__assets":{"CSS":["/assets/css/file1.css"],"JS":["/assets/js/file1.js","/assets/js/file2.js"]},"__contextID":"CONTEXT_ID","__currentURL":"https://demo.test.fider.io:3000/","__description":"My Page Description","__favicon":"https://demo.test.fider.io:3000/favicon","__logo":"https://getfider.com/images/logo-100x100.png","__props":null,"__settings":{"baseURL":"https://demo.test.fider.io:3000","buildTime":"","compiler":"","domain":"","environment":"","globalAssetsURL":"https://demo.test.fider.io:3000","googleAnalytics":"","hasLegal":false,"mode":"","oauth":[],"tenantAssetsURL":"https://demo.test.fider.io:3000","version":""},"__tenant":null,"__title":"My Page Title · Fider","__user":{"email":"[email protected]","id":0,"isAdministrator":true,"isCollaborator":true,"name":"Jon Snow","role":"administrator","status":"active"}}</script><script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=default,fetch" crossorigin="anonymous"></script>diff --git a/public/services/utils.ts b/public/services/utils.tsindex 9aac465f8..1b13db208 100644--- a/public/services/utils.ts+++ b/public/services/utils.ts@@ -125,7 +125,7 @@ export const isCookieEnabled = (): boolean => {export const uploadedImageURL = (bkey: string, size: number): string | undefined => {if (bkey) {- return `${Fider.settings.tenantAssetsURL}/images/${size}/${bkey}`;+ return `${Fider.settings.tenantAssetsURL}/images/${bkey}?size=${size}`;}return undefined;};diff --git a/vendor/github.com/disintegration/imaging/.travis.yml b/vendor/github.com/disintegration/imaging/.travis.ymlnew file mode 100644index 000000000..89370edcb--- /dev/null+++ b/vendor/github.com/disintegration/imaging/.travis.yml@@ -0,0 +1,13 @@+language: go+go:+ - "1.7.x"+ - "1.8.x"+ - "1.9.x"+ - "1.10.x"++before_install:+ - go get github.com/mattn/goveralls++script:+ - go test -v -race -cover+ - $GOPATH/bin/goveralls -service=travis-cidiff --git a/vendor/github.com/disintegration/imaging/LICENSE b/vendor/github.com/disintegration/imaging/LICENSEnew file mode 100644index 000000000..c68f7ab7c--- /dev/null+++ b/vendor/github.com/disintegration/imaging/LICENSE@@ -0,0 +1,21 @@+The MIT License (MIT)++Copyright (c) 2012-2018 Grigory Dryapak++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to deal+in the Software without restriction, including without limitation the rights+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+copies of the Software, and to permit persons to whom the Software is+furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in all+copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+SOFTWARE.\ No newline at end of filediff --git a/vendor/github.com/disintegration/imaging/README.md b/vendor/github.com/disintegration/imaging/README.mdnew file mode 100644index 000000000..c7ee30fc8--- /dev/null+++ b/vendor/github.com/disintegration/imaging/README.md@@ -0,0 +1,188 @@+# Imaging++[](https://godoc.org/github.com/disintegration/imaging)+[](https://travis-ci.org/disintegration/imaging)+[](https://coveralls.io/github/disintegration/imaging?branch=master)+[](https://goreportcard.com/report/github.com/disintegration/imaging)++Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).++All the image processing functions provided by the package accept any image type that implements `image.Image` interface+as an input, and return a new image of `*image.NRGBA` type (32bit RGBA colors, not premultiplied by alpha).++## Installation++ go get -u github.com/disintegration/imaging++## Documentation++http://godoc.org/github.com/disintegration/imaging++## Usage examples++A few usage examples can be found below. See the documentation for the full list of supported functions.++### Image resizing++```go+// Resize srcImage to size = 128x128px using the Lanczos filter.+dstImage128 := imaging.Resize(srcImage, 128, 128, imaging.Lanczos)++// Resize srcImage to width = 800px preserving the aspect ratio.+dstImage800 := imaging.Resize(srcImage, 800, 0, imaging.Lanczos)++// Scale down srcImage to fit the 800x600px bounding box.+dstImageFit := imaging.Fit(srcImage, 800, 600, imaging.Lanczos)++// Resize and crop the srcImage to fill the 100x100px area.+dstImageFill := imaging.Fill(srcImage, 100, 100, imaging.Center, imaging.Lanczos)+```++Imaging supports image resizing using various resampling filters. The most notable ones:+- `NearestNeighbor` - Fastest resampling filter, no antialiasing.+- `Box` - Simple and fast averaging filter appropriate for downscaling. When upscaling it's similar to NearestNeighbor.+- `Linear` - Bilinear filter, smooth and reasonably fast.+- `MitchellNetravali` - А smooth bicubic filter.+- `CatmullRom` - A sharp bicubic filter.+- `Gaussian` - Blurring filter that uses gaussian function, useful for noise removal.+- `Lanczos` - High-quality resampling filter for photographic images yielding sharp results, slower than cubic filters.++The full list of supported filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali, CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine. Custom filters can be created using ResampleFilter struct.++**Resampling filters comparison**++Original image:++++The same image resized from 600x400px to 150x100px using different resampling filters.+From faster (lower quality) to slower (higher quality):++Filter | Resize result+--------------------------|---------------------------------------------+`imaging.NearestNeighbor` | +`imaging.Linear` | +`imaging.CatmullRom` | +`imaging.Lanczos` | +++### Gaussian Blur++```go+dstImage := imaging.Blur(srcImage, 0.5)+```++Sigma parameter allows to control the strength of the blurring effect.++Original image | Sigma = 0.5 | Sigma = 1.5+-----------------------------------|----------------------------------------|---------------------------------------+ |  | ++### Sharpening++```go+dstImage := imaging.Sharpen(srcImage, 0.5)+```++`Sharpen` uses gaussian function internally. Sigma parameter allows to control the strength of the sharpening effect.++Original image | Sigma = 0.5 | Sigma = 1.5+-----------------------------------|-------------------------------------------|------------------------------------------+ |  | ++### Gamma correction++```go+dstImage := imaging.AdjustGamma(srcImage, 0.75)+```++Original image | Gamma = 0.75 | Gamma = 1.25+-----------------------------------|------------------------------------------|-----------------------------------------+ |  | ++### Contrast adjustment++```go+dstImage := imaging.AdjustContrast(srcImage, 20)+```++Original image | Contrast = 15 | Contrast = -15+-----------------------------------|--------------------------------------------|-------------------------------------------+ |  | ++### Brightness adjustment++```go+dstImage := imaging.AdjustBrightness(srcImage, 20)+```++Original image | Brightness = 10 | Brightness = -10+-----------------------------------|----------------------------------------------|---------------------------------------------+ |  | ++## Example code++```go+package main++import (+ "image"+ "image/color"+ "log"++ "github.com/disintegration/imaging"+)++func main() {+ // Open a test image.+ src, err := imaging.Open("testdata/flowers.png")+ if err != nil {+ log.Fatalf("failed to open image: %v", err)+ }++ // Crop the original image to 300x300px size using the center anchor.+ src = imaging.CropAnchor(src, 300, 300, imaging.Center)++ // Resize the cropped image to width = 200px preserving the aspect ratio.+ src = imaging.Resize(src, 200, 0, imaging.Lanczos)++ // Create a blurred version of the image.+ img1 := imaging.Blur(src, 5)++ // Create a grayscale version of the image with higher contrast and sharpness.+ img2 := imaging.Grayscale(src)+ img2 = imaging.AdjustContrast(img2, 20)+ img2 = imaging.Sharpen(img2, 2)++ // Create an inverted version of the image.+ img3 := imaging.Invert(src)++ // Create an embossed version of the image using a convolution filter.+ img4 := imaging.Convolve3x3(+ src,+ [9]float64{+ -1, -1, 0,+ -1, 1, 1,+ 0, 1, 1,+ },+ nil,+ )++ // Create a new image and paste the four produced images into it.+ dst := imaging.New(400, 400, color.NRGBA{0, 0, 0, 0})+ dst = imaging.Paste(dst, img1, image.Pt(0, 0))+ dst = imaging.Paste(dst, img2, image.Pt(0, 200))+ dst = imaging.Paste(dst, img3, image.Pt(200, 0))+ dst = imaging.Paste(dst, img4, image.Pt(200, 200))++ // Save the resulting image as JPEG.+ err = imaging.Save(dst, "testdata/out_example.jpg")+ if err != nil {+ log.Fatalf("failed to save image: %v", err)+ }+}+```++Output:++\ No newline at end of filediff --git a/vendor/github.com/disintegration/imaging/adjust.go b/vendor/github.com/disintegration/imaging/adjust.gonew file mode 100644index 000000000..fb3a9ce3c--- /dev/null+++ b/vendor/github.com/disintegration/imaging/adjust.go@@ -0,0 +1,222 @@+package imaging++import (+ "image"+ "image/color"+ "math"+)++// Grayscale produces a grayscale version of the image.+func Grayscale(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ parallel(0, src.h, func(ys <-chan int) {+ for y := range ys {+ i := y * dst.Stride+ src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])+ for x := 0; x < src.w; x++ {+ r := dst.Pix[i+0]+ g := dst.Pix[i+1]+ b := dst.Pix[i+2]+ f := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)+ y := uint8(f + 0.5)+ dst.Pix[i+0] = y+ dst.Pix[i+1] = y+ dst.Pix[i+2] = y+ i += 4+ }+ }+ })+ return dst+}++// Invert produces an inverted (negated) version of the image.+func Invert(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ parallel(0, src.h, func(ys <-chan int) {+ for y := range ys {+ i := y * dst.Stride+ src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])+ for x := 0; x < src.w; x++ {+ dst.Pix[i+0] = 255 - dst.Pix[i+0]+ dst.Pix[i+1] = 255 - dst.Pix[i+1]+ dst.Pix[i+2] = 255 - dst.Pix[i+2]+ i += 4+ }+ }+ })+ return dst+}++// AdjustContrast changes the contrast of the image using the percentage parameter and returns the adjusted image.+// The percentage must be in range (-100, 100). The percentage = 0 gives the original image.+// The percentage = -100 gives solid gray image.+//+// Examples:+//+// dstImage = imaging.AdjustContrast(srcImage, -10) // decrease image contrast by 10%+// dstImage = imaging.AdjustContrast(srcImage, 20) // increase image contrast by 20%+//+func AdjustContrast(img image.Image, percentage float64) *image.NRGBA {+ percentage = math.Min(math.Max(percentage, -100.0), 100.0)+ lut := make([]uint8, 256)++ v := (100.0 + percentage) / 100.0+ for i := 0; i < 256; i++ {+ if 0 <= v && v <= 1 {+ lut[i] = clamp((0.5 + (float64(i)/255.0-0.5)*v) * 255.0)+ } else if 1 < v && v < 2 {+ lut[i] = clamp((0.5 + (float64(i)/255.0-0.5)*(1/(2.0-v))) * 255.0)+ } else {+ lut[i] = uint8(float64(i)/255.0+0.5) * 255+ }+ }++ return adjustLUT(img, lut)+}++// AdjustBrightness changes the brightness of the image using the percentage parameter and returns the adjusted image.+// The percentage must be in range (-100, 100). The percentage = 0 gives the original image.+// The percentage = -100 gives solid black image. The percentage = 100 gives solid white image.+//+// Examples:+//+// dstImage = imaging.AdjustBrightness(srcImage, -15) // decrease image brightness by 15%+// dstImage = imaging.AdjustBrightness(srcImage, 10) // increase image brightness by 10%+//+func AdjustBrightness(img image.Image, percentage float64) *image.NRGBA {+ percentage = math.Min(math.Max(percentage, -100.0), 100.0)+ lut := make([]uint8, 256)++ shift := 255.0 * percentage / 100.0+ for i := 0; i < 256; i++ {+ lut[i] = clamp(float64(i) + shift)+ }++ return adjustLUT(img, lut)+}++// AdjustGamma performs a gamma correction on the image and returns the adjusted image.+// Gamma parameter must be positive. Gamma = 1.0 gives the original image.+// Gamma less than 1.0 darkens the image and gamma greater than 1.0 lightens it.+//+// Example:+//+// dstImage = imaging.AdjustGamma(srcImage, 0.7)+//+func AdjustGamma(img image.Image, gamma float64) *image.NRGBA {+ e := 1.0 / math.Max(gamma, 0.0001)+ lut := make([]uint8, 256)++ for i := 0; i < 256; i++ {+ lut[i] = clamp(math.Pow(float64(i)/255.0, e) * 255.0)+ }++ return adjustLUT(img, lut)+}++// AdjustSigmoid changes the contrast of the image using a sigmoidal function and returns the adjusted image.+// It's a non-linear contrast change useful for photo adjustments as it preserves highlight and shadow detail.+// The midpoint parameter is the midpoint of contrast that must be between 0 and 1, typically 0.5.+// The factor parameter indicates how much to increase or decrease the contrast, typically in range (-10, 10).+// If the factor parameter is positive the image contrast is increased otherwise the contrast is decreased.+//+// Examples:+//+// dstImage = imaging.AdjustSigmoid(srcImage, 0.5, 3.0) // increase the contrast+// dstImage = imaging.AdjustSigmoid(srcImage, 0.5, -3.0) // decrease the contrast+//+func AdjustSigmoid(img image.Image, midpoint, factor float64) *image.NRGBA {+ if factor == 0 {+ return Clone(img)+ }++ lut := make([]uint8, 256)+ a := math.Min(math.Max(midpoint, 0.0), 1.0)+ b := math.Abs(factor)+ sig0 := sigmoid(a, b, 0)+ sig1 := sigmoid(a, b, 1)+ e := 1.0e-6++ if factor > 0 {+ for i := 0; i < 256; i++ {+ x := float64(i) / 255.0+ sigX := sigmoid(a, b, x)+ f := (sigX - sig0) / (sig1 - sig0)+ lut[i] = clamp(f * 255.0)+ }+ } else {+ for i := 0; i < 256; i++ {+ x := float64(i) / 255.0+ arg := math.Min(math.Max((sig1-sig0)*x+sig0, e), 1.0-e)+ f := a - math.Log(1.0/arg-1.0)/b+ lut[i] = clamp(f * 255.0)+ }+ }++ return adjustLUT(img, lut)+}++func sigmoid(a, b, x float64) float64 {+ return 1 / (1 + math.Exp(b*(a-x)))+}++// adjustLUT applies the given lookup table to the colors of the image.+func adjustLUT(img image.Image, lut []uint8) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ parallel(0, src.h, func(ys <-chan int) {+ for y := range ys {+ i := y * dst.Stride+ src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])+ for x := 0; x < src.w; x++ {+ dst.Pix[i+0] = lut[dst.Pix[i+0]]+ dst.Pix[i+1] = lut[dst.Pix[i+1]]+ dst.Pix[i+2] = lut[dst.Pix[i+2]]+ i += 4+ }+ }+ })+ return dst+}++// AdjustFunc applies the fn function to each pixel of the img image and returns the adjusted image.+//+// Example:+//+// dstImage = imaging.AdjustFunc(+// srcImage,+// func(c color.NRGBA) color.NRGBA {+// // shift the red channel by 16+// r := int(c.R) + 16+// if r > 255 {+// r = 255+// }+// return color.NRGBA{uint8(r), c.G, c.B, c.A}+// }+// )+//+func AdjustFunc(img image.Image, fn func(c color.NRGBA) color.NRGBA) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ parallel(0, src.h, func(ys <-chan int) {+ for y := range ys {+ i := y * dst.Stride+ src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])+ for x := 0; x < src.w; x++ {+ r := dst.Pix[i+0]+ g := dst.Pix[i+1]+ b := dst.Pix[i+2]+ a := dst.Pix[i+3]+ c := fn(color.NRGBA{r, g, b, a})+ dst.Pix[i+0] = c.R+ dst.Pix[i+1] = c.G+ dst.Pix[i+2] = c.B+ dst.Pix[i+3] = c.A+ i += 4+ }+ }+ })+ return dst+}diff --git a/vendor/github.com/disintegration/imaging/convolution.go b/vendor/github.com/disintegration/imaging/convolution.gonew file mode 100644index 000000000..9e6404dee--- /dev/null+++ b/vendor/github.com/disintegration/imaging/convolution.go@@ -0,0 +1,146 @@+package imaging++import (+ "image"+)++// ConvolveOptions are convolution parameters.+type ConvolveOptions struct {+ // If Normalize is true the kernel is normalized before convolution.+ Normalize bool++ // If Abs is true the absolute value of each color channel is taken after convolution.+ Abs bool++ // Bias is added to each color channel value after convolution.+ Bias int+}++// Convolve3x3 convolves the image with the specified 3x3 convolution kernel.+// Default parameters are used if a nil *ConvolveOptions is passed.+func Convolve3x3(img image.Image, kernel [9]float64, options *ConvolveOptions) *image.NRGBA {+ return convolve(img, kernel[:], options)+}++// Convolve5x5 convolves the image with the specified 5x5 convolution kernel.+// Default parameters are used if a nil *ConvolveOptions is passed.+func Convolve5x5(img image.Image, kernel [25]float64, options *ConvolveOptions) *image.NRGBA {+ return convolve(img, kernel[:], options)+}++func convolve(img image.Image, kernel []float64, options *ConvolveOptions) *image.NRGBA {+ src := toNRGBA(img)+ w := src.Bounds().Max.X+ h := src.Bounds().Max.Y+ dst := image.NewNRGBA(image.Rect(0, 0, w, h))++ if w < 1 || h < 1 {+ return dst+ }++ if options == nil {+ options = &ConvolveOptions{}+ }++ if options.Normalize {+ normalizeKernel(kernel)+ }++ type coef struct {+ x, y int+ k float64+ }+ var coefs []coef+ var m int++ switch len(kernel) {+ case 9:+ m = 1+ case 25:+ m = 2+ }++ i := 0+ for y := -m; y <= m; y++ {+ for x := -m; x <= m; x++ {+ if kernel[i] != 0 {+ coefs = append(coefs, coef{x: x, y: y, k: kernel[i]})+ }+ i+++ }+ }++ parallel(0, h, func(ys <-chan int) {+ for y := range ys {+ for x := 0; x < w; x++ {+ var r, g, b float64+ for _, c := range coefs {+ ix := x + c.x+ if ix < 0 {+ ix = 0+ } else if ix >= w {+ ix = w - 1+ }++ iy := y + c.y+ if iy < 0 {+ iy = 0+ } else if iy >= h {+ iy = h - 1+ }++ off := iy*src.Stride + ix*4+ r += float64(src.Pix[off+0]) * c.k+ g += float64(src.Pix[off+1]) * c.k+ b += float64(src.Pix[off+2]) * c.k+ }++ if options.Abs {+ if r < 0 {+ r = -r+ }+ if g < 0 {+ g = -g+ }+ if b < 0 {+ b = -b+ }+ }++ if options.Bias != 0 {+ r += float64(options.Bias)+ g += float64(options.Bias)+ b += float64(options.Bias)+ }++ srcOff := y*src.Stride + x*4+ dstOff := y*dst.Stride + x*4+ dst.Pix[dstOff+0] = clamp(r)+ dst.Pix[dstOff+1] = clamp(g)+ dst.Pix[dstOff+2] = clamp(b)+ dst.Pix[dstOff+3] = src.Pix[srcOff+3]+ }+ }+ })++ return dst+}++func normalizeKernel(kernel []float64) {+ var sum, sumpos float64+ for i := range kernel {+ sum += kernel[i]+ if kernel[i] > 0 {+ sumpos += kernel[i]+ }+ }+ if sum != 0 {+ for i := range kernel {+ kernel[i] /= sum+ }+ } else if sumpos != 0 {+ for i := range kernel {+ kernel[i] /= sumpos+ }+ }+}diff --git a/vendor/github.com/disintegration/imaging/doc.go b/vendor/github.com/disintegration/imaging/doc.gonew file mode 100644index 000000000..5d59b46e2--- /dev/null+++ b/vendor/github.com/disintegration/imaging/doc.go@@ -0,0 +1,7 @@+/*+Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).++All the image processing functions provided by the package accept any image type that implements image.Image interface+as an input, and return a new image of *image.NRGBA type (32bit RGBA colors, not premultiplied by alpha).+*/+package imagingdiff --git a/vendor/github.com/disintegration/imaging/effects.go b/vendor/github.com/disintegration/imaging/effects.gonew file mode 100644index 000000000..149cfeb0f--- /dev/null+++ b/vendor/github.com/disintegration/imaging/effects.go@@ -0,0 +1,173 @@+package imaging++import (+ "image"+ "math"+)++func gaussianBlurKernel(x, sigma float64) float64 {+ return math.Exp(-(x*x)/(2*sigma*sigma)) / (sigma * math.Sqrt(2*math.Pi))+}++// Blur produces a blurred version of the image using a Gaussian function.+// Sigma parameter must be positive and indicates how much the image will be blurred.+//+// Usage example:+//+// dstImage := imaging.Blur(srcImage, 3.5)+//+func Blur(img image.Image, sigma float64) *image.NRGBA {+ if sigma <= 0 {+ return Clone(img)+ }++ radius := int(math.Ceil(sigma * 3.0))+ kernel := make([]float64, radius+1)++ for i := 0; i <= radius; i++ {+ kernel[i] = gaussianBlurKernel(float64(i), sigma)+ }++ return blurVertical(blurHorizontal(img, kernel), kernel)+}++func blurHorizontal(img image.Image, kernel []float64) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ radius := len(kernel) - 1++ parallel(0, src.h, func(ys <-chan int) {+ scanLine := make([]uint8, src.w*4)+ scanLineF := make([]float64, len(scanLine))+ for y := range ys {+ src.scan(0, y, src.w, y+1, scanLine)+ for i, v := range scanLine {+ scanLineF[i] = float64(v)+ }+ for x, idx := 0, 0; x < src.w; x, idx = x+1, idx+4 {+ min := x - radius+ if min < 0 {+ min = 0+ }+ max := x + radius+ if max > src.w-1 {+ max = src.w - 1+ }++ var r, g, b, a, wsum float64+ for ix := min; ix <= max; ix++ {+ i := ix * 4+ weight := kernel[absint(x-ix)]+ wsum += weight+ wa := scanLineF[i+3] * weight+ r += scanLineF[i+0] * wa+ g += scanLineF[i+1] * wa+ b += scanLineF[i+2] * wa+ a += wa+ }+ if a != 0 {+ r /= a+ g /= a+ b /= a+ }++ scanLine[idx+0] = clamp(r)+ scanLine[idx+1] = clamp(g)+ scanLine[idx+2] = clamp(b)+ scanLine[idx+3] = clamp(a / wsum)+ }+ copy(dst.Pix[y*dst.Stride:], scanLine)+ }+ })++ return dst+}++func blurVertical(img image.Image, kernel []float64) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ radius := len(kernel) - 1++ parallel(0, src.w, func(xs <-chan int) {+ scanLine := make([]uint8, src.h*4)+ scanLineF := make([]float64, len(scanLine))+ for x := range xs {+ src.scan(x, 0, x+1, src.h, scanLine)+ for i, v := range scanLine {+ scanLineF[i] = float64(v)+ }+ for y := 0; y < src.h; y++ {+ min := y - radius+ if min < 0 {+ min = 0+ }+ max := y + radius+ if max > src.h-1 {+ max = src.h - 1+ }++ var r, g, b, a, wsum float64+ for iy := min; iy <= max; iy++ {+ i := iy * 4+ weight := kernel[absint(y-iy)]+ wsum += weight+ wa := scanLineF[i+3] * weight+ r += scanLineF[i+0] * wa+ g += scanLineF[i+1] * wa+ b += scanLineF[i+2] * wa+ a += wa+ }+ if a != 0 {+ r /= a+ g /= a+ b /= a+ }++ j := y*dst.Stride + x*4+ dst.Pix[j+0] = clamp(r)+ dst.Pix[j+1] = clamp(g)+ dst.Pix[j+2] = clamp(b)+ dst.Pix[j+3] = clamp(a / wsum)+ }+ }+ })++ return dst+}++// Sharpen produces a sharpened version of the image.+// Sigma parameter must be positive and indicates how much the image will be sharpened.+//+// Usage example:+//+// dstImage := imaging.Sharpen(srcImage, 3.5)+//+func Sharpen(img image.Image, sigma float64) *image.NRGBA {+ if sigma <= 0 {+ return Clone(img)+ }++ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ blurred := Blur(img, sigma)++ parallel(0, src.h, func(ys <-chan int) {+ scanLine := make([]uint8, src.w*4)+ for y := range ys {+ src.scan(0, y, src.w, y+1, scanLine)+ j := y * dst.Stride+ for i := 0; i < src.w*4; i++ {+ val := int(scanLine[i])<<1 - int(blurred.Pix[j])+ if val < 0 {+ val = 0+ } else if val > 0xff {+ val = 0xff+ }+ dst.Pix[j] = uint8(val)+ j+++ }+ }+ })++ return dst+}diff --git a/vendor/github.com/disintegration/imaging/histogram.go b/vendor/github.com/disintegration/imaging/histogram.gonew file mode 100644index 000000000..5bcb001ca--- /dev/null+++ b/vendor/github.com/disintegration/imaging/histogram.go@@ -0,0 +1,51 @@+package imaging++import (+ "image"+ "sync"+)++// Histogram returns a normalized histogram of an image.+//+// Resulting histogram is represented as an array of 256 floats, where+// histogram[i] is a probability of a pixel being of a particular luminance i.+func Histogram(img image.Image) [256]float64 {+ var mu sync.Mutex+ var histogram [256]float64+ var total float64++ src := newScanner(img)+ if src.w == 0 || src.h == 0 {+ return histogram+ }++ parallel(0, src.h, func(ys <-chan int) {+ var tmpHistogram [256]float64+ var tmpTotal float64+ scanLine := make([]uint8, src.w*4)+ for y := range ys {+ src.scan(0, y, src.w, y+1, scanLine)+ i := 0+ for x := 0; x < src.w; x++ {+ r := scanLine[i+0]+ g := scanLine[i+1]+ b := scanLine[i+2]+ y := 0.299*float32(r) + 0.587*float32(g) + 0.114*float32(b)+ tmpHistogram[int(y+0.5)]+++ tmpTotal+++ i += 4+ }+ }+ mu.Lock()+ for i := 0; i < 256; i++ {+ histogram[i] += tmpHistogram[i]+ }+ total += tmpTotal+ mu.Unlock()+ })++ for i := 0; i < 256; i++ {+ histogram[i] = histogram[i] / total+ }+ return histogram+}diff --git a/vendor/github.com/disintegration/imaging/io.go b/vendor/github.com/disintegration/imaging/io.gonew file mode 100644index 000000000..557bf2f3d--- /dev/null+++ b/vendor/github.com/disintegration/imaging/io.go@@ -0,0 +1,463 @@+package imaging++import (+ "encoding/binary"+ "errors"+ "image"+ "image/draw"+ "image/gif"+ "image/jpeg"+ "image/png"+ "io"+ "io/ioutil"+ "os"+ "path/filepath"+ "strings"++ "golang.org/x/image/bmp"+ "golang.org/x/image/tiff"+)++// Format is an image file format.+type Format int++// Image file formats.+const (+ JPEG Format = iota+ PNG+ GIF+ TIFF+ BMP+)++func (f Format) String() string {+ switch f {+ case JPEG:+ return "JPEG"+ case PNG:+ return "PNG"+ case GIF:+ return "GIF"+ case TIFF:+ return "TIFF"+ case BMP:+ return "BMP"+ default:+ return "Unsupported"+ }+}++var formatFromExt = map[string]Format{+ "jpg": JPEG,+ "jpeg": JPEG,+ "png": PNG,+ "tif": TIFF,+ "tiff": TIFF,+ "bmp": BMP,+ "gif": GIF,+}++// FormatFromExtension parses image format from extension:+// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.+func FormatFromExtension(ext string) (Format, error) {+ if f, ok := formatFromExt[strings.ToLower(strings.TrimPrefix(ext, "."))]; ok {+ return f, nil+ }+ return -1, ErrUnsupportedFormat+}++// FormatFromFilename parses image format from filename extension:+// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.+func FormatFromFilename(filename string) (Format, error) {+ ext := filepath.Ext(filename)+ return FormatFromExtension(ext)+}++var (+ // ErrUnsupportedFormat means the given image format (or file extension) is unsupported.+ ErrUnsupportedFormat = errors.New("imaging: unsupported image format")+)++type fileSystem interface {+ Create(string) (io.WriteCloser, error)+ Open(string) (io.ReadCloser, error)+}++type localFS struct{}++func (localFS) Create(name string) (io.WriteCloser, error) { return os.Create(name) }+func (localFS) Open(name string) (io.ReadCloser, error) { return os.Open(name) }++var fs fileSystem = localFS{}++type decodeConfig struct {+ autoOrientation bool+}++var defaultDecodeConfig = decodeConfig{+ autoOrientation: false,+}++// DecodeOption sets an optional parameter for the Decode and Open functions.+type DecodeOption func(*decodeConfig)++// AutoOrientation returns a DecodeOption that sets the auto-orientation mode.+// If auto-orientation is enabled, the image will be transformed after decoding+// according to the EXIF orientation tag (if present). By default it's disabled.+func AutoOrientation(enabled bool) DecodeOption {+ return func(c *decodeConfig) {+ c.autoOrientation = enabled+ }+}++// Decode reads an image from r.+func Decode(r io.Reader, opts ...DecodeOption) (image.Image, error) {+ cfg := defaultDecodeConfig+ for _, option := range opts {+ option(&cfg)+ }++ if !cfg.autoOrientation {+ img, _, err := image.Decode(r)+ return img, err+ }++ var orient orientation+ pr, pw := io.Pipe()+ r = io.TeeReader(r, pw)+ done := make(chan struct{})+ go func() {+ defer close(done)+ orient = readOrientation(pr)+ io.Copy(ioutil.Discard, pr)+ }()++ img, _, err := image.Decode(r)+ pw.Close()+ <-done+ if err != nil {+ return nil, err+ }++ return fixOrientation(img, orient), nil+}++// Open loads an image from file.+//+// Examples:+//+// // Load an image from file.+// img, err := imaging.Open("test.jpg")+//+// // Load an image and transform it depending on the EXIF orientation tag (if present).+// img, err := imaging.Open("test.jpg", imaging.AutoOrientation(true))+//+func Open(filename string, opts ...DecodeOption) (image.Image, error) {+ file, err := fs.Open(filename)+ if err != nil {+ return nil, err+ }+ defer file.Close()+ return Decode(file, opts...)+}++type encodeConfig struct {+ jpegQuality int+ gifNumColors int+ gifQuantizer draw.Quantizer+ gifDrawer draw.Drawer+ pngCompressionLevel png.CompressionLevel+}++var defaultEncodeConfig = encodeConfig{+ jpegQuality: 95,+ gifNumColors: 256,+ gifQuantizer: nil,+ gifDrawer: nil,+ pngCompressionLevel: png.DefaultCompression,+}++// EncodeOption sets an optional parameter for the Encode and Save functions.+type EncodeOption func(*encodeConfig)++// JPEGQuality returns an EncodeOption that sets the output JPEG quality.+// Quality ranges from 1 to 100 inclusive, higher is better. Default is 95.+func JPEGQuality(quality int) EncodeOption {+ return func(c *encodeConfig) {+ c.jpegQuality = quality+ }+}++// GIFNumColors returns an EncodeOption that sets the maximum number of colors+// used in the GIF-encoded image. It ranges from 1 to 256. Default is 256.+func GIFNumColors(numColors int) EncodeOption {+ return func(c *encodeConfig) {+ c.gifNumColors = numColors+ }+}++// GIFQuantizer returns an EncodeOption that sets the quantizer that is used to produce+// a palette of the GIF-encoded image.+func GIFQuantizer(quantizer draw.Quantizer) EncodeOption {+ return func(c *encodeConfig) {+ c.gifQuantizer = quantizer+ }+}++// GIFDrawer returns an EncodeOption that sets the drawer that is used to convert+// the source image to the desired palette of the GIF-encoded image.+func GIFDrawer(drawer draw.Drawer) EncodeOption {+ return func(c *encodeConfig) {+ c.gifDrawer = drawer+ }+}++// PNGCompressionLevel returns an EncodeOption that sets the compression level+// of the PNG-encoded image. Default is png.DefaultCompression.+func PNGCompressionLevel(level png.CompressionLevel) EncodeOption {+ return func(c *encodeConfig) {+ c.pngCompressionLevel = level+ }+}++// Encode writes the image img to w in the specified format (JPEG, PNG, GIF, TIFF or BMP).+func Encode(w io.Writer, img image.Image, format Format, opts ...EncodeOption) error {+ cfg := defaultEncodeConfig+ for _, option := range opts {+ option(&cfg)+ }++ var err error+ switch format {+ case JPEG:+ var rgba *image.RGBA+ if nrgba, ok := img.(*image.NRGBA); ok {+ if nrgba.Opaque() {+ rgba = &image.RGBA{+ Pix: nrgba.Pix,+ Stride: nrgba.Stride,+ Rect: nrgba.Rect,+ }+ }+ }+ if rgba != nil {+ err = jpeg.Encode(w, rgba, &jpeg.Options{Quality: cfg.jpegQuality})+ } else {+ err = jpeg.Encode(w, img, &jpeg.Options{Quality: cfg.jpegQuality})+ }++ case PNG:+ enc := png.Encoder{CompressionLevel: cfg.pngCompressionLevel}+ err = enc.Encode(w, img)++ case GIF:+ err = gif.Encode(w, img, &gif.Options{+ NumColors: cfg.gifNumColors,+ Quantizer: cfg.gifQuantizer,+ Drawer: cfg.gifDrawer,+ })++ case TIFF:+ err = tiff.Encode(w, img, &tiff.Options{Compression: tiff.Deflate, Predictor: true})++ case BMP:+ err = bmp.Encode(w, img)++ default:+ err = ErrUnsupportedFormat+ }+ return err+}++// Save saves the image to file with the specified filename.+// The format is determined from the filename extension:+// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.+//+// Examples:+//+// // Save the image as PNG.+// err := imaging.Save(img, "out.png")+//+// // Save the image as JPEG with optional quality parameter set to 80.+// err := imaging.Save(img, "out.jpg", imaging.JPEGQuality(80))+//+func Save(img image.Image, filename string, opts ...EncodeOption) (err error) {+ f, err := FormatFromFilename(filename)+ if err != nil {+ return err+ }+ file, err := fs.Create(filename)+ if err != nil {+ return err+ }++ defer func() {+ cerr := file.Close()+ if err == nil {+ err = cerr+ }+ }()++ return Encode(file, img, f, opts...)+}++// orientation is an EXIF flag that specifies the transformation+// that should be applied to image to display it correctly.+type orientation int++const (+ orientationUnspecified = 0+ orientationNormal = 1+ orientationFlipH = 2+ orientationRotate180 = 3+ orientationFlipV = 4+ orientationTranspose = 5+ orientationRotate270 = 6+ orientationTransverse = 7+ orientationRotate90 = 8+)++// readOrientation tries to read the orientation EXIF flag from image data in r.+// If the EXIF data block is not found or the orientation flag is not found+// or any other error occures while reading the data, it returns the+// orientationUnspecified (0) value.+func readOrientation(r io.Reader) orientation {+ const (+ markerSOI = 0xffd8+ markerAPP1 = 0xffe1+ exifHeader = 0x45786966+ byteOrderBE = 0x4d4d+ byteOrderLE = 0x4949+ orientationTag = 0x0112+ )++ // Check if JPEG SOI marker is present.+ var soi uint16+ if err := binary.Read(r, binary.BigEndian, &soi); err != nil {+ return orientationUnspecified+ }+ if soi != markerSOI {+ return orientationUnspecified // Missing JPEG SOI marker.+ }++ // Find JPEG APP1 marker.+ for {+ var marker, size uint16+ if err := binary.Read(r, binary.BigEndian, &marker); err != nil {+ return orientationUnspecified+ }+ if err := binary.Read(r, binary.BigEndian, &size); err != nil {+ return orientationUnspecified+ }+ if marker>>8 != 0xff {+ return orientationUnspecified // Invalid JPEG marker.+ }+ if marker == markerAPP1 {+ break+ }+ if size < 2 {+ return orientationUnspecified // Invalid block size.+ }+ if _, err := io.CopyN(ioutil.Discard, r, int64(size-2)); err != nil {+ return orientationUnspecified+ }+ }++ // Check if EXIF header is present.+ var header uint32+ if err := binary.Read(r, binary.BigEndian, &header); err != nil {+ return orientationUnspecified+ }+ if header != exifHeader {+ return orientationUnspecified+ }+ if _, err := io.CopyN(ioutil.Discard, r, 2); err != nil {+ return orientationUnspecified+ }++ // Read byte order information.+ var (+ byteOrderTag uint16+ byteOrder binary.ByteOrder+ )+ if err := binary.Read(r, binary.BigEndian, &byteOrderTag); err != nil {+ return orientationUnspecified+ }+ switch byteOrderTag {+ case byteOrderBE:+ byteOrder = binary.BigEndian+ case byteOrderLE:+ byteOrder = binary.LittleEndian+ default:+ return orientationUnspecified // Invalid byte order flag.+ }+ if _, err := io.CopyN(ioutil.Discard, r, 2); err != nil {+ return orientationUnspecified+ }++ // Skip the EXIF offset.+ var offset uint32+ if err := binary.Read(r, byteOrder, &offset); err != nil {+ return orientationUnspecified+ }+ if offset < 8 {+ return orientationUnspecified // Invalid offset value.+ }+ if _, err := io.CopyN(ioutil.Discard, r, int64(offset-8)); err != nil {+ return orientationUnspecified+ }++ // Read the number of tags.+ var numTags uint16+ if err := binary.Read(r, byteOrder, &numTags); err != nil {+ return orientationUnspecified+ }++ // Find the orientation tag.+ for i := 0; i < int(numTags); i++ {+ var tag uint16+ if err := binary.Read(r, byteOrder, &tag); err != nil {+ return orientationUnspecified+ }+ if tag != orientationTag {+ if _, err := io.CopyN(ioutil.Discard, r, 10); err != nil {+ return orientationUnspecified+ }+ continue+ }+ if _, err := io.CopyN(ioutil.Discard, r, 6); err != nil {+ return orientationUnspecified+ }+ var val uint16+ if err := binary.Read(r, byteOrder, &val); err != nil {+ return orientationUnspecified+ }+ if val < 1 || val > 8 {+ return orientationUnspecified // Invalid tag value.+ }+ return orientation(val)+ }+ return orientationUnspecified // Missing orientation tag.+}++// fixOrientation applies a transform to img corresponding to the given orientation flag.+func fixOrientation(img image.Image, o orientation) image.Image {+ switch o {+ case orientationNormal:+ case orientationFlipH:+ img = FlipH(img)+ case orientationFlipV:+ img = FlipV(img)+ case orientationRotate90:+ img = Rotate90(img)+ case orientationRotate180:+ img = Rotate180(img)+ case orientationRotate270:+ img = Rotate270(img)+ case orientationTranspose:+ img = Transpose(img)+ case orientationTransverse:+ img = Transverse(img)+ }+ return img+}diff --git a/vendor/github.com/disintegration/imaging/resize.go b/vendor/github.com/disintegration/imaging/resize.gonew file mode 100644index 000000000..97f498a0a--- /dev/null+++ b/vendor/github.com/disintegration/imaging/resize.go@@ -0,0 +1,572 @@+package imaging++import (+ "image"+ "math"+)++type indexWeight struct {+ index int+ weight float64+}++func precomputeWeights(dstSize, srcSize int, filter ResampleFilter) [][]indexWeight {+ du := float64(srcSize) / float64(dstSize)+ scale := du+ if scale < 1.0 {+ scale = 1.0+ }+ ru := math.Ceil(scale * filter.Support)++ out := make([][]indexWeight, dstSize)+ tmp := make([]indexWeight, 0, dstSize*int(ru+2)*2)++ for v := 0; v < dstSize; v++ {+ fu := (float64(v)+0.5)*du - 0.5++ begin := int(math.Ceil(fu - ru))+ if begin < 0 {+ begin = 0+ }+ end := int(math.Floor(fu + ru))+ if end > srcSize-1 {+ end = srcSize - 1+ }++ var sum float64+ for u := begin; u <= end; u++ {+ w := filter.Kernel((float64(u) - fu) / scale)+ if w != 0 {+ sum += w+ tmp = append(tmp, indexWeight{index: u, weight: w})+ }+ }+ if sum != 0 {+ for i := range tmp {+ tmp[i].weight /= sum+ }+ }++ out[v] = tmp+ tmp = tmp[len(tmp):]+ }++ return out+}++// Resize resizes the image to the specified width and height using the specified resampling+// filter and returns the transformed image. If one of width or height is 0, the image aspect+// ratio is preserved.+//+// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,+// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.+//+// Usage example:+//+// dstImage := imaging.Resize(srcImage, 800, 600, imaging.Lanczos)+//+func Resize(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA {+ dstW, dstH := width, height+ if dstW < 0 || dstH < 0 {+ return &image.NRGBA{}+ }+ if dstW == 0 && dstH == 0 {+ return &image.NRGBA{}+ }++ srcW := img.Bounds().Dx()+ srcH := img.Bounds().Dy()+ if srcW <= 0 || srcH <= 0 {+ return &image.NRGBA{}+ }++ // If new width or height is 0 then preserve aspect ratio, minimum 1px.+ if dstW == 0 {+ tmpW := float64(dstH) * float64(srcW) / float64(srcH)+ dstW = int(math.Max(1.0, math.Floor(tmpW+0.5)))+ }+ if dstH == 0 {+ tmpH := float64(dstW) * float64(srcH) / float64(srcW)+ dstH = int(math.Max(1.0, math.Floor(tmpH+0.5)))+ }++ if filter.Support <= 0 {+ // Nearest-neighbor special case.+ return resizeNearest(img, dstW, dstH)+ }++ if srcW != dstW && srcH != dstH {+ return resizeVertical(resizeHorizontal(img, dstW, filter), dstH, filter)+ }+ if srcW != dstW {+ return resizeHorizontal(img, dstW, filter)+ }+ if srcH != dstH {+ return resizeVertical(img, dstH, filter)+ }+ return Clone(img)+}++func resizeHorizontal(img image.Image, width int, filter ResampleFilter) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, width, src.h))+ weights := precomputeWeights(width, src.w, filter)+ parallel(0, src.h, func(ys <-chan int) {+ scanLine := make([]uint8, src.w*4)+ for y := range ys {+ src.scan(0, y, src.w, y+1, scanLine)+ j0 := y * dst.Stride+ for x := 0; x < width; x++ {+ var r, g, b, a float64+ for _, w := range weights[x] {+ i := w.index * 4+ aw := float64(scanLine[i+3]) * w.weight+ r += float64(scanLine[i+0]) * aw+ g += float64(scanLine[i+1]) * aw+ b += float64(scanLine[i+2]) * aw+ a += aw+ }+ if a != 0 {+ aInv := 1 / a+ j := j0 + x*4+ dst.Pix[j+0] = clamp(r * aInv)+ dst.Pix[j+1] = clamp(g * aInv)+ dst.Pix[j+2] = clamp(b * aInv)+ dst.Pix[j+3] = clamp(a)+ }+ }+ }+ })+ return dst+}++func resizeVertical(img image.Image, height int, filter ResampleFilter) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, height))+ weights := precomputeWeights(height, src.h, filter)+ parallel(0, src.w, func(xs <-chan int) {+ scanLine := make([]uint8, src.h*4)+ for x := range xs {+ src.scan(x, 0, x+1, src.h, scanLine)+ for y := 0; y < height; y++ {+ var r, g, b, a float64+ for _, w := range weights[y] {+ i := w.index * 4+ aw := float64(scanLine[i+3]) * w.weight+ r += float64(scanLine[i+0]) * aw+ g += float64(scanLine[i+1]) * aw+ b += float64(scanLine[i+2]) * aw+ a += aw+ }+ if a != 0 {+ aInv := 1 / a+ j := y*dst.Stride + x*4+ dst.Pix[j+0] = clamp(r * aInv)+ dst.Pix[j+1] = clamp(g * aInv)+ dst.Pix[j+2] = clamp(b * aInv)+ dst.Pix[j+3] = clamp(a)+ }+ }+ }+ })+ return dst+}++// resizeNearest is a fast nearest-neighbor resize, no filtering.+func resizeNearest(img image.Image, width, height int) *image.NRGBA {+ dst := image.NewNRGBA(image.Rect(0, 0, width, height))+ dx := float64(img.Bounds().Dx()) / float64(width)+ dy := float64(img.Bounds().Dy()) / float64(height)++ if dx > 1 && dy > 1 {+ src := newScanner(img)+ parallel(0, height, func(ys <-chan int) {+ for y := range ys {+ srcY := int((float64(y) + 0.5) * dy)+ dstOff := y * dst.Stride+ for x := 0; x < width; x++ {+ srcX := int((float64(x) + 0.5) * dx)+ src.scan(srcX, srcY, srcX+1, srcY+1, dst.Pix[dstOff:dstOff+4])+ dstOff += 4+ }+ }+ })+ } else {+ src := toNRGBA(img)+ parallel(0, height, func(ys <-chan int) {+ for y := range ys {+ srcY := int((float64(y) + 0.5) * dy)+ srcOff0 := srcY * src.Stride+ dstOff := y * dst.Stride+ for x := 0; x < width; x++ {+ srcX := int((float64(x) + 0.5) * dx)+ srcOff := srcOff0 + srcX*4+ copy(dst.Pix[dstOff:dstOff+4], src.Pix[srcOff:srcOff+4])+ dstOff += 4+ }+ }+ })+ }++ return dst+}++// Fit scales down the image using the specified resample filter to fit the specified+// maximum width and height and returns the transformed image.+//+// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,+// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.+//+// Usage example:+//+// dstImage := imaging.Fit(srcImage, 800, 600, imaging.Lanczos)+//+func Fit(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA {+ maxW, maxH := width, height++ if maxW <= 0 || maxH <= 0 {+ return &image.NRGBA{}+ }++ srcBounds := img.Bounds()+ srcW := srcBounds.Dx()+ srcH := srcBounds.Dy()++ if srcW <= 0 || srcH <= 0 {+ return &image.NRGBA{}+ }++ if srcW <= maxW && srcH <= maxH {+ return Clone(img)+ }++ srcAspectRatio := float64(srcW) / float64(srcH)+ maxAspectRatio := float64(maxW) / float64(maxH)++ var newW, newH int+ if srcAspectRatio > maxAspectRatio {+ newW = maxW+ newH = int(float64(newW) / srcAspectRatio)+ } else {+ newH = maxH+ newW = int(float64(newH) * srcAspectRatio)+ }++ return Resize(img, newW, newH, filter)+}++// Fill scales the image to the smallest possible size that will cover the specified dimensions,+// crops the resized image to the specified dimensions using the given anchor point and returns+// the transformed image.+//+// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,+// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.+//+// Usage example:+//+// dstImage := imaging.Fill(srcImage, 800, 600, imaging.Center, imaging.Lanczos)+//+func Fill(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA {+ minW, minH := width, height++ if minW <= 0 || minH <= 0 {+ return &image.NRGBA{}+ }++ srcBounds := img.Bounds()+ srcW := srcBounds.Dx()+ srcH := srcBounds.Dy()++ if srcW <= 0 || srcH <= 0 {+ return &image.NRGBA{}+ }++ if srcW == minW && srcH == minH {+ return Clone(img)+ }++ srcAspectRatio := float64(srcW) / float64(srcH)+ minAspectRatio := float64(minW) / float64(minH)++ var tmp *image.NRGBA+ if srcAspectRatio < minAspectRatio {+ tmp = Resize(img, minW, 0, filter)+ } else {+ tmp = Resize(img, 0, minH, filter)+ }++ return CropAnchor(tmp, minW, minH, anchor)+}++// Thumbnail scales the image up or down using the specified resample filter, crops it+// to the specified width and hight and returns the transformed image.+//+// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,+// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.+//+// Usage example:+//+// dstImage := imaging.Thumbnail(srcImage, 100, 100, imaging.Lanczos)+//+func Thumbnail(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA {+ return Fill(img, width, height, Center, filter)+}++// ResampleFilter is a resampling filter struct. It can be used to define custom filters.+//+// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,+// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.+//+// General filter recommendations:+//+// - Lanczos+// High-quality resampling filter for photographic images yielding sharp results.+// It's slower than cubic filters (see below).+//+// - CatmullRom+// A sharp cubic filter. It's a good filter for both upscaling and downscaling if sharp results are needed.+//+// - MitchellNetravali+// A high quality cubic filter that produces smoother results with less ringing artifacts than CatmullRom.+//+// - BSpline+// A good filter if a very smooth output is needed.+//+// - Linear+// Bilinear interpolation filter, produces reasonably good, smooth output.+// It's faster than cubic filters.+//+// - Box+// Simple and fast averaging filter appropriate for downscaling.+// When upscaling it's similar to NearestNeighbor.+//+// - NearestNeighbor+// Fastest resampling filter, no antialiasing.+//+type ResampleFilter struct {+ Support float64+ Kernel func(float64) float64+}++// NearestNeighbor is a nearest-neighbor filter (no anti-aliasing).+var NearestNeighbor ResampleFilter++// Box filter (averaging pixels).+var Box ResampleFilter++// Linear filter.+var Linear ResampleFilter++// Hermite cubic spline filter (BC-spline; B=0; C=0).+var Hermite ResampleFilter++// MitchellNetravali is Mitchell-Netravali cubic filter (BC-spline; B=1/3; C=1/3).+var MitchellNetravali ResampleFilter++// CatmullRom is a Catmull-Rom - sharp cubic filter (BC-spline; B=0; C=0.5).+var CatmullRom ResampleFilter++// BSpline is a smooth cubic filter (BC-spline; B=1; C=0).+var BSpline ResampleFilter++// Gaussian is a Gaussian blurring Filter.+var Gaussian ResampleFilter++// Bartlett is a Bartlett-windowed sinc filter (3 lobes).+var Bartlett ResampleFilter++// Lanczos filter (3 lobes).+var Lanczos ResampleFilter++// Hann is a Hann-windowed sinc filter (3 lobes).+var Hann ResampleFilter++// Hamming is a Hamming-windowed sinc filter (3 lobes).+var Hamming ResampleFilter++// Blackman is a Blackman-windowed sinc filter (3 lobes).+var Blackman ResampleFilter++// Welch is a Welch-windowed sinc filter (parabolic window, 3 lobes).+var Welch ResampleFilter++// Cosine is a Cosine-windowed sinc filter (3 lobes).+var Cosine ResampleFilter++func bcspline(x, b, c float64) float64 {+ var y float64+ x = math.Abs(x)+ if x < 1.0 {+ y = ((12-9*b-6*c)*x*x*x + (-18+12*b+6*c)*x*x + (6 - 2*b)) / 6+ } else if x < 2.0 {+ y = ((-b-6*c)*x*x*x + (6*b+30*c)*x*x + (-12*b-48*c)*x + (8*b + 24*c)) / 6+ }+ return y+}++func sinc(x float64) float64 {+ if x == 0 {+ return 1+ }+ return math.Sin(math.Pi*x) / (math.Pi * x)+}++func init() {+ NearestNeighbor = ResampleFilter{+ Support: 0.0, // special case - not applying the filter+ }++ Box = ResampleFilter{+ Support: 0.5,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x <= 0.5 {+ return 1.0+ }+ return 0+ },+ }++ Linear = ResampleFilter{+ Support: 1.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 1.0 {+ return 1.0 - x+ }+ return 0+ },+ }++ Hermite = ResampleFilter{+ Support: 1.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 1.0 {+ return bcspline(x, 0.0, 0.0)+ }+ return 0+ },+ }++ MitchellNetravali = ResampleFilter{+ Support: 2.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 2.0 {+ return bcspline(x, 1.0/3.0, 1.0/3.0)+ }+ return 0+ },+ }++ CatmullRom = ResampleFilter{+ Support: 2.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 2.0 {+ return bcspline(x, 0.0, 0.5)+ }+ return 0+ },+ }++ BSpline = ResampleFilter{+ Support: 2.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 2.0 {+ return bcspline(x, 1.0, 0.0)+ }+ return 0+ },+ }++ Gaussian = ResampleFilter{+ Support: 2.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 2.0 {+ return math.Exp(-2 * x * x)+ }+ return 0+ },+ }++ Bartlett = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * (3.0 - x) / 3.0+ }+ return 0+ },+ }++ Lanczos = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * sinc(x/3.0)+ }+ return 0+ },+ }++ Hann = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * (0.5 + 0.5*math.Cos(math.Pi*x/3.0))+ }+ return 0+ },+ }++ Hamming = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * (0.54 + 0.46*math.Cos(math.Pi*x/3.0))+ }+ return 0+ },+ }++ Blackman = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * (0.42 - 0.5*math.Cos(math.Pi*x/3.0+math.Pi) + 0.08*math.Cos(2.0*math.Pi*x/3.0))+ }+ return 0+ },+ }++ Welch = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * (1.0 - (x * x / 9.0))+ }+ return 0+ },+ }++ Cosine = ResampleFilter{+ Support: 3.0,+ Kernel: func(x float64) float64 {+ x = math.Abs(x)+ if x < 3.0 {+ return sinc(x) * math.Cos((math.Pi/2.0)*(x/3.0))+ }+ return 0+ },+ }+}diff --git a/vendor/github.com/disintegration/imaging/scanner.go b/vendor/github.com/disintegration/imaging/scanner.gonew file mode 100644index 000000000..c4dbfe1ec--- /dev/null+++ b/vendor/github.com/disintegration/imaging/scanner.go@@ -0,0 +1,250 @@+package imaging++import (+ "image"+ "image/color"+)++type scanner struct {+ image image.Image+ w, h int+ palette []color.NRGBA+}++func newScanner(img image.Image) *scanner {+ s := &scanner{+ image: img,+ w: img.Bounds().Dx(),+ h: img.Bounds().Dy(),+ }+ if img, ok := img.(*image.Paletted); ok {+ s.palette = make([]color.NRGBA, len(img.Palette))+ for i := 0; i < len(img.Palette); i++ {+ s.palette[i] = color.NRGBAModel.Convert(img.Palette[i]).(color.NRGBA)+ }+ }+ return s+}++// scan scans the given rectangular region of the image into dst.+func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {+ switch img := s.image.(type) {+ case *image.NRGBA:+ size := (x2 - x1) * 4+ j := 0+ i := y1*img.Stride + x1*4+ for y := y1; y < y2; y++ {+ copy(dst[j:j+size], img.Pix[i:i+size])+ j += size+ i += img.Stride+ }++ case *image.NRGBA64:+ j := 0+ for y := y1; y < y2; y++ {+ i := y*img.Stride + x1*8+ for x := x1; x < x2; x++ {+ dst[j+0] = img.Pix[i+0]+ dst[j+1] = img.Pix[i+2]+ dst[j+2] = img.Pix[i+4]+ dst[j+3] = img.Pix[i+6]+ j += 4+ i += 8+ }+ }++ case *image.RGBA:+ j := 0+ for y := y1; y < y2; y++ {+ i := y*img.Stride + x1*4+ for x := x1; x < x2; x++ {+ a := img.Pix[i+3]+ switch a {+ case 0:+ dst[j+0] = 0+ dst[j+1] = 0+ dst[j+2] = 0+ case 0xff:+ dst[j+0] = img.Pix[i+0]+ dst[j+1] = img.Pix[i+1]+ dst[j+2] = img.Pix[i+2]+ default:+ r16 := uint16(img.Pix[i+0])+ g16 := uint16(img.Pix[i+1])+ b16 := uint16(img.Pix[i+2])+ a16 := uint16(a)+ dst[j+0] = uint8(r16 * 0xff / a16)+ dst[j+1] = uint8(g16 * 0xff / a16)+ dst[j+2] = uint8(b16 * 0xff / a16)+ }+ dst[j+3] = a+ j += 4+ i += 4+ }+ }++ case *image.RGBA64:+ j := 0+ for y := y1; y < y2; y++ {+ i := y*img.Stride + x1*8+ for x := x1; x < x2; x++ {+ a := img.Pix[i+6]+ switch a {+ case 0:+ dst[j+0] = 0+ dst[j+1] = 0+ dst[j+2] = 0+ case 0xff:+ dst[j+0] = img.Pix[i+0]+ dst[j+1] = img.Pix[i+2]+ dst[j+2] = img.Pix[i+4]+ default:+ r32 := uint32(img.Pix[i+0])<<8 | uint32(img.Pix[i+1])+ g32 := uint32(img.Pix[i+2])<<8 | uint32(img.Pix[i+3])+ b32 := uint32(img.Pix[i+4])<<8 | uint32(img.Pix[i+5])+ a32 := uint32(img.Pix[i+6])<<8 | uint32(img.Pix[i+7])+ dst[j+0] = uint8((r32 * 0xffff / a32) >> 8)+ dst[j+1] = uint8((g32 * 0xffff / a32) >> 8)+ dst[j+2] = uint8((b32 * 0xffff / a32) >> 8)+ }+ dst[j+3] = a+ j += 4+ i += 8+ }+ }++ case *image.Gray:+ j := 0+ for y := y1; y < y2; y++ {+ i := y*img.Stride + x1+ for x := x1; x < x2; x++ {+ c := img.Pix[i]+ dst[j+0] = c+ dst[j+1] = c+ dst[j+2] = c+ dst[j+3] = 0xff+ j += 4+ i+++ }+ }++ case *image.Gray16:+ j := 0+ for y := y1; y < y2; y++ {+ i := y*img.Stride + x1*2+ for x := x1; x < x2; x++ {+ c := img.Pix[i]+ dst[j+0] = c+ dst[j+1] = c+ dst[j+2] = c+ dst[j+3] = 0xff+ j += 4+ i += 2+ }+ }++ case *image.YCbCr:+ j := 0+ x1 += img.Rect.Min.X+ x2 += img.Rect.Min.X+ y1 += img.Rect.Min.Y+ y2 += img.Rect.Min.Y+ for y := y1; y < y2; y++ {+ iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)+ for x := x1; x < x2; x++ {+ var ic int+ switch img.SubsampleRatio {+ case image.YCbCrSubsampleRatio444:+ ic = (y-img.Rect.Min.Y)*img.CStride + (x - img.Rect.Min.X)+ case image.YCbCrSubsampleRatio422:+ ic = (y-img.Rect.Min.Y)*img.CStride + (x/2 - img.Rect.Min.X/2)+ case image.YCbCrSubsampleRatio420:+ ic = (y/2-img.Rect.Min.Y/2)*img.CStride + (x/2 - img.Rect.Min.X/2)+ case image.YCbCrSubsampleRatio440:+ ic = (y/2-img.Rect.Min.Y/2)*img.CStride + (x - img.Rect.Min.X)+ default:+ ic = img.COffset(x, y)+ }++ yy := int(img.Y[iy])+ cb := int(img.Cb[ic]) - 128+ cr := int(img.Cr[ic]) - 128++ r := (yy<<16 + 91881*cr + 1<<15) >> 16+ if r > 0xff {+ r = 0xff+ } else if r < 0 {+ r = 0+ }++ g := (yy<<16 - 22554*cb - 46802*cr + 1<<15) >> 16+ if g > 0xff {+ g = 0xff+ } else if g < 0 {+ g = 0+ }++ b := (yy<<16 + 116130*cb + 1<<15) >> 16+ if b > 0xff {+ b = 0xff+ } else if b < 0 {+ b = 0+ }++ dst[j+0] = uint8(r)+ dst[j+1] = uint8(g)+ dst[j+2] = uint8(b)+ dst[j+3] = 0xff++ iy+++ j += 4+ }+ }++ case *image.Paletted:+ j := 0+ for y := y1; y < y2; y++ {+ i := y*img.Stride + x1+ for x := x1; x < x2; x++ {+ c := s.palette[img.Pix[i]]+ dst[j+0] = c.R+ dst[j+1] = c.G+ dst[j+2] = c.B+ dst[j+3] = c.A+ j += 4+ i+++ }+ }++ default:+ j := 0+ b := s.image.Bounds()+ x1 += b.Min.X+ x2 += b.Min.X+ y1 += b.Min.Y+ y2 += b.Min.Y+ for y := y1; y < y2; y++ {+ for x := x1; x < x2; x++ {+ r16, g16, b16, a16 := s.image.At(x, y).RGBA()+ switch a16 {+ case 0xffff:+ dst[j+0] = uint8(r16 >> 8)+ dst[j+1] = uint8(g16 >> 8)+ dst[j+2] = uint8(b16 >> 8)+ dst[j+3] = 0xff+ case 0:+ dst[j+0] = 0+ dst[j+1] = 0+ dst[j+2] = 0+ dst[j+3] = 0+ default:+ dst[j+0] = uint8(((r16 * 0xffff) / a16) >> 8)+ dst[j+1] = uint8(((g16 * 0xffff) / a16) >> 8)+ dst[j+2] = uint8(((b16 * 0xffff) / a16) >> 8)+ dst[j+3] = uint8(a16 >> 8)+ }+ j += 4+ }+ }+ }+}diff --git a/vendor/github.com/disintegration/imaging/tools.go b/vendor/github.com/disintegration/imaging/tools.gonew file mode 100644index 000000000..788794619--- /dev/null+++ b/vendor/github.com/disintegration/imaging/tools.go@@ -0,0 +1,247 @@+package imaging++import (+ "bytes"+ "image"+ "image/color"+ "math"+)++// New creates a new image with the specified width and height, and fills it with the specified color.+func New(width, height int, fillColor color.Color) *image.NRGBA {+ if width <= 0 || height <= 0 {+ return &image.NRGBA{}+ }++ c := color.NRGBAModel.Convert(fillColor).(color.NRGBA)+ if (c == color.NRGBA{0, 0, 0, 0}) {+ return image.NewNRGBA(image.Rect(0, 0, width, height))+ }++ return &image.NRGBA{+ Pix: bytes.Repeat([]byte{c.R, c.G, c.B, c.A}, width*height),+ Stride: 4 * width,+ Rect: image.Rect(0, 0, width, height),+ }+}++// Clone returns a copy of the given image.+func Clone(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))+ size := src.w * 4+ parallel(0, src.h, func(ys <-chan int) {+ for y := range ys {+ i := y * dst.Stride+ src.scan(0, y, src.w, y+1, dst.Pix[i:i+size])+ }+ })+ return dst+}++// Anchor is the anchor point for image alignment.+type Anchor int++// Anchor point positions.+const (+ Center Anchor = iota+ TopLeft+ Top+ TopRight+ Left+ Right+ BottomLeft+ Bottom+ BottomRight+)++func anchorPt(b image.Rectangle, w, h int, anchor Anchor) image.Point {+ var x, y int+ switch anchor {+ case TopLeft:+ x = b.Min.X+ y = b.Min.Y+ case Top:+ x = b.Min.X + (b.Dx()-w)/2+ y = b.Min.Y+ case TopRight:+ x = b.Max.X - w+ y = b.Min.Y+ case Left:+ x = b.Min.X+ y = b.Min.Y + (b.Dy()-h)/2+ case Right:+ x = b.Max.X - w+ y = b.Min.Y + (b.Dy()-h)/2+ case BottomLeft:+ x = b.Min.X+ y = b.Max.Y - h+ case Bottom:+ x = b.Min.X + (b.Dx()-w)/2+ y = b.Max.Y - h+ case BottomRight:+ x = b.Max.X - w+ y = b.Max.Y - h+ default:+ x = b.Min.X + (b.Dx()-w)/2+ y = b.Min.Y + (b.Dy()-h)/2+ }+ return image.Pt(x, y)+}++// Crop cuts out a rectangular region with the specified bounds+// from the image and returns the cropped image.+func Crop(img image.Image, rect image.Rectangle) *image.NRGBA {+ r := rect.Intersect(img.Bounds()).Sub(img.Bounds().Min)+ if r.Empty() {+ return &image.NRGBA{}+ }+ src := newScanner(img)+ dst := image.NewNRGBA(image.Rect(0, 0, r.Dx(), r.Dy()))+ rowSize := r.Dx() * 4+ parallel(r.Min.Y, r.Max.Y, func(ys <-chan int) {+ for y := range ys {+ i := (y - r.Min.Y) * dst.Stride+ src.scan(r.Min.X, y, r.Max.X, y+1, dst.Pix[i:i+rowSize])+ }+ })+ return dst+}++// CropAnchor cuts out a rectangular region with the specified size+// from the image using the specified anchor point and returns the cropped image.+func CropAnchor(img image.Image, width, height int, anchor Anchor) *image.NRGBA {+ srcBounds := img.Bounds()+ pt := anchorPt(srcBounds, width, height, anchor)+ r := image.Rect(0, 0, width, height).Add(pt)+ b := srcBounds.Intersect(r)+ return Crop(img, b)+}++// CropCenter cuts out a rectangular region with the specified size+// from the center of the image and returns the cropped image.+func CropCenter(img image.Image, width, height int) *image.NRGBA {+ return CropAnchor(img, width, height, Center)+}++// Paste pastes the img image to the background image at the specified position and returns the combined image.+func Paste(background, img image.Image, pos image.Point) *image.NRGBA {+ dst := Clone(background)+ pos = pos.Sub(background.Bounds().Min)+ pasteRect := image.Rectangle{Min: pos, Max: pos.Add(img.Bounds().Size())}+ interRect := pasteRect.Intersect(dst.Bounds())+ if interRect.Empty() {+ return dst+ }+ src := newScanner(img)+ parallel(interRect.Min.Y, interRect.Max.Y, func(ys <-chan int) {+ for y := range ys {+ x1 := interRect.Min.X - pasteRect.Min.X+ x2 := interRect.Max.X - pasteRect.Min.X+ y1 := y - pasteRect.Min.Y+ y2 := y1 + 1+ i1 := y*dst.Stride + interRect.Min.X*4+ i2 := i1 + interRect.Dx()*4+ src.scan(x1, y1, x2, y2, dst.Pix[i1:i2])+ }+ })+ return dst+}++// PasteCenter pastes the img image to the center of the background image and returns the combined image.+func PasteCenter(background, img image.Image) *image.NRGBA {+ bgBounds := background.Bounds()+ bgW := bgBounds.Dx()+ bgH := bgBounds.Dy()+ bgMinX := bgBounds.Min.X+ bgMinY := bgBounds.Min.Y++ centerX := bgMinX + bgW/2+ centerY := bgMinY + bgH/2++ x0 := centerX - img.Bounds().Dx()/2+ y0 := centerY - img.Bounds().Dy()/2++ return Paste(background, img, image.Pt(x0, y0))+}++// Overlay draws the img image over the background image at given position+// and returns the combined image. Opacity parameter is the opacity of the img+// image layer, used to compose the images, it must be from 0.0 to 1.0.+//+// Usage examples:+//+// // Draw spriteImage over backgroundImage at the given position (x=50, y=50).+// dstImage := imaging.Overlay(backgroundImage, spriteImage, image.Pt(50, 50), 1.0)+//+// // Blend two opaque images of the same size.+// dstImage := imaging.Overlay(imageOne, imageTwo, image.Pt(0, 0), 0.5)+//+func Overlay(background, img image.Image, pos image.Point, opacity float64) *image.NRGBA {+ opacity = math.Min(math.Max(opacity, 0.0), 1.0) // Ensure 0.0 <= opacity <= 1.0.+ dst := Clone(background)+ pos = pos.Sub(background.Bounds().Min)+ pasteRect := image.Rectangle{Min: pos, Max: pos.Add(img.Bounds().Size())}+ interRect := pasteRect.Intersect(dst.Bounds())+ if interRect.Empty() {+ return dst+ }+ src := newScanner(img)+ parallel(interRect.Min.Y, interRect.Max.Y, func(ys <-chan int) {+ scanLine := make([]uint8, interRect.Dx()*4)+ for y := range ys {+ x1 := interRect.Min.X - pasteRect.Min.X+ x2 := interRect.Max.X - pasteRect.Min.X+ y1 := y - pasteRect.Min.Y+ y2 := y1 + 1+ src.scan(x1, y1, x2, y2, scanLine)+ i := y*dst.Stride + interRect.Min.X*4+ j := 0+ for x := interRect.Min.X; x < interRect.Max.X; x++ {+ r1 := float64(dst.Pix[i+0])+ g1 := float64(dst.Pix[i+1])+ b1 := float64(dst.Pix[i+2])+ a1 := float64(dst.Pix[i+3])++ r2 := float64(scanLine[j+0])+ g2 := float64(scanLine[j+1])+ b2 := float64(scanLine[j+2])+ a2 := float64(scanLine[j+3])++ coef2 := opacity * a2 / 255+ coef1 := (1 - coef2) * a1 / 255+ coefSum := coef1 + coef2+ coef1 /= coefSum+ coef2 /= coefSum++ dst.Pix[i+0] = uint8(r1*coef1 + r2*coef2)+ dst.Pix[i+1] = uint8(g1*coef1 + g2*coef2)+ dst.Pix[i+2] = uint8(b1*coef1 + b2*coef2)+ dst.Pix[i+3] = uint8(math.Min(a1+a2*opacity*(255-a1)/255, 255))++ i += 4+ j += 4+ }+ }+ })+ return dst+}++// OverlayCenter overlays the img image to the center of the background image and+// returns the combined image. Opacity parameter is the opacity of the img+// image layer, used to compose the images, it must be from 0.0 to 1.0.+func OverlayCenter(background, img image.Image, opacity float64) *image.NRGBA {+ bgBounds := background.Bounds()+ bgW := bgBounds.Dx()+ bgH := bgBounds.Dy()+ bgMinX := bgBounds.Min.X+ bgMinY := bgBounds.Min.Y++ centerX := bgMinX + bgW/2+ centerY := bgMinY + bgH/2++ x0 := centerX - img.Bounds().Dx()/2+ y0 := centerY - img.Bounds().Dy()/2++ return Overlay(background, img, image.Point{x0, y0}, opacity)+}diff --git a/vendor/github.com/disintegration/imaging/transform.go b/vendor/github.com/disintegration/imaging/transform.gonew file mode 100644index 000000000..d788d0d42--- /dev/null+++ b/vendor/github.com/disintegration/imaging/transform.go@@ -0,0 +1,271 @@+package imaging++import (+ "image"+ "image/color"+ "math"+)++// FlipH flips the image horizontally (from left to right) and returns the transformed image.+func FlipH(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.w+ dstH := src.h+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcY := dstY+ src.scan(0, srcY, src.w, srcY+1, dst.Pix[i:i+rowSize])+ reverse(dst.Pix[i : i+rowSize])+ }+ })+ return dst+}++// FlipV flips the image vertically (from top to bottom) and returns the transformed image.+func FlipV(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.w+ dstH := src.h+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcY := dstH - dstY - 1+ src.scan(0, srcY, src.w, srcY+1, dst.Pix[i:i+rowSize])+ }+ })+ return dst+}++// Transpose flips the image horizontally and rotates 90 degrees counter-clockwise.+func Transpose(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.h+ dstH := src.w+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcX := dstY+ src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])+ }+ })+ return dst+}++// Transverse flips the image vertically and rotates 90 degrees counter-clockwise.+func Transverse(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.h+ dstH := src.w+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcX := dstH - dstY - 1+ src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])+ reverse(dst.Pix[i : i+rowSize])+ }+ })+ return dst+}++// Rotate90 rotates the image 90 degrees counter-clockwise and returns the transformed image.+func Rotate90(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.h+ dstH := src.w+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcX := dstH - dstY - 1+ src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])+ }+ })+ return dst+}++// Rotate180 rotates the image 180 degrees counter-clockwise and returns the transformed image.+func Rotate180(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.w+ dstH := src.h+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcY := dstH - dstY - 1+ src.scan(0, srcY, src.w, srcY+1, dst.Pix[i:i+rowSize])+ reverse(dst.Pix[i : i+rowSize])+ }+ })+ return dst+}++// Rotate270 rotates the image 270 degrees counter-clockwise and returns the transformed image.+func Rotate270(img image.Image) *image.NRGBA {+ src := newScanner(img)+ dstW := src.h+ dstH := src.w+ rowSize := dstW * 4+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))+ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ i := dstY * dst.Stride+ srcX := dstY+ src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])+ reverse(dst.Pix[i : i+rowSize])+ }+ })+ return dst+}++// Rotate rotates an image by the given angle counter-clockwise .+// The angle parameter is the rotation angle in degrees.+// The bgColor parameter specifies the color of the uncovered zone after the rotation.+func Rotate(img image.Image, angle float64, bgColor color.Color) *image.NRGBA {+ angle = angle - math.Floor(angle/360)*360++ switch angle {+ case 0:+ return Clone(img)+ case 90:+ return Rotate90(img)+ case 180:+ return Rotate180(img)+ case 270:+ return Rotate270(img)+ }++ src := toNRGBA(img)+ srcW := src.Bounds().Max.X+ srcH := src.Bounds().Max.Y+ dstW, dstH := rotatedSize(srcW, srcH, angle)+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))++ if dstW <= 0 || dstH <= 0 {+ return dst+ }++ srcXOff := float64(srcW)/2 - 0.5+ srcYOff := float64(srcH)/2 - 0.5+ dstXOff := float64(dstW)/2 - 0.5+ dstYOff := float64(dstH)/2 - 0.5++ bgColorNRGBA := color.NRGBAModel.Convert(bgColor).(color.NRGBA)+ sin, cos := math.Sincos(math.Pi * angle / 180)++ parallel(0, dstH, func(ys <-chan int) {+ for dstY := range ys {+ for dstX := 0; dstX < dstW; dstX++ {+ xf, yf := rotatePoint(float64(dstX)-dstXOff, float64(dstY)-dstYOff, sin, cos)+ xf, yf = xf+srcXOff, yf+srcYOff+ interpolatePoint(dst, dstX, dstY, src, xf, yf, bgColorNRGBA)+ }+ }+ })++ return dst+}++func rotatePoint(x, y, sin, cos float64) (float64, float64) {+ return x*cos - y*sin, x*sin + y*cos+}++func rotatedSize(w, h int, angle float64) (int, int) {+ if w <= 0 || h <= 0 {+ return 0, 0+ }++ sin, cos := math.Sincos(math.Pi * angle / 180)+ x1, y1 := rotatePoint(float64(w-1), 0, sin, cos)+ x2, y2 := rotatePoint(float64(w-1), float64(h-1), sin, cos)+ x3, y3 := rotatePoint(0, float64(h-1), sin, cos)++ minx := math.Min(x1, math.Min(x2, math.Min(x3, 0)))+ maxx := math.Max(x1, math.Max(x2, math.Max(x3, 0)))+ miny := math.Min(y1, math.Min(y2, math.Min(y3, 0)))+ maxy := math.Max(y1, math.Max(y2, math.Max(y3, 0)))++ neww := maxx - minx + 1+ if neww-math.Floor(neww) > 0.1 {+ neww+++ }+ newh := maxy - miny + 1+ if newh-math.Floor(newh) > 0.1 {+ newh+++ }++ return int(neww), int(newh)+}++func interpolatePoint(dst *image.NRGBA, dstX, dstY int, src *image.NRGBA, xf, yf float64, bgColor color.NRGBA) {+ dstIndex := dstY*dst.Stride + dstX*4++ x0 := int(math.Floor(xf))+ y0 := int(math.Floor(yf))+ bounds := src.Bounds()+ if !image.Pt(x0, y0).In(image.Rect(bounds.Min.X-1, bounds.Min.Y-1, bounds.Max.X, bounds.Max.Y)) {+ dst.Pix[dstIndex+0] = bgColor.R+ dst.Pix[dstIndex+1] = bgColor.G+ dst.Pix[dstIndex+2] = bgColor.B+ dst.Pix[dstIndex+3] = bgColor.A+ return+ }++ xq := xf - float64(x0)+ yq := yf - float64(y0)++ var pxs [4]color.NRGBA+ var cfs [4]float64++ for i := 0; i < 2; i++ {+ for j := 0; j < 2; j++ {+ k := i*2 + j+ pt := image.Pt(x0+j, y0+i)+ if pt.In(bounds) {+ l := pt.Y*src.Stride + pt.X*4+ pxs[k].R = src.Pix[l+0]+ pxs[k].G = src.Pix[l+1]+ pxs[k].B = src.Pix[l+2]+ pxs[k].A = src.Pix[l+3]+ } else {+ pxs[k] = bgColor+ }+ }+ }++ cfs[0] = (1 - xq) * (1 - yq)+ cfs[1] = xq * (1 - yq)+ cfs[2] = (1 - xq) * yq+ cfs[3] = xq * yq++ var r, g, b, a float64+ for i := range pxs {+ wa := float64(pxs[i].A) * cfs[i]+ r += float64(pxs[i].R) * wa+ g += float64(pxs[i].G) * wa+ b += float64(pxs[i].B) * wa+ a += wa+ }++ if a != 0 {+ r /= a+ g /= a+ b /= a+ }++ dst.Pix[dstIndex+0] = clamp(r)+ dst.Pix[dstIndex+1] = clamp(g)+ dst.Pix[dstIndex+2] = clamp(b)+ dst.Pix[dstIndex+3] = clamp(a)+}diff --git a/vendor/github.com/disintegration/imaging/utils.go b/vendor/github.com/disintegration/imaging/utils.gonew file mode 100644index 000000000..3b6ad2e49--- /dev/null+++ b/vendor/github.com/disintegration/imaging/utils.go@@ -0,0 +1,83 @@+package imaging++import (+ "image"+ "runtime"+ "sync"+)++// parallel processes the data in separate goroutines.+func parallel(start, stop int, fn func(<-chan int)) {+ count := stop - start+ if count < 1 {+ return+ }++ procs := runtime.GOMAXPROCS(0)+ if procs > count {+ procs = count+ }++ c := make(chan int, count)+ for i := start; i < stop; i++ {+ c <- i+ }+ close(c)++ var wg sync.WaitGroup+ for i := 0; i < procs; i++ {+ wg.Add(1)+ go func() {+ defer wg.Done()+ fn(c)+ }()+ }+ wg.Wait()+}++// absint returns the absolute value of i.+func absint(i int) int {+ if i < 0 {+ return -i+ }+ return i+}++// clamp rounds and clamps float64 value to fit into uint8.+func clamp(x float64) uint8 {+ v := int64(x + 0.5)+ if v > 255 {+ return 255+ }+ if v > 0 {+ return uint8(v)+ }+ return 0+}++func reverse(pix []uint8) {+ if len(pix) <= 4 {+ return+ }+ i := 0+ j := len(pix) - 4+ for i < j {+ pix[i+0], pix[j+0] = pix[j+0], pix[i+0]+ pix[i+1], pix[j+1] = pix[j+1], pix[i+1]+ pix[i+2], pix[j+2] = pix[j+2], pix[i+2]+ pix[i+3], pix[j+3] = pix[j+3], pix[i+3]+ i += 4+ j -= 4+ }+}++func toNRGBA(img image.Image) *image.NRGBA {+ if img, ok := img.(*image.NRGBA); ok {+ return &image.NRGBA{+ Pix: img.Pix,+ Stride: img.Stride,+ Rect: img.Rect.Sub(img.Rect.Min),+ }+ }+ return Clone(img)+}diff --git a/vendor/golang.org/x/image/bmp/reader.go b/vendor/golang.org/x/image/bmp/reader.gonew file mode 100644index 000000000..a0f2715cd--- /dev/null+++ b/vendor/golang.org/x/image/bmp/reader.go@@ -0,0 +1,199 @@+// Copyright 2011 The 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 bmp implements a BMP image decoder and encoder.+//+// The BMP specification is at http://www.digicamsoft.com/bmp/bmp.html.+package bmp // import "golang.org/x/image/bmp"++import (+ "errors"+ "image"+ "image/color"+ "io"+)++// ErrUnsupported means that the input BMP image uses a valid but unsupported+// feature.+var ErrUnsupported = errors.New("bmp: unsupported BMP image")++func readUint16(b []byte) uint16 {+ return uint16(b[0]) | uint16(b[1])<<8+}++func readUint32(b []byte) uint32 {+ return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24+}++// decodePaletted reads an 8 bit-per-pixel BMP image from r.+// If topDown is false, the image rows will be read bottom-up.+func decodePaletted(r io.Reader, c image.Config, topDown bool) (image.Image, error) {+ paletted := image.NewPaletted(image.Rect(0, 0, c.Width, c.Height), c.ColorModel.(color.Palette))+ if c.Width == 0 || c.Height == 0 {+ return paletted, nil+ }+ var tmp [4]byte+ y0, y1, yDelta := c.Height-1, -1, -1+ if topDown {+ y0, y1, yDelta = 0, c.Height, +1+ }+ for y := y0; y != y1; y += yDelta {+ p := paletted.Pix[y*paletted.Stride : y*paletted.Stride+c.Width]+ if _, err := io.ReadFull(r, p); err != nil {+ return nil, err+ }+ // Each row is 4-byte aligned.+ if c.Width%4 != 0 {+ _, err := io.ReadFull(r, tmp[:4-c.Width%4])+ if err != nil {+ return nil, err+ }+ }+ }+ return paletted, nil+}++// decodeRGB reads a 24 bit-per-pixel BMP image from r.+// If topDown is false, the image rows will be read bottom-up.+func decodeRGB(r io.Reader, c image.Config, topDown bool) (image.Image, error) {+ rgba := image.NewRGBA(image.Rect(0, 0, c.Width, c.Height))+ if c.Width == 0 || c.Height == 0 {+ return rgba, nil+ }+ // There are 3 bytes per pixel, and each row is 4-byte aligned.+ b := make([]byte, (3*c.Width+3)&^3)+ y0, y1, yDelta := c.Height-1, -1, -1+ if topDown {+ y0, y1, yDelta = 0, c.Height, +1+ }+ for y := y0; y != y1; y += yDelta {+ if _, err := io.ReadFull(r, b); err != nil {+ return nil, err+ }+ p := rgba.Pix[y*rgba.Stride : y*rgba.Stride+c.Width*4]+ for i, j := 0, 0; i < len(p); i, j = i+4, j+3 {+ // BMP images are stored in BGR order rather than RGB order.+ p[i+0] = b[j+2]+ p[i+1] = b[j+1]+ p[i+2] = b[j+0]+ p[i+3] = 0xFF+ }+ }+ return rgba, nil+}++// decodeNRGBA reads a 32 bit-per-pixel BMP image from r.+// If topDown is false, the image rows will be read bottom-up.+func decodeNRGBA(r io.Reader, c image.Config, topDown bool) (image.Image, error) {+ rgba := image.NewNRGBA(image.Rect(0, 0, c.Width, c.Height))+ if c.Width == 0 || c.Height == 0 {+ return rgba, nil+ }+ y0, y1, yDelta := c.Height-1, -1, -1+ if topDown {+ y0, y1, yDelta = 0, c.Height, +1+ }+ for y := y0; y != y1; y += yDelta {+ p := rgba.Pix[y*rgba.Stride : y*rgba.Stride+c.Width*4]+ if _, err := io.ReadFull(r, p); err != nil {+ return nil, err+ }+ for i := 0; i < len(p); i += 4 {+ // BMP images are stored in BGRA order rather than RGBA order.+ p[i+0], p[i+2] = p[i+2], p[i+0]+ }+ }+ return rgba, nil+}++// Decode reads a BMP image from r and returns it as an image.Image.+// Limitation: The file must be 8, 24 or 32 bits per pixel.+func Decode(r io.Reader) (image.Image, error) {+ c, bpp, topDown, err := decodeConfig(r)+ if err != nil {+ return nil, err+ }+ switch bpp {+ case 8:+ return decodePaletted(r, c, topDown)+ case 24:+ return decodeRGB(r, c, topDown)+ case 32:+ return decodeNRGBA(r, c, topDown)+ }+ panic("unreachable")+}++// DecodeConfig returns the color model and dimensions of a BMP image without+// decoding the entire image.+// Limitation: The file must be 8, 24 or 32 bits per pixel.+func DecodeConfig(r io.Reader) (image.Config, error) {+ config, _, _, err := decodeConfig(r)+ return config, err+}++func decodeConfig(r io.Reader) (config image.Config, bitsPerPixel int, topDown bool, err error) {+ // We only support those BMP images that are a BITMAPFILEHEADER+ // immediately followed by a BITMAPINFOHEADER.+ const (+ fileHeaderLen = 14+ infoHeaderLen = 40+ )+ var b [1024]byte+ if _, err := io.ReadFull(r, b[:fileHeaderLen+infoHeaderLen]); err != nil {+ return image.Config{}, 0, false, err+ }+ if string(b[:2]) != "BM" {+ return image.Config{}, 0, false, errors.New("bmp: invalid format")+ }+ offset := readUint32(b[10:14])+ if readUint32(b[14:18]) != infoHeaderLen {+ return image.Config{}, 0, false, ErrUnsupported+ }+ width := int(int32(readUint32(b[18:22])))+ height := int(int32(readUint32(b[22:26])))+ if height < 0 {+ height, topDown = -height, true+ }+ if width < 0 || height < 0 {+ return image.Config{}, 0, false, ErrUnsupported+ }+ // We only support 1 plane, 8 or 24 bits per pixel and no compression.+ planes, bpp, compression := readUint16(b[26:28]), readUint16(b[28:30]), readUint32(b[30:34])+ if planes != 1 || compression != 0 {+ return image.Config{}, 0, false, ErrUnsupported+ }+ switch bpp {+ case 8:+ if offset != fileHeaderLen+infoHeaderLen+256*4 {+ return image.Config{}, 0, false, ErrUnsupported+ }+ _, err = io.ReadFull(r, b[:256*4])+ if err != nil {+ return image.Config{}, 0, false, err+ }+ pcm := make(color.Palette, 256)+ for i := range pcm {+ // BMP images are stored in BGR order rather than RGB order.+ // Every 4th byte is padding.+ pcm[i] = color.RGBA{b[4*i+2], b[4*i+1], b[4*i+0], 0xFF}+ }+ return image.Config{ColorModel: pcm, Width: width, Height: height}, 8, topDown, nil+ case 24:+ if offset != fileHeaderLen+infoHeaderLen {+ return image.Config{}, 0, false, ErrUnsupported+ }+ return image.Config{ColorModel: color.RGBAModel, Width: width, Height: height}, 24, topDown, nil+ case 32:+ if offset != fileHeaderLen+infoHeaderLen {+ return image.Config{}, 0, false, ErrUnsupported+ }+ return image.Config{ColorModel: color.RGBAModel, Width: width, Height: height}, 32, topDown, nil+ }+ return image.Config{}, 0, false, ErrUnsupported+}++func init() {+ image.RegisterFormat("bmp", "BM????\x00\x00\x00\x00", Decode, DecodeConfig)+}diff --git a/vendor/golang.org/x/image/bmp/writer.go b/vendor/golang.org/x/image/bmp/writer.gonew file mode 100644index 000000000..6947968a4--- /dev/null+++ b/vendor/golang.org/x/image/bmp/writer.go@@ -0,0 +1,166 @@+// Copyright 2013 The 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 bmp++import (+ "encoding/binary"+ "errors"+ "image"+ "io"+)++type header struct {+ sigBM [2]byte+ fileSize uint32+ resverved [2]uint16+ pixOffset uint32+ dibHeaderSize uint32+ width uint32+ height uint32+ colorPlane uint16+ bpp uint16+ compression uint32+ imageSize uint32+ xPixelsPerMeter uint32+ yPixelsPerMeter uint32+ colorUse uint32+ colorImportant uint32+}++func encodePaletted(w io.Writer, pix []uint8, dx, dy, stride, step int) error {+ var padding []byte+ if dx < step {+ padding = make([]byte, step-dx)+ }+ for y := dy - 1; y >= 0; y-- {+ min := y*stride + 0+ max := y*stride + dx+ if _, err := w.Write(pix[min:max]); err != nil {+ return err+ }+ if padding != nil {+ if _, err := w.Write(padding); err != nil {+ return err+ }+ }+ }+ return nil+}++func encodeRGBA(w io.Writer, pix []uint8, dx, dy, stride, step int) error {+ buf := make([]byte, step)+ for y := dy - 1; y >= 0; y-- {+ min := y*stride + 0+ max := y*stride + dx*4+ off := 0+ for i := min; i < max; i += 4 {+ buf[off+2] = pix[i+0]+ buf[off+1] = pix[i+1]+ buf[off+0] = pix[i+2]+ off += 3+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++func encode(w io.Writer, m image.Image, step int) error {+ b := m.Bounds()+ buf := make([]byte, step)+ for y := b.Max.Y - 1; y >= b.Min.Y; y-- {+ off := 0+ for x := b.Min.X; x < b.Max.X; x++ {+ r, g, b, _ := m.At(x, y).RGBA()+ buf[off+2] = byte(r >> 8)+ buf[off+1] = byte(g >> 8)+ buf[off+0] = byte(b >> 8)+ off += 3+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++// Encode writes the image m to w in BMP format.+func Encode(w io.Writer, m image.Image) error {+ d := m.Bounds().Size()+ if d.X < 0 || d.Y < 0 {+ return errors.New("bmp: negative bounds")+ }+ h := &header{+ sigBM: [2]byte{'B', 'M'},+ fileSize: 14 + 40,+ pixOffset: 14 + 40,+ dibHeaderSize: 40,+ width: uint32(d.X),+ height: uint32(d.Y),+ colorPlane: 1,+ }++ var step int+ var palette []byte+ switch m := m.(type) {+ case *image.Gray:+ step = (d.X + 3) &^ 3+ palette = make([]byte, 1024)+ for i := 0; i < 256; i++ {+ palette[i*4+0] = uint8(i)+ palette[i*4+1] = uint8(i)+ palette[i*4+2] = uint8(i)+ palette[i*4+3] = 0xFF+ }+ h.imageSize = uint32(d.Y * step)+ h.fileSize += uint32(len(palette)) + h.imageSize+ h.pixOffset += uint32(len(palette))+ h.bpp = 8++ case *image.Paletted:+ step = (d.X + 3) &^ 3+ palette = make([]byte, 1024)+ for i := 0; i < len(m.Palette) && i < 256; i++ {+ r, g, b, _ := m.Palette[i].RGBA()+ palette[i*4+0] = uint8(b >> 8)+ palette[i*4+1] = uint8(g >> 8)+ palette[i*4+2] = uint8(r >> 8)+ palette[i*4+3] = 0xFF+ }+ h.imageSize = uint32(d.Y * step)+ h.fileSize += uint32(len(palette)) + h.imageSize+ h.pixOffset += uint32(len(palette))+ h.bpp = 8+ default:+ step = (3*d.X + 3) &^ 3+ h.imageSize = uint32(d.Y * step)+ h.fileSize += h.imageSize+ h.bpp = 24+ }++ if err := binary.Write(w, binary.LittleEndian, h); err != nil {+ return err+ }+ if palette != nil {+ if err := binary.Write(w, binary.LittleEndian, palette); err != nil {+ return err+ }+ }++ if d.X == 0 || d.Y == 0 {+ return nil+ }++ switch m := m.(type) {+ case *image.Gray:+ return encodePaletted(w, m.Pix, d.X, d.Y, m.Stride, step)+ case *image.Paletted:+ return encodePaletted(w, m.Pix, d.X, d.Y, m.Stride, step)+ case *image.RGBA:+ return encodeRGBA(w, m.Pix, d.X, d.Y, m.Stride, step)+ }+ return encode(w, m, step)+}diff --git a/vendor/golang.org/x/image/tiff/buffer.go b/vendor/golang.org/x/image/tiff/buffer.gonew file mode 100644index 000000000..d1801be48--- /dev/null+++ b/vendor/golang.org/x/image/tiff/buffer.go@@ -0,0 +1,69 @@+// Copyright 2011 The 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 tiff++import "io"++// buffer buffers an io.Reader to satisfy io.ReaderAt.+type buffer struct {+ r io.Reader+ buf []byte+}++// fill reads data from b.r until the buffer contains at least end bytes.+func (b *buffer) fill(end int) error {+ m := len(b.buf)+ if end > m {+ if end > cap(b.buf) {+ newcap := 1024+ for newcap < end {+ newcap *= 2+ }+ newbuf := make([]byte, end, newcap)+ copy(newbuf, b.buf)+ b.buf = newbuf+ } else {+ b.buf = b.buf[:end]+ }+ if n, err := io.ReadFull(b.r, b.buf[m:end]); err != nil {+ end = m + n+ b.buf = b.buf[:end]+ return err+ }+ }+ return nil+}++func (b *buffer) ReadAt(p []byte, off int64) (int, error) {+ o := int(off)+ end := o + len(p)+ if int64(end) != off+int64(len(p)) {+ return 0, io.ErrUnexpectedEOF+ }++ err := b.fill(end)+ return copy(p, b.buf[o:end]), err+}++// Slice returns a slice of the underlying buffer. The slice contains+// n bytes starting at offset off.+func (b *buffer) Slice(off, n int) ([]byte, error) {+ end := off + n+ if err := b.fill(end); err != nil {+ return nil, err+ }+ return b.buf[off:end], nil+}++// newReaderAt converts an io.Reader into an io.ReaderAt.+func newReaderAt(r io.Reader) io.ReaderAt {+ if ra, ok := r.(io.ReaderAt); ok {+ return ra+ }+ return &buffer{+ r: r,+ buf: make([]byte, 0, 1024),+ }+}diff --git a/vendor/golang.org/x/image/tiff/compress.go b/vendor/golang.org/x/image/tiff/compress.gonew file mode 100644index 000000000..3f176f00a--- /dev/null+++ b/vendor/golang.org/x/image/tiff/compress.go@@ -0,0 +1,58 @@+// Copyright 2011 The 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 tiff++import (+ "bufio"+ "io"+)++type byteReader interface {+ io.Reader+ io.ByteReader+}++// unpackBits decodes the PackBits-compressed data in src and returns the+// uncompressed data.+//+// The PackBits compression format is described in section 9 (p. 42)+// of the TIFF spec.+func unpackBits(r io.Reader) ([]byte, error) {+ buf := make([]byte, 128)+ dst := make([]byte, 0, 1024)+ br, ok := r.(byteReader)+ if !ok {+ br = bufio.NewReader(r)+ }++ for {+ b, err := br.ReadByte()+ if err != nil {+ if err == io.EOF {+ return dst, nil+ }+ return nil, err+ }+ code := int(int8(b))+ switch {+ case code >= 0:+ n, err := io.ReadFull(br, buf[:code+1])+ if err != nil {+ return nil, err+ }+ dst = append(dst, buf[:n]...)+ case code == -128:+ // No-op.+ default:+ if b, err = br.ReadByte(); err != nil {+ return nil, err+ }+ for j := 0; j < 1-code; j++ {+ buf[j] = b+ }+ dst = append(dst, buf[:1-code]...)+ }+ }+}diff --git a/vendor/golang.org/x/image/tiff/consts.go b/vendor/golang.org/x/image/tiff/consts.gonew file mode 100644index 000000000..3c51a70be--- /dev/null+++ b/vendor/golang.org/x/image/tiff/consts.go@@ -0,0 +1,133 @@+// Copyright 2011 The 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 tiff++// A tiff image file contains one or more images. The metadata+// of each image is contained in an Image File Directory (IFD),+// which contains entries of 12 bytes each and is described+// on page 14-16 of the specification. An IFD entry consists of+//+// - a tag, which describes the signification of the entry,+// - the data type and length of the entry,+// - the data itself or a pointer to it if it is more than 4 bytes.+//+// The presence of a length means that each IFD is effectively an array.++const (+ leHeader = "II\x2A\x00" // Header for little-endian files.+ beHeader = "MM\x00\x2A" // Header for big-endian files.++ ifdLen = 12 // Length of an IFD entry in bytes.+)++// Data types (p. 14-16 of the spec).+const (+ dtByte = 1+ dtASCII = 2+ dtShort = 3+ dtLong = 4+ dtRational = 5+)++// The length of one instance of each data type in bytes.+var lengths = [...]uint32{0, 1, 1, 2, 4, 8}++// Tags (see p. 28-41 of the spec).+const (+ tImageWidth = 256+ tImageLength = 257+ tBitsPerSample = 258+ tCompression = 259+ tPhotometricInterpretation = 262++ tStripOffsets = 273+ tSamplesPerPixel = 277+ tRowsPerStrip = 278+ tStripByteCounts = 279++ tTileWidth = 322+ tTileLength = 323+ tTileOffsets = 324+ tTileByteCounts = 325++ tXResolution = 282+ tYResolution = 283+ tResolutionUnit = 296++ tPredictor = 317+ tColorMap = 320+ tExtraSamples = 338+ tSampleFormat = 339+)++// Compression types (defined in various places in the spec and supplements).+const (+ cNone = 1+ cCCITT = 2+ cG3 = 3 // Group 3 Fax.+ cG4 = 4 // Group 4 Fax.+ cLZW = 5+ cJPEGOld = 6 // Superseded by cJPEG.+ cJPEG = 7+ cDeflate = 8 // zlib compression.+ cPackBits = 32773+ cDeflateOld = 32946 // Superseded by cDeflate.+)++// Photometric interpretation values (see p. 37 of the spec).+const (+ pWhiteIsZero = 0+ pBlackIsZero = 1+ pRGB = 2+ pPaletted = 3+ pTransMask = 4 // transparency mask+ pCMYK = 5+ pYCbCr = 6+ pCIELab = 8+)++// Values for the tPredictor tag (page 64-65 of the spec).+const (+ prNone = 1+ prHorizontal = 2+)++// Values for the tResolutionUnit tag (page 18).+const (+ resNone = 1+ resPerInch = 2 // Dots per inch.+ resPerCM = 3 // Dots per centimeter.+)++// imageMode represents the mode of the image.+type imageMode int++const (+ mBilevel imageMode = iota+ mPaletted+ mGray+ mGrayInvert+ mRGB+ mRGBA+ mNRGBA+)++// CompressionType describes the type of compression used in Options.+type CompressionType int++const (+ Uncompressed CompressionType = iota+ Deflate+)++// specValue returns the compression type constant from the TIFF spec that+// is equivalent to c.+func (c CompressionType) specValue() uint32 {+ switch c {+ case Deflate:+ return cDeflate+ }+ return cNone+}diff --git a/vendor/golang.org/x/image/tiff/lzw/reader.go b/vendor/golang.org/x/image/tiff/lzw/reader.gonew file mode 100644index 000000000..51ae39f8a--- /dev/null+++ b/vendor/golang.org/x/image/tiff/lzw/reader.go@@ -0,0 +1,272 @@+// Copyright 2011 The 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 lzw implements the Lempel-Ziv-Welch compressed data format,+// described in T. A. Welch, ``A Technique for High-Performance Data+// Compression'', Computer, 17(6) (June 1984), pp 8-19.+//+// In particular, it implements LZW as used by the TIFF file format, including+// an "off by one" algorithmic difference when compared to standard LZW.+package lzw // import "golang.org/x/image/tiff/lzw"++/*+This file was branched from src/pkg/compress/lzw/reader.go in the+standard library. Differences from the original are marked with "NOTE".++The tif_lzw.c file in the libtiff C library has this comment:++----+The 5.0 spec describes a different algorithm than Aldus+implements. Specifically, Aldus does code length transitions+one code earlier than should be done (for real LZW).+Earlier versions of this library implemented the correct+LZW algorithm, but emitted codes in a bit order opposite+to the TIFF spec. Thus, to maintain compatibility w/ Aldus+we interpret MSB-LSB ordered codes to be images written w/+old versions of this library, but otherwise adhere to the+Aldus "off by one" algorithm.+----++The Go code doesn't read (invalid) TIFF files written by old versions of+libtiff, but the LZW algorithm in this package still differs from the one in+Go's standard package library to accomodate this "off by one" in valid TIFFs.+*/++import (+ "bufio"+ "errors"+ "fmt"+ "io"+)++// Order specifies the bit ordering in an LZW data stream.+type Order int++const (+ // LSB means Least Significant Bits first, as used in the GIF file format.+ LSB Order = iota+ // MSB means Most Significant Bits first, as used in the TIFF and PDF+ // file formats.+ MSB+)++const (+ maxWidth = 12+ decoderInvalidCode = 0xffff+ flushBuffer = 1 << maxWidth+)++// decoder is the state from which the readXxx method converts a byte+// stream into a code stream.+type decoder struct {+ r io.ByteReader+ bits uint32+ nBits uint+ width uint+ read func(*decoder) (uint16, error) // readLSB or readMSB+ litWidth int // width in bits of literal codes+ err error++ // The first 1<<litWidth codes are literal codes.+ // The next two codes mean clear and EOF.+ // Other valid codes are in the range [lo, hi] where lo := clear + 2,+ // with the upper bound incrementing on each code seen.+ // overflow is the code at which hi overflows the code width. NOTE: TIFF's LZW is "off by one".+ // last is the most recently seen code, or decoderInvalidCode.+ clear, eof, hi, overflow, last uint16++ // Each code c in [lo, hi] expands to two or more bytes. For c != hi:+ // suffix[c] is the last of these bytes.+ // prefix[c] is the code for all but the last byte.+ // This code can either be a literal code or another code in [lo, c).+ // The c == hi case is a special case.+ suffix [1 << maxWidth]uint8+ prefix [1 << maxWidth]uint16++ // output is the temporary output buffer.+ // Literal codes are accumulated from the start of the buffer.+ // Non-literal codes decode to a sequence of suffixes that are first+ // written right-to-left from the end of the buffer before being copied+ // to the start of the buffer.+ // It is flushed when it contains >= 1<<maxWidth bytes,+ // so that there is always room to decode an entire code.+ output [2 * 1 << maxWidth]byte+ o int // write index into output+ toRead []byte // bytes to return from Read+}++// readLSB returns the next code for "Least Significant Bits first" data.+func (d *decoder) readLSB() (uint16, error) {+ for d.nBits < d.width {+ x, err := d.r.ReadByte()+ if err != nil {+ return 0, err+ }+ d.bits |= uint32(x) << d.nBits+ d.nBits += 8+ }+ code := uint16(d.bits & (1<<d.width - 1))+ d.bits >>= d.width+ d.nBits -= d.width+ return code, nil+}++// readMSB returns the next code for "Most Significant Bits first" data.+func (d *decoder) readMSB() (uint16, error) {+ for d.nBits < d.width {+ x, err := d.r.ReadByte()+ if err != nil {+ return 0, err+ }+ d.bits |= uint32(x) << (24 - d.nBits)+ d.nBits += 8+ }+ code := uint16(d.bits >> (32 - d.width))+ d.bits <<= d.width+ d.nBits -= d.width+ return code, nil+}++func (d *decoder) Read(b []byte) (int, error) {+ for {+ if len(d.toRead) > 0 {+ n := copy(b, d.toRead)+ d.toRead = d.toRead[n:]+ return n, nil+ }+ if d.err != nil {+ return 0, d.err+ }+ d.decode()+ }+}++// decode decompresses bytes from r and leaves them in d.toRead.+// read specifies how to decode bytes into codes.+// litWidth is the width in bits of literal codes.+func (d *decoder) decode() {+ // Loop over the code stream, converting codes into decompressed bytes.+loop:+ for {+ code, err := d.read(d)+ if err != nil {+ if err == io.EOF {+ err = io.ErrUnexpectedEOF+ }+ d.err = err+ break+ }+ switch {+ case code < d.clear:+ // We have a literal code.+ d.output[d.o] = uint8(code)+ d.o+++ if d.last != decoderInvalidCode {+ // Save what the hi code expands to.+ d.suffix[d.hi] = uint8(code)+ d.prefix[d.hi] = d.last+ }+ case code == d.clear:+ d.width = 1 + uint(d.litWidth)+ d.hi = d.eof+ d.overflow = 1 << d.width+ d.last = decoderInvalidCode+ continue+ case code == d.eof:+ d.err = io.EOF+ break loop+ case code <= d.hi:+ c, i := code, len(d.output)-1+ if code == d.hi {+ // code == hi is a special case which expands to the last expansion+ // followed by the head of the last expansion. To find the head, we walk+ // the prefix chain until we find a literal code.+ c = d.last+ for c >= d.clear {+ c = d.prefix[c]+ }+ d.output[i] = uint8(c)+ i--+ c = d.last+ }+ // Copy the suffix chain into output and then write that to w.+ for c >= d.clear {+ d.output[i] = d.suffix[c]+ i--+ c = d.prefix[c]+ }+ d.output[i] = uint8(c)+ d.o += copy(d.output[d.o:], d.output[i:])+ if d.last != decoderInvalidCode {+ // Save what the hi code expands to.+ d.suffix[d.hi] = uint8(c)+ d.prefix[d.hi] = d.last+ }+ default:+ d.err = errors.New("lzw: invalid code")+ break loop+ }+ d.last, d.hi = code, d.hi+1+ if d.hi+1 >= d.overflow { // NOTE: the "+1" is where TIFF's LZW differs from the standard algorithm.+ if d.width == maxWidth {+ d.last = decoderInvalidCode+ } else {+ d.width+++ d.overflow <<= 1+ }+ }+ if d.o >= flushBuffer {+ break+ }+ }+ // Flush pending output.+ d.toRead = d.output[:d.o]+ d.o = 0+}++var errClosed = errors.New("lzw: reader/writer is closed")++func (d *decoder) Close() error {+ d.err = errClosed // in case any Reads come along+ return nil+}++// NewReader creates a new io.ReadCloser.+// Reads from the returned io.ReadCloser read and decompress data from r.+// If r does not also implement io.ByteReader,+// the decompressor may read more data than necessary from r.+// It is the caller's responsibility to call Close on the ReadCloser when+// finished reading.+// The number of bits to use for literal codes, litWidth, must be in the+// range [2,8] and is typically 8. It must equal the litWidth+// used during compression.+func NewReader(r io.Reader, order Order, litWidth int) io.ReadCloser {+ d := new(decoder)+ switch order {+ case LSB:+ d.read = (*decoder).readLSB+ case MSB:+ d.read = (*decoder).readMSB+ default:+ d.err = errors.New("lzw: unknown order")+ return d+ }+ if litWidth < 2 || 8 < litWidth {+ d.err = fmt.Errorf("lzw: litWidth %d out of range", litWidth)+ return d+ }+ if br, ok := r.(io.ByteReader); ok {+ d.r = br+ } else {+ d.r = bufio.NewReader(r)+ }+ d.litWidth = litWidth+ d.width = 1 + uint(litWidth)+ d.clear = uint16(1) << uint(litWidth)+ d.eof, d.hi = d.clear+1, d.clear+1+ d.overflow = uint16(1) << d.width+ d.last = decoderInvalidCode++ return d+}diff --git a/vendor/golang.org/x/image/tiff/reader.go b/vendor/golang.org/x/image/tiff/reader.gonew file mode 100644index 000000000..0e3d3325f--- /dev/null+++ b/vendor/golang.org/x/image/tiff/reader.go@@ -0,0 +1,681 @@+// Copyright 2011 The 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 tiff implements a TIFF image decoder and encoder.+//+// The TIFF specification is at http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf+package tiff // import "golang.org/x/image/tiff"++import (+ "compress/zlib"+ "encoding/binary"+ "fmt"+ "image"+ "image/color"+ "io"+ "io/ioutil"+ "math"++ "golang.org/x/image/tiff/lzw"+)++// A FormatError reports that the input is not a valid TIFF image.+type FormatError string++func (e FormatError) Error() string {+ return "tiff: invalid format: " + string(e)+}++// An UnsupportedError reports that the input uses a valid but+// unimplemented feature.+type UnsupportedError string++func (e UnsupportedError) Error() string {+ return "tiff: unsupported feature: " + string(e)+}++var errNoPixels = FormatError("not enough pixel data")++type decoder struct {+ r io.ReaderAt+ byteOrder binary.ByteOrder+ config image.Config+ mode imageMode+ bpp uint+ features map[int][]uint+ palette []color.Color++ buf []byte+ off int // Current offset in buf.+ v uint32 // Buffer value for reading with arbitrary bit depths.+ nbits uint // Remaining number of bits in v.+}++// firstVal returns the first uint of the features entry with the given tag,+// or 0 if the tag does not exist.+func (d *decoder) firstVal(tag int) uint {+ f := d.features[tag]+ if len(f) == 0 {+ return 0+ }+ return f[0]+}++// ifdUint decodes the IFD entry in p, which must be of the Byte, Short+// or Long type, and returns the decoded uint values.+func (d *decoder) ifdUint(p []byte) (u []uint, err error) {+ var raw []byte+ if len(p) < ifdLen {+ return nil, FormatError("bad IFD entry")+ }++ datatype := d.byteOrder.Uint16(p[2:4])+ if dt := int(datatype); dt <= 0 || dt >= len(lengths) {+ return nil, UnsupportedError("IFD entry datatype")+ }++ count := d.byteOrder.Uint32(p[4:8])+ if count > math.MaxInt32/lengths[datatype] {+ return nil, FormatError("IFD data too large")+ }+ if datalen := lengths[datatype] * count; datalen > 4 {+ // The IFD contains a pointer to the real value.+ raw = make([]byte, datalen)+ _, err = d.r.ReadAt(raw, int64(d.byteOrder.Uint32(p[8:12])))+ } else {+ raw = p[8 : 8+datalen]+ }+ if err != nil {+ return nil, err+ }++ u = make([]uint, count)+ switch datatype {+ case dtByte:+ for i := uint32(0); i < count; i++ {+ u[i] = uint(raw[i])+ }+ case dtShort:+ for i := uint32(0); i < count; i++ {+ u[i] = uint(d.byteOrder.Uint16(raw[2*i : 2*(i+1)]))+ }+ case dtLong:+ for i := uint32(0); i < count; i++ {+ u[i] = uint(d.byteOrder.Uint32(raw[4*i : 4*(i+1)]))+ }+ default:+ return nil, UnsupportedError("data type")+ }+ return u, nil+}++// parseIFD decides whether the the IFD entry in p is "interesting" and+// stows away the data in the decoder. It returns the tag number of the+// entry and an error, if any.+func (d *decoder) parseIFD(p []byte) (int, error) {+ tag := d.byteOrder.Uint16(p[0:2])+ switch tag {+ case tBitsPerSample,+ tExtraSamples,+ tPhotometricInterpretation,+ tCompression,+ tPredictor,+ tStripOffsets,+ tStripByteCounts,+ tRowsPerStrip,+ tTileWidth,+ tTileLength,+ tTileOffsets,+ tTileByteCounts,+ tImageLength,+ tImageWidth:+ val, err := d.ifdUint(p)+ if err != nil {+ return 0, err+ }+ d.features[int(tag)] = val+ case tColorMap:+ val, err := d.ifdUint(p)+ if err != nil {+ return 0, err+ }+ numcolors := len(val) / 3+ if len(val)%3 != 0 || numcolors <= 0 || numcolors > 256 {+ return 0, FormatError("bad ColorMap length")+ }+ d.palette = make([]color.Color, numcolors)+ for i := 0; i < numcolors; i++ {+ d.palette[i] = color.RGBA64{+ uint16(val[i]),+ uint16(val[i+numcolors]),+ uint16(val[i+2*numcolors]),+ 0xffff,+ }+ }+ case tSampleFormat:+ // Page 27 of the spec: If the SampleFormat is present and+ // the value is not 1 [= unsigned integer data], a Baseline+ // TIFF reader that cannot handle the SampleFormat value+ // must terminate the import process gracefully.+ val, err := d.ifdUint(p)+ if err != nil {+ return 0, err+ }+ for _, v := range val {+ if v != 1 {+ return 0, UnsupportedError("sample format")+ }+ }+ }+ return int(tag), nil+}++// readBits reads n bits from the internal buffer starting at the current offset.+func (d *decoder) readBits(n uint) (v uint32, ok bool) {+ for d.nbits < n {+ d.v <<= 8+ if d.off >= len(d.buf) {+ return 0, false+ }+ d.v |= uint32(d.buf[d.off])+ d.off+++ d.nbits += 8+ }+ d.nbits -= n+ rv := d.v >> d.nbits+ d.v &^= rv << d.nbits+ return rv, true+}++// flushBits discards the unread bits in the buffer used by readBits.+// It is used at the end of a line.+func (d *decoder) flushBits() {+ d.v = 0+ d.nbits = 0+}++// minInt returns the smaller of x or y.+func minInt(a, b int) int {+ if a <= b {+ return a+ }+ return b+}++// decode decodes the raw data of an image.+// It reads from d.buf and writes the strip or tile into dst.+func (d *decoder) decode(dst image.Image, xmin, ymin, xmax, ymax int) error {+ d.off = 0++ // Apply horizontal predictor if necessary.+ // In this case, p contains the color difference to the preceding pixel.+ // See page 64-65 of the spec.+ if d.firstVal(tPredictor) == prHorizontal {+ switch d.bpp {+ case 16:+ var off int+ n := 2 * len(d.features[tBitsPerSample]) // bytes per sample times samples per pixel+ for y := ymin; y < ymax; y++ {+ off += n+ for x := 0; x < (xmax-xmin-1)*n; x += 2 {+ if off+2 > len(d.buf) {+ return errNoPixels+ }+ v0 := d.byteOrder.Uint16(d.buf[off-n : off-n+2])+ v1 := d.byteOrder.Uint16(d.buf[off : off+2])+ d.byteOrder.PutUint16(d.buf[off:off+2], v1+v0)+ off += 2+ }+ }+ case 8:+ var off int+ n := 1 * len(d.features[tBitsPerSample]) // bytes per sample times samples per pixel+ for y := ymin; y < ymax; y++ {+ off += n+ for x := 0; x < (xmax-xmin-1)*n; x++ {+ if off >= len(d.buf) {+ return errNoPixels+ }+ d.buf[off] += d.buf[off-n]+ off+++ }+ }+ case 1:+ return UnsupportedError("horizontal predictor with 1 BitsPerSample")+ }+ }++ rMaxX := minInt(xmax, dst.Bounds().Max.X)+ rMaxY := minInt(ymax, dst.Bounds().Max.Y)+ switch d.mode {+ case mGray, mGrayInvert:+ if d.bpp == 16 {+ img := dst.(*image.Gray16)+ for y := ymin; y < rMaxY; y++ {+ for x := xmin; x < rMaxX; x++ {+ if d.off+2 > len(d.buf) {+ return errNoPixels+ }+ v := d.byteOrder.Uint16(d.buf[d.off : d.off+2])+ d.off += 2+ if d.mode == mGrayInvert {+ v = 0xffff - v+ }+ img.SetGray16(x, y, color.Gray16{v})+ }+ }+ } else {+ img := dst.(*image.Gray)+ max := uint32((1 << d.bpp) - 1)+ for y := ymin; y < rMaxY; y++ {+ for x := xmin; x < rMaxX; x++ {+ v, ok := d.readBits(d.bpp)+ if !ok {+ return errNoPixels+ }+ v = v * 0xff / max+ if d.mode == mGrayInvert {+ v = 0xff - v+ }+ img.SetGray(x, y, color.Gray{uint8(v)})+ }+ d.flushBits()+ }+ }+ case mPaletted:+ img := dst.(*image.Paletted)+ for y := ymin; y < rMaxY; y++ {+ for x := xmin; x < rMaxX; x++ {+ v, ok := d.readBits(d.bpp)+ if !ok {+ return errNoPixels+ }+ img.SetColorIndex(x, y, uint8(v))+ }+ d.flushBits()+ }+ case mRGB:+ if d.bpp == 16 {+ img := dst.(*image.RGBA64)+ for y := ymin; y < rMaxY; y++ {+ for x := xmin; x < rMaxX; x++ {+ if d.off+6 > len(d.buf) {+ return errNoPixels+ }+ r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2])+ g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4])+ b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6])+ d.off += 6+ img.SetRGBA64(x, y, color.RGBA64{r, g, b, 0xffff})+ }+ }+ } else {+ img := dst.(*image.RGBA)+ for y := ymin; y < rMaxY; y++ {+ min := img.PixOffset(xmin, y)+ max := img.PixOffset(rMaxX, y)+ off := (y - ymin) * (xmax - xmin) * 3+ for i := min; i < max; i += 4 {+ if off+3 > len(d.buf) {+ return errNoPixels+ }+ img.Pix[i+0] = d.buf[off+0]+ img.Pix[i+1] = d.buf[off+1]+ img.Pix[i+2] = d.buf[off+2]+ img.Pix[i+3] = 0xff+ off += 3+ }+ }+ }+ case mNRGBA:+ if d.bpp == 16 {+ img := dst.(*image.NRGBA64)+ for y := ymin; y < rMaxY; y++ {+ for x := xmin; x < rMaxX; x++ {+ if d.off+8 > len(d.buf) {+ return errNoPixels+ }+ r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2])+ g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4])+ b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6])+ a := d.byteOrder.Uint16(d.buf[d.off+6 : d.off+8])+ d.off += 8+ img.SetNRGBA64(x, y, color.NRGBA64{r, g, b, a})+ }+ }+ } else {+ img := dst.(*image.NRGBA)+ for y := ymin; y < rMaxY; y++ {+ min := img.PixOffset(xmin, y)+ max := img.PixOffset(rMaxX, y)+ i0, i1 := (y-ymin)*(xmax-xmin)*4, (y-ymin+1)*(xmax-xmin)*4+ if i1 > len(d.buf) {+ return errNoPixels+ }+ copy(img.Pix[min:max], d.buf[i0:i1])+ }+ }+ case mRGBA:+ if d.bpp == 16 {+ img := dst.(*image.RGBA64)+ for y := ymin; y < rMaxY; y++ {+ for x := xmin; x < rMaxX; x++ {+ if d.off+8 > len(d.buf) {+ return errNoPixels+ }+ r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2])+ g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4])+ b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6])+ a := d.byteOrder.Uint16(d.buf[d.off+6 : d.off+8])+ d.off += 8+ img.SetRGBA64(x, y, color.RGBA64{r, g, b, a})+ }+ }+ } else {+ img := dst.(*image.RGBA)+ for y := ymin; y < rMaxY; y++ {+ min := img.PixOffset(xmin, y)+ max := img.PixOffset(rMaxX, y)+ i0, i1 := (y-ymin)*(xmax-xmin)*4, (y-ymin+1)*(xmax-xmin)*4+ if i1 > len(d.buf) {+ return errNoPixels+ }+ copy(img.Pix[min:max], d.buf[i0:i1])+ }+ }+ }++ return nil+}++func newDecoder(r io.Reader) (*decoder, error) {+ d := &decoder{+ r: newReaderAt(r),+ features: make(map[int][]uint),+ }++ p := make([]byte, 8)+ if _, err := d.r.ReadAt(p, 0); err != nil {+ return nil, err+ }+ switch string(p[0:4]) {+ case leHeader:+ d.byteOrder = binary.LittleEndian+ case beHeader:+ d.byteOrder = binary.BigEndian+ default:+ return nil, FormatError("malformed header")+ }++ ifdOffset := int64(d.byteOrder.Uint32(p[4:8]))++ // The first two bytes contain the number of entries (12 bytes each).+ if _, err := d.r.ReadAt(p[0:2], ifdOffset); err != nil {+ return nil, err+ }+ numItems := int(d.byteOrder.Uint16(p[0:2]))++ // All IFD entries are read in one chunk.+ p = make([]byte, ifdLen*numItems)+ if _, err := d.r.ReadAt(p, ifdOffset+2); err != nil {+ return nil, err+ }++ prevTag := -1+ for i := 0; i < len(p); i += ifdLen {+ tag, err := d.parseIFD(p[i : i+ifdLen])+ if err != nil {+ return nil, err+ }+ if tag <= prevTag {+ return nil, FormatError("tags are not sorted in ascending order")+ }+ prevTag = tag+ }++ d.config.Width = int(d.firstVal(tImageWidth))+ d.config.Height = int(d.firstVal(tImageLength))++ if _, ok := d.features[tBitsPerSample]; !ok {+ return nil, FormatError("BitsPerSample tag missing")+ }+ d.bpp = d.firstVal(tBitsPerSample)+ switch d.bpp {+ case 0:+ return nil, FormatError("BitsPerSample must not be 0")+ case 1, 8, 16:+ // Nothing to do, these are accepted by this implementation.+ default:+ return nil, UnsupportedError(fmt.Sprintf("BitsPerSample of %v", d.bpp))+ }++ // Determine the image mode.+ switch d.firstVal(tPhotometricInterpretation) {+ case pRGB:+ if d.bpp == 16 {+ for _, b := range d.features[tBitsPerSample] {+ if b != 16 {+ return nil, FormatError("wrong number of samples for 16bit RGB")+ }+ }+ } else {+ for _, b := range d.features[tBitsPerSample] {+ if b != 8 {+ return nil, FormatError("wrong number of samples for 8bit RGB")+ }+ }+ }+ // RGB images normally have 3 samples per pixel.+ // If there are more, ExtraSamples (p. 31-32 of the spec)+ // gives their meaning (usually an alpha channel).+ //+ // This implementation does not support extra samples+ // of an unspecified type.+ switch len(d.features[tBitsPerSample]) {+ case 3:+ d.mode = mRGB+ if d.bpp == 16 {+ d.config.ColorModel = color.RGBA64Model+ } else {+ d.config.ColorModel = color.RGBAModel+ }+ case 4:+ switch d.firstVal(tExtraSamples) {+ case 1:+ d.mode = mRGBA+ if d.bpp == 16 {+ d.config.ColorModel = color.RGBA64Model+ } else {+ d.config.ColorModel = color.RGBAModel+ }+ case 2:+ d.mode = mNRGBA+ if d.bpp == 16 {+ d.config.ColorModel = color.NRGBA64Model+ } else {+ d.config.ColorModel = color.NRGBAModel+ }+ default:+ return nil, FormatError("wrong number of samples for RGB")+ }+ default:+ return nil, FormatError("wrong number of samples for RGB")+ }+ case pPaletted:+ d.mode = mPaletted+ d.config.ColorModel = color.Palette(d.palette)+ case pWhiteIsZero:+ d.mode = mGrayInvert+ if d.bpp == 16 {+ d.config.ColorModel = color.Gray16Model+ } else {+ d.config.ColorModel = color.GrayModel+ }+ case pBlackIsZero:+ d.mode = mGray+ if d.bpp == 16 {+ d.config.ColorModel = color.Gray16Model+ } else {+ d.config.ColorModel = color.GrayModel+ }+ default:+ return nil, UnsupportedError("color model")+ }++ return d, nil+}++// DecodeConfig returns the color model and dimensions of a TIFF image without+// decoding the entire image.+func DecodeConfig(r io.Reader) (image.Config, error) {+ d, err := newDecoder(r)+ if err != nil {+ return image.Config{}, err+ }+ return d.config, nil+}++// Decode reads a TIFF image from r and returns it as an image.Image.+// The type of Image returned depends on the contents of the TIFF.+func Decode(r io.Reader) (img image.Image, err error) {+ d, err := newDecoder(r)+ if err != nil {+ return+ }++ blockPadding := false+ blockWidth := d.config.Width+ blockHeight := d.config.Height+ blocksAcross := 1+ blocksDown := 1++ if d.config.Width == 0 {+ blocksAcross = 0+ }+ if d.config.Height == 0 {+ blocksDown = 0+ }++ var blockOffsets, blockCounts []uint++ if int(d.firstVal(tTileWidth)) != 0 {+ blockPadding = true++ blockWidth = int(d.firstVal(tTileWidth))+ blockHeight = int(d.firstVal(tTileLength))++ if blockWidth != 0 {+ blocksAcross = (d.config.Width + blockWidth - 1) / blockWidth+ }+ if blockHeight != 0 {+ blocksDown = (d.config.Height + blockHeight - 1) / blockHeight+ }++ blockCounts = d.features[tTileByteCounts]+ blockOffsets = d.features[tTileOffsets]++ } else {+ if int(d.firstVal(tRowsPerStrip)) != 0 {+ blockHeight = int(d.firstVal(tRowsPerStrip))+ }++ if blockHeight != 0 {+ blocksDown = (d.config.Height + blockHeight - 1) / blockHeight+ }++ blockOffsets = d.features[tStripOffsets]+ blockCounts = d.features[tStripByteCounts]+ }++ // Check if we have the right number of strips/tiles, offsets and counts.+ if n := blocksAcross * blocksDown; len(blockOffsets) < n || len(blockCounts) < n {+ return nil, FormatError("inconsistent header")+ }++ imgRect := image.Rect(0, 0, d.config.Width, d.config.Height)+ switch d.mode {+ case mGray, mGrayInvert:+ if d.bpp == 16 {+ img = image.NewGray16(imgRect)+ } else {+ img = image.NewGray(imgRect)+ }+ case mPaletted:+ img = image.NewPaletted(imgRect, d.palette)+ case mNRGBA:+ if d.bpp == 16 {+ img = image.NewNRGBA64(imgRect)+ } else {+ img = image.NewNRGBA(imgRect)+ }+ case mRGB, mRGBA:+ if d.bpp == 16 {+ img = image.NewRGBA64(imgRect)+ } else {+ img = image.NewRGBA(imgRect)+ }+ }++ for i := 0; i < blocksAcross; i++ {+ blkW := blockWidth+ if !blockPadding && i == blocksAcross-1 && d.config.Width%blockWidth != 0 {+ blkW = d.config.Width % blockWidth+ }+ for j := 0; j < blocksDown; j++ {+ blkH := blockHeight+ if !blockPadding && j == blocksDown-1 && d.config.Height%blockHeight != 0 {+ blkH = d.config.Height % blockHeight+ }+ offset := int64(blockOffsets[j*blocksAcross+i])+ n := int64(blockCounts[j*blocksAcross+i])+ switch d.firstVal(tCompression) {++ // According to the spec, Compression does not have a default value,+ // but some tools interpret a missing Compression value as none so we do+ // the same.+ case cNone, 0:+ if b, ok := d.r.(*buffer); ok {+ d.buf, err = b.Slice(int(offset), int(n))+ } else {+ d.buf = make([]byte, n)+ _, err = d.r.ReadAt(d.buf, offset)+ }+ case cLZW:+ r := lzw.NewReader(io.NewSectionReader(d.r, offset, n), lzw.MSB, 8)+ d.buf, err = ioutil.ReadAll(r)+ r.Close()+ case cDeflate, cDeflateOld:+ var r io.ReadCloser+ r, err = zlib.NewReader(io.NewSectionReader(d.r, offset, n))+ if err != nil {+ return nil, err+ }+ d.buf, err = ioutil.ReadAll(r)+ r.Close()+ case cPackBits:+ d.buf, err = unpackBits(io.NewSectionReader(d.r, offset, n))+ default:+ err = UnsupportedError(fmt.Sprintf("compression value %d", d.firstVal(tCompression)))+ }+ if err != nil {+ return nil, err+ }++ xmin := i * blockWidth+ ymin := j * blockHeight+ xmax := xmin + blkW+ ymax := ymin + blkH+ err = d.decode(img, xmin, ymin, xmax, ymax)+ if err != nil {+ return nil, err+ }+ }+ }+ return+}++func init() {+ image.RegisterFormat("tiff", leHeader, Decode, DecodeConfig)+ image.RegisterFormat("tiff", beHeader, Decode, DecodeConfig)+}diff --git a/vendor/golang.org/x/image/tiff/writer.go b/vendor/golang.org/x/image/tiff/writer.gonew file mode 100644index 000000000..c8a01cea7--- /dev/null+++ b/vendor/golang.org/x/image/tiff/writer.go@@ -0,0 +1,438 @@+// Copyright 2012 The 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 tiff++import (+ "bytes"+ "compress/zlib"+ "encoding/binary"+ "image"+ "io"+ "sort"+)++// The TIFF format allows to choose the order of the different elements freely.+// The basic structure of a TIFF file written by this package is:+//+// 1. Header (8 bytes).+// 2. Image data.+// 3. Image File Directory (IFD).+// 4. "Pointer area" for larger entries in the IFD.++// We only write little-endian TIFF files.+var enc = binary.LittleEndian++// An ifdEntry is a single entry in an Image File Directory.+// A value of type dtRational is composed of two 32-bit values,+// thus data contains two uints (numerator and denominator) for a single number.+type ifdEntry struct {+ tag int+ datatype int+ data []uint32+}++func (e ifdEntry) putData(p []byte) {+ for _, d := range e.data {+ switch e.datatype {+ case dtByte, dtASCII:+ p[0] = byte(d)+ p = p[1:]+ case dtShort:+ enc.PutUint16(p, uint16(d))+ p = p[2:]+ case dtLong, dtRational:+ enc.PutUint32(p, uint32(d))+ p = p[4:]+ }+ }+}++type byTag []ifdEntry++func (d byTag) Len() int { return len(d) }+func (d byTag) Less(i, j int) bool { return d[i].tag < d[j].tag }+func (d byTag) Swap(i, j int) { d[i], d[j] = d[j], d[i] }++func encodeGray(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error {+ if !predictor {+ return writePix(w, pix, dy, dx, stride)+ }+ buf := make([]byte, dx)+ for y := 0; y < dy; y++ {+ min := y*stride + 0+ max := y*stride + dx+ off := 0+ var v0 uint8+ for i := min; i < max; i++ {+ v1 := pix[i]+ buf[off] = v1 - v0+ v0 = v1+ off+++ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++func encodeGray16(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error {+ buf := make([]byte, dx*2)+ for y := 0; y < dy; y++ {+ min := y*stride + 0+ max := y*stride + dx*2+ off := 0+ var v0 uint16+ for i := min; i < max; i += 2 {+ // An image.Gray16's Pix is in big-endian order.+ v1 := uint16(pix[i])<<8 | uint16(pix[i+1])+ if predictor {+ v0, v1 = v1, v1-v0+ }+ // We only write little-endian TIFF files.+ buf[off+0] = byte(v1)+ buf[off+1] = byte(v1 >> 8)+ off += 2+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++func encodeRGBA(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error {+ if !predictor {+ return writePix(w, pix, dy, dx*4, stride)+ }+ buf := make([]byte, dx*4)+ for y := 0; y < dy; y++ {+ min := y*stride + 0+ max := y*stride + dx*4+ off := 0+ var r0, g0, b0, a0 uint8+ for i := min; i < max; i += 4 {+ r1, g1, b1, a1 := pix[i+0], pix[i+1], pix[i+2], pix[i+3]+ buf[off+0] = r1 - r0+ buf[off+1] = g1 - g0+ buf[off+2] = b1 - b0+ buf[off+3] = a1 - a0+ off += 4+ r0, g0, b0, a0 = r1, g1, b1, a1+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++func encodeRGBA64(w io.Writer, pix []uint8, dx, dy, stride int, predictor bool) error {+ buf := make([]byte, dx*8)+ for y := 0; y < dy; y++ {+ min := y*stride + 0+ max := y*stride + dx*8+ off := 0+ var r0, g0, b0, a0 uint16+ for i := min; i < max; i += 8 {+ // An image.RGBA64's Pix is in big-endian order.+ r1 := uint16(pix[i+0])<<8 | uint16(pix[i+1])+ g1 := uint16(pix[i+2])<<8 | uint16(pix[i+3])+ b1 := uint16(pix[i+4])<<8 | uint16(pix[i+5])+ a1 := uint16(pix[i+6])<<8 | uint16(pix[i+7])+ if predictor {+ r0, r1 = r1, r1-r0+ g0, g1 = g1, g1-g0+ b0, b1 = b1, b1-b0+ a0, a1 = a1, a1-a0+ }+ // We only write little-endian TIFF files.+ buf[off+0] = byte(r1)+ buf[off+1] = byte(r1 >> 8)+ buf[off+2] = byte(g1)+ buf[off+3] = byte(g1 >> 8)+ buf[off+4] = byte(b1)+ buf[off+5] = byte(b1 >> 8)+ buf[off+6] = byte(a1)+ buf[off+7] = byte(a1 >> 8)+ off += 8+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++func encode(w io.Writer, m image.Image, predictor bool) error {+ bounds := m.Bounds()+ buf := make([]byte, 4*bounds.Dx())+ for y := bounds.Min.Y; y < bounds.Max.Y; y++ {+ off := 0+ if predictor {+ var r0, g0, b0, a0 uint8+ for x := bounds.Min.X; x < bounds.Max.X; x++ {+ r, g, b, a := m.At(x, y).RGBA()+ r1 := uint8(r >> 8)+ g1 := uint8(g >> 8)+ b1 := uint8(b >> 8)+ a1 := uint8(a >> 8)+ buf[off+0] = r1 - r0+ buf[off+1] = g1 - g0+ buf[off+2] = b1 - b0+ buf[off+3] = a1 - a0+ off += 4+ r0, g0, b0, a0 = r1, g1, b1, a1+ }+ } else {+ for x := bounds.Min.X; x < bounds.Max.X; x++ {+ r, g, b, a := m.At(x, y).RGBA()+ buf[off+0] = uint8(r >> 8)+ buf[off+1] = uint8(g >> 8)+ buf[off+2] = uint8(b >> 8)+ buf[off+3] = uint8(a >> 8)+ off += 4+ }+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ return nil+}++// writePix writes the internal byte array of an image to w. It is less general+// but much faster then encode. writePix is used when pix directly+// corresponds to one of the TIFF image types.+func writePix(w io.Writer, pix []byte, nrows, length, stride int) error {+ if length == stride {+ _, err := w.Write(pix[:nrows*length])+ return err+ }+ for ; nrows > 0; nrows-- {+ if _, err := w.Write(pix[:length]); err != nil {+ return err+ }+ pix = pix[stride:]+ }+ return nil+}++func writeIFD(w io.Writer, ifdOffset int, d []ifdEntry) error {+ var buf [ifdLen]byte+ // Make space for "pointer area" containing IFD entry data+ // longer than 4 bytes.+ parea := make([]byte, 1024)+ pstart := ifdOffset + ifdLen*len(d) + 6+ var o int // Current offset in parea.++ // The IFD has to be written with the tags in ascending order.+ sort.Sort(byTag(d))++ // Write the number of entries in this IFD.+ if err := binary.Write(w, enc, uint16(len(d))); err != nil {+ return err+ }+ for _, ent := range d {+ enc.PutUint16(buf[0:2], uint16(ent.tag))+ enc.PutUint16(buf[2:4], uint16(ent.datatype))+ count := uint32(len(ent.data))+ if ent.datatype == dtRational {+ count /= 2+ }+ enc.PutUint32(buf[4:8], count)+ datalen := int(count * lengths[ent.datatype])+ if datalen <= 4 {+ ent.putData(buf[8:12])+ } else {+ if (o + datalen) > len(parea) {+ newlen := len(parea) + 1024+ for (o + datalen) > newlen {+ newlen += 1024+ }+ newarea := make([]byte, newlen)+ copy(newarea, parea)+ parea = newarea+ }+ ent.putData(parea[o : o+datalen])+ enc.PutUint32(buf[8:12], uint32(pstart+o))+ o += datalen+ }+ if _, err := w.Write(buf[:]); err != nil {+ return err+ }+ }+ // The IFD ends with the offset of the next IFD in the file,+ // or zero if it is the last one (page 14).+ if err := binary.Write(w, enc, uint32(0)); err != nil {+ return err+ }+ _, err := w.Write(parea[:o])+ return err+}++// Options are the encoding parameters.+type Options struct {+ // Compression is the type of compression used.+ Compression CompressionType+ // Predictor determines whether a differencing predictor is used;+ // if true, instead of each pixel's color, the color difference to the+ // preceding one is saved. This improves the compression for certain+ // types of images and compressors. For example, it works well for+ // photos with Deflate compression.+ Predictor bool+}++// Encode writes the image m to w. opt determines the options used for+// encoding, such as the compression type. If opt is nil, an uncompressed+// image is written.+func Encode(w io.Writer, m image.Image, opt *Options) error {+ d := m.Bounds().Size()++ compression := uint32(cNone)+ predictor := false+ if opt != nil {+ compression = opt.Compression.specValue()+ // The predictor field is only used with LZW. See page 64 of the spec.+ predictor = opt.Predictor && compression == cLZW+ }++ _, err := io.WriteString(w, leHeader)+ if err != nil {+ return err+ }++ // Compressed data is written into a buffer first, so that we+ // know the compressed size.+ var buf bytes.Buffer+ // dst holds the destination for the pixel data of the image --+ // either w or a writer to buf.+ var dst io.Writer+ // imageLen is the length of the pixel data in bytes.+ // The offset of the IFD is imageLen + 8 header bytes.+ var imageLen int++ switch compression {+ case cNone:+ dst = w+ // Write IFD offset before outputting pixel data.+ switch m.(type) {+ case *image.Paletted:+ imageLen = d.X * d.Y * 1+ case *image.Gray:+ imageLen = d.X * d.Y * 1+ case *image.Gray16:+ imageLen = d.X * d.Y * 2+ case *image.RGBA64:+ imageLen = d.X * d.Y * 8+ case *image.NRGBA64:+ imageLen = d.X * d.Y * 8+ default:+ imageLen = d.X * d.Y * 4+ }+ err = binary.Write(w, enc, uint32(imageLen+8))+ if err != nil {+ return err+ }+ case cDeflate:+ dst = zlib.NewWriter(&buf)+ }++ pr := uint32(prNone)+ photometricInterpretation := uint32(pRGB)+ samplesPerPixel := uint32(4)+ bitsPerSample := []uint32{8, 8, 8, 8}+ extraSamples := uint32(0)+ colorMap := []uint32{}++ if predictor {+ pr = prHorizontal+ }+ switch m := m.(type) {+ case *image.Paletted:+ photometricInterpretation = pPaletted+ samplesPerPixel = 1+ bitsPerSample = []uint32{8}+ colorMap = make([]uint32, 256*3)+ for i := 0; i < 256 && i < len(m.Palette); i++ {+ r, g, b, _ := m.Palette[i].RGBA()+ colorMap[i+0*256] = uint32(r)+ colorMap[i+1*256] = uint32(g)+ colorMap[i+2*256] = uint32(b)+ }+ err = encodeGray(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ case *image.Gray:+ photometricInterpretation = pBlackIsZero+ samplesPerPixel = 1+ bitsPerSample = []uint32{8}+ err = encodeGray(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ case *image.Gray16:+ photometricInterpretation = pBlackIsZero+ samplesPerPixel = 1+ bitsPerSample = []uint32{16}+ err = encodeGray16(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ case *image.NRGBA:+ extraSamples = 2 // Unassociated alpha.+ err = encodeRGBA(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ case *image.NRGBA64:+ extraSamples = 2 // Unassociated alpha.+ bitsPerSample = []uint32{16, 16, 16, 16}+ err = encodeRGBA64(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ case *image.RGBA:+ extraSamples = 1 // Associated alpha.+ err = encodeRGBA(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ case *image.RGBA64:+ extraSamples = 1 // Associated alpha.+ bitsPerSample = []uint32{16, 16, 16, 16}+ err = encodeRGBA64(dst, m.Pix, d.X, d.Y, m.Stride, predictor)+ default:+ extraSamples = 1 // Associated alpha.+ err = encode(dst, m, predictor)+ }+ if err != nil {+ return err+ }++ if compression != cNone {+ if err = dst.(io.Closer).Close(); err != nil {+ return err+ }+ imageLen = buf.Len()+ if err = binary.Write(w, enc, uint32(imageLen+8)); err != nil {+ return err+ }+ if _, err = buf.WriteTo(w); err != nil {+ return err+ }+ }++ ifd := []ifdEntry{+ {tImageWidth, dtShort, []uint32{uint32(d.X)}},+ {tImageLength, dtShort, []uint32{uint32(d.Y)}},+ {tBitsPerSample, dtShort, bitsPerSample},+ {tCompression, dtShort, []uint32{compression}},+ {tPhotometricInterpretation, dtShort, []uint32{photometricInterpretation}},+ {tStripOffsets, dtLong, []uint32{8}},+ {tSamplesPerPixel, dtShort, []uint32{samplesPerPixel}},+ {tRowsPerStrip, dtShort, []uint32{uint32(d.Y)}},+ {tStripByteCounts, dtLong, []uint32{uint32(imageLen)}},+ // There is currently no support for storing the image+ // resolution, so give a bogus value of 72x72 dpi.+ {tXResolution, dtRational, []uint32{72, 1}},+ {tYResolution, dtRational, []uint32{72, 1}},+ {tResolutionUnit, dtShort, []uint32{resPerInch}},+ }+ if pr != prNone {+ ifd = append(ifd, ifdEntry{tPredictor, dtShort, []uint32{pr}})+ }+ if len(colorMap) != 0 {+ ifd = append(ifd, ifdEntry{tColorMap, dtShort, colorMap})+ }+ if extraSamples > 0 {+ ifd = append(ifd, ifdEntry{tExtraSamples, dtShort, []uint32{extraSamples}})+ }++ return writeIFD(w, imageLen+8, ifd)+}diff --git a/views/base.html b/views/base.htmlindex 6a875850c..03c52b90a 100644--- a/views/base.html+++ b/views/base.html@@ -4,9 +4,9 @@<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"><meta http-equiv="X-UA-Compatible" content="IE=edge" />- <link rel="icon" href='{{ replace .__favicon ":size" "64" }}' sizes="64x64" type="image/png">- <link rel="icon" href='{{ replace .__favicon ":size" "192" }}' sizes="192x192" type="image/png">- <link rel="apple-touch-icon" href='{{ replace .__favicon ":size" "180" }}?bg=white' sizes="180x180" type="image/png">+ <link rel="icon" href='{{ .__favicon }}?size=64' sizes="64x64" type="image/png">+ <link rel="icon" href='{{ .__favicon }}?size=192' sizes="192x192" type="image/png">+ <link rel="apple-touch-icon" href='{{ .__favicon }}?size=180&bg=white' sizes="180x180" type="image/png">{{ if .__canonicalURL }}<link rel="canonical" href="{{ .__canonicalURL }}" />{{ end }}