//水印
func waterMark(picBytes []byte) []byte {
// 打开水印图并解码
img, fileType, _ := image.Decode(bytes.NewBuffer(picBytes))
//读取水印图片
watermark, _ := png.Decode(bytes.NewBuffer(wm))
//原始图界限
origin_size := img.Bounds()
//创建新图层
canvas := image.NewNRGBA(origin_size)
//贴原始图
draw.Draw(canvas, origin_size, img, image.ZP, draw.Src)
//贴水印图
draw.Draw(canvas, watermark.Bounds().Add(image.Pt(origin_size.Dx()-watermark.Bounds().Dx(), origin_size.Dy()-watermark.Bounds().Dy()-4)), watermark, image.ZP, draw.Over)
//生成新图片
buff := bytes.NewBuffer([]byte{})
switch fileType {
case "jpeg":
jpeg.Encode(buff, canvas, &jpeg.Options{95})
default:
png.Encode(buff, canvas)
}
return buff.Bytes()
}
// decoder reads an image from r and modifies the image as defined by opts.
// swapDimensions indicates the decoded image will be rotated after being
// returned, and when interpreting opts, the post-rotation dimensions should
// be considered.
// The decoded image is returned in im. The registered name of the decoder
// used is returned in format. If the image was not successfully decoded, err
// will be non-nil. If the decoded image was made smaller, needRescale will
// be true.
func decode(r io.Reader, opts *DecodeOpts, swapDimensions bool) (im image.Image, format string, err error, needRescale bool) {
if opts == nil {
// Fall-back to normal decode.
im, format, err = image.Decode(r)
return im, format, err, false
}
var buf bytes.Buffer
tr := io.TeeReader(r, &buf)
ic, format, err := image.DecodeConfig(tr)
if err != nil {
return nil, "", err, false
}
mr := io.MultiReader(&buf, r)
b := image.Rect(0, 0, ic.Width, ic.Height)
sw, sh, needRescale := opts.rescaleDimensions(b, swapDimensions)
if !needRescale {
im, format, err = image.Decode(mr)
return im, format, err, false
}
imageDebug(fmt.Sprintf("Resizing from %dx%d -> %dx%d", ic.Width, ic.Height, sw, sh))
if format == "cr2" {
// Replace mr with an io.Reader to the JPEG thumbnail embedded in a
// CR2 image.
if mr, err = cr2.NewReader(mr); err != nil {
return nil, "", err, false
}
format = "jpeg"
}
if format == "jpeg" && fastjpeg.Available() {
factor := fastjpeg.Factor(ic.Width, ic.Height, sw, sh)
if factor > 1 {
var buf bytes.Buffer
tr := io.TeeReader(mr, &buf)
im, err = fastjpeg.DecodeDownsample(tr, factor)
switch err.(type) {
case fastjpeg.DjpegFailedError:
log.Printf("Retrying with jpeg.Decode, because djpeg failed with: %v", err)
im, err = jpeg.Decode(io.MultiReader(&buf, mr))
case nil:
// fallthrough to rescale() below.
default:
return nil, format, err, false
}
return rescale(im, sw, sh), format, err, true
}
}
// Fall-back to normal decode.
im, format, err = image.Decode(mr)
if err != nil {
return nil, "", err, false
}
return rescale(im, sw, sh), format, err, needRescale
}
func CheckImage(t TesterLight, img []byte, sample []byte) {
i1, _, err := image.Decode(bytes.NewReader(img))
if err != nil {
t.Fatal(err)
}
i2, _, err := image.Decode(bytes.NewReader(sample))
if err != nil {
t.Fatal(err)
}
if !i1.Bounds().Eq(i2.Bounds()) {
t.Fatalf("Different image bounds: %v and %v", i1.Bounds(), i2.Bounds())
}
bounds := i1.Bounds()
for x := bounds.Min.X; x < bounds.Max.Y; x++ {
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
c1 := i1.At(x, y)
c2 := i2.At(x, y)
if !CmpColors(c1, c2, 30) {
t.Fatalf("Different colors at (%v, %v): %v vs %v", x, y, c1, c2)
}
}
}
}
func TestPHA(t *testing.T) {
// Load picture from file.
infile, err := os.Open("./testdata/pic_output.png")
if err != nil {
t.Errorf("Load picture: %s.", err)
}
// Decode picture.
srcImg, _, err := image.Decode(infile)
infile.Close()
if err != nil {
t.Errorf("Decode picture: %s.", err)
}
fg := PHA(srcImg)
fmt.Println("Fingerprint:", fg)
// Load picture2 from file.
infile, err = os.Open("./testdata/pic_output2.jpg")
if err != nil {
t.Errorf("Load picture2: %s.", err)
}
// Decode picture.
srcImg, _, err = image.Decode(infile)
infile.Close()
if err != nil {
t.Errorf("Decode picture2: %s.", err)
}
fg2 := PHA(srcImg)
fmt.Println("Fingerprint:", fg2)
fmt.Println("Diff num:", CompareDiff(fg, fg2))
}
func pixels(source, target string) bool {
sourcefile, err := os.Open(source)
checkerror(err)
defer sourcefile.Close()
targetfile, err := os.Open(target)
checkerror(err)
defer targetfile.Close()
sourceimage, _, err := image.Decode(sourcefile)
targetimage, _, err := image.Decode(targetfile)
sourcebounds := sourceimage.Bounds()
targetbounds := targetimage.Bounds()
if (sourcebounds.Min.Y != targetbounds.Min.Y) || (sourcebounds.Min.X != targetbounds.Min.X) || (sourcebounds.Max.Y != targetbounds.Max.Y) || (sourcebounds.Max.X != targetbounds.Max.X) {
return false
// log.Fatalln("Images are not the same size pixel-wise!")
}
for y := sourcebounds.Min.Y; y < sourcebounds.Max.Y; y++ {
for x := sourcebounds.Min.X; x < sourcebounds.Max.X; x++ {
sr, sg, sb, sa := sourceimage.At(x, y).RGBA()
tr, tg, tb, ta := targetimage.At(x, y).RGBA()
if (sr != tr) || (sg != tg) || (sb != tb) || (sa != ta) {
return false
// log.Fatalln("Ah! They are not the same!", x, y)
}
}
}
return true
}
func TestReplaceImage(t *testing.T) {
proxy := goproxy.NewProxyHttpServer()
panda := getImage("test_data/panda.png", t)
football := getImage("test_data/football.png", t)
proxy.HandleResponse(goproxy.UrlIsIn("/test_data/panda.png")(goproxy_image.HandleImage(func(img image.Image, ctx *goproxy.ProxyCtx) image.Image {
return football
})))
proxy.HandleResponse(goproxy.UrlIsIn("/test_data/football.png")(goproxy_image.HandleImage(func(img image.Image, ctx *goproxy.ProxyCtx) image.Image {
return panda
})))
client, l := oneShotProxy(proxy, t)
defer l.Close()
imgByPandaReq, _, err := image.Decode(bytes.NewReader(getOrFail(localFile("test_data/panda.png"), client, t)))
fatalOnErr(err, "decode panda", t)
compareImage(football, imgByPandaReq, t)
imgByFootballReq, _, err := image.Decode(bytes.NewReader(getOrFail(localFile("test_data/football.png"), client, t)))
fatalOnErr(err, "decode football", t)
compareImage(panda, imgByFootballReq, t)
}
func DrawLogo(qrPng []byte, logo string, logoBgColor color.Color) []byte {
if logo != "" {
// println(logo)
resp, err := http.Get(logo)
if err != nil {
fmt.Printf("Logo Error=%s\n", err.Error())
// println(resp)
} else {
logoImg, _, _ := image.Decode(resp.Body)
qrImg, _, _ := image.Decode(bytes.NewReader(qrPng))
pb := qrImg.Bounds()
logoImg = resize.Resize(uint(pb.Dx()/4), uint(pb.Dy()/4), logoImg, resize.Lanczos3)
logoBgImg := image.NewRGBA(image.Rect(0, 0, logoImg.Bounds().Dx()+2, logoImg.Bounds().Dy()+2))
draw.Draw(logoBgImg, logoBgImg.Bounds(), &image.Uniform{color.White}, image.Point{}, draw.Src)
draw.Draw(logoBgImg, logoImg.Bounds(), logoImg, image.Point{-1, -1}, draw.Over)
offsetX := (pb.Dx() - logoBgImg.Bounds().Dx()) / 2
newImg := image.NewRGBA(pb)
draw.Draw(newImg, pb, qrImg, image.Point{}, draw.Src)
draw.Draw(newImg, newImg.Bounds(), logoBgImg, image.Point{-offsetX, -offsetX}, draw.Over)
// println(logoImg)
buf := new(bytes.Buffer)
err = png.Encode(buf, newImg)
// send_s3 := buf.Bytes()
return buf.Bytes()
}
}
return qrPng
}
func TestImageHandler(t *testing.T) {
client, proxy, l := oneShotProxy(t)
defer l.Close()
football := getImage("test_data/football.png", t)
proxy.OnResponse(goproxy.UrlIs("/test_data/panda.png")).Do(goproxy_image.HandleImage(func(img image.Image, ctx *goproxy.ProxyCtx) image.Image {
return football
}))
resp, err := client.Get(localFile("test_data/panda.png"))
if err != nil {
t.Fatal("Cannot get panda.png", err)
}
img, _, err := image.Decode(resp.Body)
if err != nil {
t.Error("decode", err)
} else {
compareImage(football, img, t)
}
// and again
resp, err = client.Get(localFile("test_data/panda.png"))
if err != nil {
t.Fatal("Cannot get panda.png", err)
}
img, _, err = image.Decode(resp.Body)
if err != nil {
t.Error("decode", err)
} else {
compareImage(football, img, t)
}
}
func TestEncode(t *testing.T) {
img := prepareImg(t)
buf := &bytes.Buffer{}
if err := png.Encode(buf, img); err != nil {
t.Fatal(err)
}
imgGo, _, err := image.Decode(buf)
if err != nil {
t.Fatal(err)
}
assertEqual(t, img.Bounds(), imgGo.Bounds())
b, err := Encode(img, "png")
if err != nil {
t.Fatal(err)
}
imgMapnik, _, err := image.Decode(bytes.NewReader(b))
if err != nil {
t.Fatal(err)
}
assertImageEqual(t, img, imgMapnik)
assertImageEqual(t, imgGo, imgMapnik)
}
func LoadImage(data interface{}) Image {
var m image.Image
switch data := data.(type) {
default:
log.Fatal("NewTexture needs a string or io.Reader")
case string:
file, err := os.Open(data)
if err != nil {
log.Fatal(err)
}
defer file.Close()
img, _, err := image.Decode(file)
if err != nil {
log.Fatal(err)
}
m = img
case io.Reader:
img, _, err := image.Decode(data)
if err != nil {
log.Fatal(err)
}
m = img
case image.Image:
m = data
}
b := m.Bounds()
newm := image.NewNRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
draw.Draw(newm, newm.Bounds(), m, b.Min, draw.Src)
return &ImageObject{newm}
}
func CheckImg(src, tgt io.Reader) (int, error) {
image1, format1, err1 := image.Decode(src)
image2, format2, err2 := image.Decode(tgt)
if err1 != nil || err2 != nil {
return 1, errors.New(fmt.Sprintf("From Servier error : %v , From Local error : %v \n", err1, err2))
}
if format2 != format1 {
return 2, errors.New("Unmatched format!")
}
if image1.Bounds() != image2.Bounds() {
return 3, errors.New("Unmatched bounds")
}
total, miss := 0, 0
for i := image1.Bounds().Min.X; i <= image1.Bounds().Max.X; i++ {
for j := image1.Bounds().Min.Y; j <= image1.Bounds().Max.Y; j++ {
total++
r1, g1, b1, a1 := image1.At(i, j).RGBA()
r2, g2, b2, a2 := image2.At(i, j).RGBA()
if !approachTo(r1, r2) || !approachTo(g1, g2) || !approachTo(b1, b2) || !approachTo(a1, a2) {
return 4, errors.New("Differs two much!")
}
if r1 != r2 || g1 != g2 || b1 != b2 || a1 != a2 {
miss++
}
}
}
if miss > total/20 {
return 4, errors.New("Missed too much!")
}
return 0, nil
}
func (s *ResizeSuite) TestOriginalColdCache(c *C) {
// Open the file once to get it's size
file, err := ioutil.ReadFile("test/exif_test_img.jpg")
c.Assert(err, IsNil)
img, _, err := image.Decode(bytes.NewReader(file))
c.Assert(err, IsNil)
// Since this image should be rotated, height should equal
// width after it's uploaded.
originalSize := img.Bounds().Size().Y
// A single, unresized image is in the database/store
ctx, err := s.insertMockImage()
c.Assert(err, IsNil)
// Run the image resize request
data, err := fetch.ImageData(storage, ctx)
c.Assert(err, IsNil)
// Verify the size of the resulting byte slice
img, _, err = image.Decode(bytes.NewReader(data))
c.Assert(err, IsNil)
c.Assert(img.Bounds().Size().X, Equals, originalSize)
}
func main() {
srcPath := os.Args[1]
flatPath := os.Args[2]
dstPath := os.Args[3]
reader, err := os.Open(srcPath)
check(err)
src, srcFmt, err := image.Decode(reader)
check(err)
fmt.Println("Decoded source", srcPath, "as", srcFmt)
reader, err = os.Open(flatPath)
check(err)
flat, name, err := image.Decode(reader)
check(err)
fmt.Println("Decoded flat", flatPath, "as", name)
if src.Bounds() != flat.Bounds() {
log.Fatal("Bounds not equal")
}
proxy := ProxyImage{src, flat}
writer, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE, 0600)
check(err)
if strings.HasSuffix(dstPath, ".jpg") || strings.HasSuffix(dstPath, ".jpeg") {
jpeg.Encode(writer, proxy, &jpeg.Options{90})
} else if strings.HasSuffix(dstPath, ".png") {
png.Encode(writer, proxy)
} else {
log.Fatal(dstPath + "does not have .jpg or .png extension")
}
}
func TestDecodeRawRGB(t *testing.T) {
pnmFile := openFile(t, "testdata/test_rgb_raw.ppm")
pngFile := openFile(t, "testdata/test_rgb.png")
defer pngFile.Close()
defer pnmFile.Close()
pnmImage, format, err := image.Decode(pnmFile)
pngImage, _, err := image.Decode(pngFile)
pnm := pnmImage.(*image.RGBA)
png := pngImage.(*image.RGBA)
if err != nil {
t.Fatal(err)
}
if format != "ppm raw (rgb)" {
t.Fatal("Unexpected format:", format, "expecting ppm raw (rgb)")
}
if len(png.Pix) != len(pnm.Pix) {
t.Fatal("Wrong pixel count:", len(pnm.Pix), "expected: ", len(png.Pix))
}
for i := 0; i < len(png.Pix); i++ {
//t.Log("(", png.Pix[i], ",", pnm.Pix[i], ")")
if png.Pix[i] != pnm.Pix[i] {
t.Fatal("Incorrect pixel at position", i, "found", pnm.Pix[i], "but expected", png.Pix[i])
}
}
}
func main() {
file, err := os.Open("android.png")
if err != nil {
log.Fatal(err)
}
defer file.Close()
a, _, err := image.Decode(file)
//load go icon image
file2, err := os.Open("go.png")
if err != nil {
log.Fatal(err)
}
defer file2.Close()
g, _, err := image.Decode(file2)
if err != nil {
log.Fatal(err)
}
ar := a.Bounds()
w, h, x := ar.Dx(), ar.Dy(), 30.0
i := image.NewRGBA(image.Rect(0, 0, w, h))
draw.Draw(i, ar, a, ar.Min, draw.Src)
tr := draw2d.NewRotationMatrix(x * (math.Pi / 180.0))
draw2d.DrawImage(g, i, tr, draw.Over, draw2d.LinearFilter)
saveToPngFile("Test2.png", i)
}
func main() {
heightInt, widthInt, _ := pty.Getsize(os.Stdout)
var width uint
var height uint
// The three subtracted lines is to have room for command, file name and prompt after explosion
flag.UintVar(&width, "w", uint(widthInt), "Maximum width of output in number of columns")
flag.UintVar(&height, "h", uint((heightInt-3)*2), "Maximum height of output in number of half lines")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s [options] [file | - ...]\n\n", os.Args[0])
fmt.Fprintln(os.Stderr, " Specify \"-\" or just noting to read from stdin.")
fmt.Fprintln(os.Stderr)
fmt.Fprintln(os.Stderr, "Options:")
flag.PrintDefaults()
}
flag.Parse()
filenames := flag.Args()
if len(filenames) == 0 {
fmt.Println("stdin:")
sourceImage, _, err := image.Decode(os.Stdin)
if err != nil {
fmt.Fprintln(os.Stderr, "Error:", err)
} else {
printImage(sourceImage, width, height)
}
} else {
for i, filename := range filenames {
if i > 0 {
fmt.Println()
}
var file *os.File
var err error
if filename == "-" {
fmt.Println("stdin:")
file = os.Stdin
} else {
fmt.Printf("%s:\n", filename)
file, err = os.Open(filename)
if err != nil {
fmt.Fprintln(os.Stderr, "Error:", err)
continue
}
}
sourceImage, _, err := image.Decode(file)
_ = file.Close()
if err != nil {
fmt.Fprintln(os.Stderr, "Error:", err)
continue
}
printImage(sourceImage, width, height)
}
}
}
func loadTextures() []sprite.SubTex {
a, err := asset.Open("cards.jpeg")
if err != nil {
log.Fatal(err)
}
defer a.Close()
img, _, err := image.Decode(a)
if err != nil {
log.Fatal(err)
}
t, err := eng.LoadTexture(img)
if err != nil {
log.Fatal(err)
}
a2, err := asset.Open("dropTarget.jpeg")
if err != nil {
log.Fatal(err)
}
defer a2.Close()
img2, _, err := image.Decode(a2)
if err != nil {
log.Fatal(err)
}
t2, err := eng.LoadTexture(img2)
if err != nil {
log.Fatal(err)
}
a3, err := asset.Open("deck.jpeg")
if err != nil {
log.Fatal(err)
}
defer a3.Close()
img3, _, err := image.Decode(a3)
if err != nil {
log.Fatal(err)
}
t3, err := eng.LoadTexture(img3)
if err != nil {
log.Fatal(err)
}
return []sprite.SubTex{
card1: sprite.SubTex{t, image.Rect(15, 15, 190, 260)},
card2: sprite.SubTex{t, image.Rect(195, 60, 370, 305)},
card3: sprite.SubTex{t, image.Rect(375, 107, 550, 350)},
card4: sprite.SubTex{t, image.Rect(555, 135, 730, 377)},
dropTarget: sprite.SubTex{t2, image.Rect(0, 0, 766, 620)},
draw: sprite.SubTex{t3, image.Rect(0, 0, 1506/2, 1052)},
discard: sprite.SubTex{t3, image.Rect(1506/2, 0, 1506, 1052)},
}
}
// BuildImage builds a new image with 4 square images and overlays
// numbers on top (translucent). It sends to S3 and returns the public
// URL.
func (c *Challenge) BuildImage(profileURLs []string) ([]byte, error) {
var profileImgs []image.Image
for _, url := range profileURLs {
resp, err := http.Get(url)
if err != nil {
return nil, fmt.Errorf("Couldn't get avatar: %s", err)
}
defer resp.Body.Close()
cnt, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("couldn't read avatar body: %s", err)
}
img, _, err := image.Decode(bytes.NewBuffer(cnt))
if err != nil {
return nil, fmt.Errorf("decoding image: %s", err)
}
profileImgs = append(profileImgs, img)
}
numbersImage, _, _ := image.Decode(bytes.NewBuffer(numbersPNG))
// for 4 images
finalImage := image.NewRGBA(image.Rect(0, 0, 192+192, 192+192))
mask := &image.Uniform{color.RGBA{0, 0, 100, 100}}
// First
draw.Draw(finalImage, image.Rect(0, 0, 192, 192), profileImgs[0], image.Point{0, 0}, draw.Over)
draw.DrawMask(finalImage, image.Rect(0, 0, 64, 64), numbersImage, numbersPositions[1].Min, mask, image.Point{0, 0}, draw.Over)
// Second
draw.Draw(finalImage, image.Rect(192, 0, 192*2, 192), profileImgs[1], image.Point{0, 0}, draw.Over)
draw.DrawMask(finalImage, image.Rect(192, 0, 192+64, 64), numbersImage, numbersPositions[2].Min, mask, image.Point{0, 0}, draw.Over)
// Third
draw.Draw(finalImage, image.Rect(0, 192, 192, 192*2), profileImgs[2], image.Point{0, 0}, draw.Over)
draw.DrawMask(finalImage, image.Rect(0, 192, 64, 192+64), numbersImage, numbersPositions[3].Min, mask, image.Point{0, 0}, draw.Over)
// Fourth
draw.Draw(finalImage, image.Rect(192, 192, 192*2, 192*2), profileImgs[3], image.Point{0, 0}, draw.Over)
draw.DrawMask(finalImage, image.Rect(192, 192, 192+64, 192+64), numbersImage, numbersPositions[4].Min, mask, image.Point{0, 0}, draw.Over)
buf := &bytes.Buffer{}
png.Encode(buf, finalImage)
return buf.Bytes(), nil
//return "https://avatars.slack-edge.com/2014-12-08/3167931031_42ef453717f47b15aa3b_192.jpg", nil
}
func TestBasic(t *testing.T) {
req := Client.NewRequest(t, "GET", "/350x150", nil)
req.EnableRecording("placehold.apib")
res := Client.Do(t, req, 200)
img, format, err := image.Decode(bytes.NewReader(res.Body))
assert.NoError(t, err)
assert.Equal(t, "png", format)
assert.Equal(t, "(350,150)", img.Bounds().Max.String())
res = Client.Get(t, "/350x150.jpeg", 200)
img, format, err = image.Decode(bytes.NewReader(res.Body))
assert.NoError(t, err)
assert.Equal(t, "jpeg", format)
assert.Equal(t, "(350,150)", img.Bounds().Max.String())
}
func TestResizeEmoji(t *testing.T) {
// try to resize a jpeg image within MaxEmojiWidth and MaxEmojiHeight
small_img_data := createTestJpeg(t, MaxEmojiWidth, MaxEmojiHeight)
if small_img, _, err := image.Decode(bytes.NewReader(small_img_data)); err != nil {
t.Fatal("failed to decode jpeg bytes to image.Image")
} else {
resized_img := resizeEmoji(small_img, small_img.Bounds().Dx(), small_img.Bounds().Dy())
if resized_img.Bounds().Dx() > MaxEmojiWidth || resized_img.Bounds().Dy() > MaxEmojiHeight {
t.Fatal("resized jpeg width and height should not be greater than MaxEmojiWidth or MaxEmojiHeight")
}
if resized_img != small_img {
t.Fatal("should've returned small_img itself")
}
}
// try to resize a jpeg image
jpeg_data := createTestJpeg(t, 256, 256)
if jpeg_img, _, err := image.Decode(bytes.NewReader(jpeg_data)); err != nil {
t.Fatal("failed to decode jpeg bytes to image.Image")
} else {
resized_jpeg := resizeEmoji(jpeg_img, jpeg_img.Bounds().Dx(), jpeg_img.Bounds().Dy())
if resized_jpeg.Bounds().Dx() > MaxEmojiWidth || resized_jpeg.Bounds().Dy() > MaxEmojiHeight {
t.Fatal("resized jpeg width and height should not be greater than MaxEmojiWidth or MaxEmojiHeight")
}
}
// try to resize a png image
png_data := createTestJpeg(t, 256, 256)
if png_img, _, err := image.Decode(bytes.NewReader(png_data)); err != nil {
t.Fatal("failed to decode png bytes to image.Image")
} else {
resized_png := resizeEmoji(png_img, png_img.Bounds().Dx(), png_img.Bounds().Dy())
if resized_png.Bounds().Dx() > MaxEmojiWidth || resized_png.Bounds().Dy() > MaxEmojiHeight {
t.Fatal("resized png width and height should not be greater than MaxEmojiWidth or MaxEmojiHeight")
}
}
// try to resize an animated gif
gif_data := createTestAnimatedGif(t, 256, 256, 10)
if gif_img, err := gif.DecodeAll(bytes.NewReader(gif_data)); err != nil {
t.Fatal("failed to decode gif bytes to gif.GIF")
} else {
resized_gif := resizeEmojiGif(gif_img)
if resized_gif.Config.Width > MaxEmojiWidth || resized_gif.Config.Height > MaxEmojiHeight {
t.Fatal("resized gif width and height should not be greater than MaxEmojiWidth or MaxEmojiHeight")
}
if len(resized_gif.Image) != len(gif_img.Image) {
t.Fatal("resized gif should have the same number of frames as original gif")
}
}
}
func loadSize(ctxt *fs.Context, name string, max int) *image.RGBA {
data, _, err := ctxt.Read("qr/upload/" + name + ".png")
if err != nil {
panic(err)
}
i, _, err := image.Decode(bytes.NewBuffer(data))
if err != nil {
panic(err)
}
b := i.Bounds()
dx, dy := max, max
if b.Dx() > b.Dy() {
dy = b.Dy() * dx / b.Dx()
} else {
dx = b.Dx() * dy / b.Dy()
}
var irgba *image.RGBA
switch i := i.(type) {
case *image.RGBA:
irgba = resize.ResizeRGBA(i, i.Bounds(), dx, dy)
case *image.NRGBA:
irgba = resize.ResizeNRGBA(i, i.Bounds(), dx, dy)
}
return irgba
}
// UploadAvatar saves custom avatar for user.
// FIXME: split uploads to different subdirs in case we have massive users.
func (u *User) UploadAvatar(data []byte) error {
img, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return fmt.Errorf("Decode: %v", err)
}
m := resize.Resize(290, 290, img, resize.NearestNeighbor)
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
return err
}
u.UseCustomAvatar = true
if err = updateUser(sess, u); err != nil {
return fmt.Errorf("updateUser: %v", err)
}
os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
fw, err := os.Create(u.CustomAvatarPath())
if err != nil {
return fmt.Errorf("Create: %v", err)
}
defer fw.Close()
if err = png.Encode(fw, m); err != nil {
return fmt.Errorf("Encode: %v", err)
}
return sess.Commit()
}
func NewSpriteFromImage(fileName string) *Sprite {
reader, err := os.Open(fileName)
if err != nil {
log.Fatal(err)
}
defer reader.Close()
m, _, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
}
bounds := m.Bounds()
if bounds.Max.Y-bounds.Min.Y != 8 {
log.Fatal("Invalid image size")
}
s := NewSprite(bounds.Max.X-bounds.Min.X, bounds.Max.Y-bounds.Min.Y)
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
for x := bounds.Min.X; x < bounds.Max.X; x++ {
r, g, b, _ := m.At(x, y).RGBA()
s.SetPixel(x-bounds.Min.X, y-bounds.Min.Y, ledmatrix.RGB(int(r>>8), int(g>>8), int(b>>8)))
}
}
return s
}
func loadSprite(fileName string) Sprite {
a, err := asset.Open(fileName)
if err != nil {
log.Fatal(err)
}
defer a.Close()
img, _, err := image.Decode(a)
if err != nil {
log.Fatal(err)
}
t, err := eng.LoadTexture(img)
if err != nil {
log.Fatal(err)
}
bounds := img.Bounds()
imgWidth := bounds.Max.X - bounds.Min.X
imgHeight := bounds.Max.Y - bounds.Min.Y
log.Printf("sprite %v size: %vx%v\n", fileName, imgWidth, imgHeight)
subTex := sprite.SubTex{t, image.Rect(0, 0, imgWidth, imgHeight)}
return Sprite{
SubTex: subTex,
Width: imgWidth,
Height: imgHeight,
}
}
// UploadAvatar saves custom avatar for user.
// FIXME: split uploads to different subdirs in case we have massive users.
func (u *User) UploadAvatar(data []byte) error {
u.UseCustomAvatar = true
img, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return err
}
m := resize.Resize(234, 234, img, resize.NearestNeighbor)
sess := x.NewSession()
defer sess.Close()
if err = sess.Begin(); err != nil {
return err
}
if _, err = sess.Id(u.Id).AllCols().Update(u); err != nil {
sess.Rollback()
return err
}
os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
fw, err := os.Create(u.CustomAvatarPath())
if err != nil {
sess.Rollback()
return err
}
defer fw.Close()
if err = jpeg.Encode(fw, m, nil); err != nil {
sess.Rollback()
return err
}
return sess.Commit()
}
// imgHandler is the HTTP handler for displaying images and painting
// moustaches; it handles "/img".
func imgHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
key := datastore.NewKey(c, "Image", r.FormValue("id"), 0, nil)
im := new(Image)
if err := datastore.Get(c, key, im); err != nil {
writeError(w, r, err)
return
}
m, _, err := image.Decode(bytes.NewBuffer(im.Data))
if err != nil {
writeError(w, r, err)
return
}
get := func(n string) int { // helper closure
i, _ := strconv.Atoi(r.FormValue(n))
return i
}
x, y, s, d := get("x"), get("y"), get("s"), get("d")
if x > 0 { // only draw if coordinates provided
m = moustache(m, x, y, s, d)
}
b := &bytes.Buffer{}
if err := jpeg.Encode(w, m, nil); err != nil {
writeError(w, r, err)
return
}
w.Header().Set("Content-type", "image/jpeg")
b.WriteTo(w)
}
func readImageFromFile(t *testing.T, srcFilename string) image.Image {
var err error
var srcImg image.Image
file, err := os.Open(srcFilename)
if err != nil {
t.Logf("%s\n", err.Error())
t.FailNow()
return nil
}
defer file.Close()
srcImg, _, err = image.Decode(file)
if err != nil {
t.Logf("%s: %s\n", srcFilename, err.Error())
t.FailNow()
return nil
}
if srcImg == nil {
t.Logf("%s: Decode failed\n", srcFilename)
t.FailNow()
return nil
}
return srcImg
}
func TestRenderFile(t *testing.T) {
m := New()
if err := m.Load("test/map.xml"); err != nil {
t.Fatal(err)
}
m.ZoomAll()
out, err := ioutil.TempDir("", "")
if err != nil {
t.Fatal("unable to create temp dir")
}
defer os.RemoveAll(out)
fname := filepath.Join(out, "out.png")
if err := m.RenderToFile(RenderOpts{}, fname); err != nil {
t.Fatal(err)
}
f, err := os.Open(fname)
if err != nil {
t.Fatal("unable to open test output", err)
}
defer f.Close()
img, _, err := image.Decode(f)
if err != nil {
t.Fatal("unable to open test output", err)
}
if img.Bounds().Dx() != 800 || img.Bounds().Dy() != 600 {
t.Error("unexpected size of output image: ", img.Bounds())
}
}
func ReadImages(path string) (<-chan image.Image, error) {
dir, err := os.Open(path)
if err != nil {
return nil, err
}
defer dir.Close()
names, err := dir.Readdirnames(0)
if err != nil {
return nil, err
}
resChan := make(chan image.Image)
go func() {
for _, name := range names {
imagePath := filepath.Join(path, name)
f, err := os.Open(imagePath)
if err != nil {
continue
}
image, _, _ := image.Decode(f)
f.Close()
if image != nil {
resChan <- image
}
}
close(resChan)
}()
return resChan, nil
}
// Image places the image in s image at (x,y) with dimensions (w,h)
func Image(x, y float64, w, h int, s string) {
f, ferr := os.Open(s)
if ferr != nil {
fakeimage(x, y, w, h, s)
return
}
defer f.Close()
img, _, err := image.Decode(f)
if err != nil {
fakeimage(x, y, w, h, s)
return
}
bounds := img.Bounds()
minx := bounds.Min.X
maxx := bounds.Max.X
miny := bounds.Min.Y
maxy := bounds.Max.Y
data := make([]C.VGubyte, w*h*4)
n := 0
// println("minx", minx, "maxx", maxx, "miny", miny, "maxy", maxy)
for y := miny; y < maxy; y++ {
for x := minx; x < maxx; x++ {
r, g, b, a := img.At(x, (maxy-1)-y).RGBA() // OpenVG has origin at lower left, y increasing up
data[n] = C.VGubyte(r)
n++
data[n] = C.VGubyte(g)
n++
data[n] = C.VGubyte(b)
n++
data[n] = C.VGubyte(a)
n++
}
}
C.makeimage(C.VGfloat(x), C.VGfloat(y), C.int(w), C.int(h), &data[0])
}