I'm having trouble converting a base 64 string to gif
i have tried the following.
unbased, err := base64.StdEncoding.DecodeString(bs64)
if err != nil {
panic("Cannot decode b64")
}
var imgCoupon image.Image
imgCoupon, err = gif.Decode(bytes.NewReader(unbased))
var opt gif.Options
opt.NumColors = 256
var buff bytes.Buffer
gif.Encode(&buff, imgCoupon, &opt)
but when i uploaded it in the GCP/google cloud storage the GIF doesn't animate.
this is how i upload.
sw := storageClient.Bucket(bucket).Object("test"+"_file"+".gif").NewWriter(ctx)
if _, err := io.Copy(sw, &buff); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"message": err.Error(),
"error": true,
})
return
}
the result:
how it should be:
The issue is with how it's being decoded. gif.Decode returns an image.Image, but gif.DecodeAll returns a gif.GIF type.
Similarly, gif.EncodeAll is used to write multiple frames.
This is the code that works for me:
unbased, err := base64.StdEncoding.DecodeString(bs64)
if err != nil {
panic("Cannot decode b64")
}
// Use DecodeAll to load the data into a gif.GIF
imgCoupon, err := gif.DecodeAll(bytes.NewReader(unbased))
imgCoupon.LoopCount = 0
// EncodeAll to the buffer
var buff bytes.Buffer
gif.EncodeAll(&buff, imgCoupon)
Related
I'm writing a go application that uses gqlgen for graphQL API.
when a user uploads a file using the api I get it as a type of graphql.Upload
type Upload struct {
File io.Reader
Filename string
Size int64
ContentType string
}
I want to be able to load the exif data of the image, decode the image and rotate it based on the exif orientation.
I use github.com/rwcarlsen/goexif/exif to fetch the exif information and github.com/disintegration/imaging for rotation, but I cannot open graphql.Upload.File twice. it fails the 2hd time.
func updateImage(dir string, id int, imgFile *graphql.Upload) error {
image := dbimage.GetImagePathNoTemplate(dir, id)
imageThumbnail := dbimage.GetImageThumbnailPathNoTemplate(dir, id)
var myImage image2.Image
var err error
switch imgFile.ContentType {
case "image/png":
if myImage, err = png.Decode(imgFile.File); err != nil {
return err
}
break
case "image/jpeg":
if myImage, err = jpeg.Decode(imgFile.File); err != nil {
return err
}
break
case "image/webp":
if myImage, err = webpbin.Decode(imgFile.File); err != nil {
return err
}
break
default:
return errors.Errorf("unknown image mimetype %v", imgFile.ContentType)
}
FAILS HERE: metaData, err := exif.Decode(imgFile.File)
...
}
of course if I extract the exif first and then decode the image, then the image decode fails.
I don't get a full path to the file and I get only one io.Reader. what can I do to fetch both exif and decode the image ?
thanks
guys thank you for your comments.
I noticed that I cannot cast io.Reader to io.Seeker.
for some reason I thought that io.Reader got some sort of rewind method that I missed but this is not the case.
so what I did is read the data to a byte array and created new Reader object whenever I need it:
byteArray, err := ioutil.ReadAll(imgFile.File)
if err != nil {
return err
}
switch imgFile.ContentType {
case "image/png":
if myImage, err = png.Decode(bytes.NewReader(byteArray)); err != nil {
return err
}
break
case "image/jpeg":
if myImage, err = jpeg.Decode(bytes.NewReader(byteArray)); err != nil {
return err
}
break
case "image/webp":
if myImage, err = webpbin.Decode(bytes.NewReader(byteArray)); err != nil {
return err
}
break
default:
return errors.Errorf("unknown image mimetype %v", imgFile.ContentType)
}
metaData, err := exif.Decode(bytes.NewReader(byteArray))
How to upload an image file in Google Cloud Storage that I already resized using 3rd party package "github.com/disintegration/imaging"?
I tried this
Code:
f, uploadedFile, err := c.Request.FormFile("file") // image file
// Decode the file into a image struct
srcImg, _, err:= image.Decode(f)
// Resize srcImage to width = 800px preserving the aspect ratio.
adjustedFile := imaging.Resize(srcImg, 800, 0, imaging.Lanczos)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"message": err.Error(),
"error": true,
})
return
}
defer f.Close()
sw := storageClient.Bucket(bucket).Object(""+ callType +"/"+ yearString +"/"+ monthString +"/" + uploadedFile.Filename).NewWriter(ctx)
if _, err := io.Copy(sw, adjustedFile); err != nil { // error here
c.JSON(http.StatusInternalServerError, gin.H{
"message": err.Error(),
"error": true,
})
return
}
Error:
`cannot use adjustedFile (type *image.NRGBA) as type io.Reader in a`rgument to io.Copy:
*image.NRGBA does not implement io.Reader (missing Read method)
Posting this as a community wiki, since It's based on #CeriseLimon's comment.
The problem is that you have to encode your image to bytes before sending it to GCS and you can do it by using the image/jpeg package, try the following code
if _, err := jpeg.Encode(sw, adjustedFile, &jpeg.Options{Quality:77}); err != nil {
...
}
I am trying to convert an []byte object to an image and save it as a jpeg in Golang. I tried to use Decode function of image but it always returns <nil>.
func saveFrames(imgByte []byte) {
img, _, _ := image.Decode(bytes.NewReader(imgByte))
out, err := os.Create("./img.jpeg")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
err = jpeg.Encode(out, img)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
}
You are not passing Options,to jpeg.Encode, you can also set it to nil.
func serveFrames(imgByte []byte) {
img, _, err := image.Decode(bytes.NewReader(imgByte))
if err != nil {
log.Fatalln(err)
}
out, _ := os.Create("./img.jpeg")
defer out.Close()
var opts jpeg.Options
opts.Quality = 1
err = jpeg.Encode(out, img, &opts)
//jpeg.Encode(out, img, nil)
if err != nil {
log.Println(err)
}
}
Don't forget to close any file, if opened.
You can use log.Fatalln(...), if you want to print error message and quit in-case of any error.
I am getting the image as base64 string ( dataurl ), Below is my function that converts the dataurl into the image,
Now if the image is png then png library will create the image and jpg library will throw an error and vice versa.
Problem is when i upload png it works well but when i upload jpg file
returns this error
invalid JPEG format: missing SOI marker
func (ProfileController) SetProfilePic(w http.ResponseWriter, r *http.Request) {
session, _ := session.UserSession.Get(r, "mvc-user-session")
var fieldMapForBasic map[string]*json.RawMessage
var f *os.File
data, _ := ioutil.ReadAll(r.Body)
json.Unmarshal(data, &fieldMapForBasic)
image, _ := json.Marshal(fieldMapForBasic["image"])
coI := strings.Index(string(image), ",")
rawImage := string(image)[coI+1:]
// Encoded Image DataUrl //
unbased, _ := base64.StdEncoding.DecodeString(string(rawImage))
res := bytes.NewReader(unbased)
path, _ := os.Getwd()
// Path to store the image //
newpath := filepath.Join(path + "/storage", strconv.Itoa(session.Values["id"].(int)))
os.MkdirAll(newpath, os.ModePerm)
uid := uuid.NewV4()
fmt.Println(newpath)
// if image is png this function will create the image from dataurl string //
pngI, errPng := png.Decode(res)
if errPng == nil {
f, _ = os.OpenFile(newpath + "/" + uid.String() + ".png", os.O_WRONLY | os.O_CREATE, 0777)
png.Encode(f, pngI)
fmt.Println("Png generated")
user := model.User{}
user.ProfilePic = "storage/" + strconv.Itoa(session.Values["id"].(int)) + "/" + uid.String()
session.Values["profile_pic"] = user.ProfilePic
session.Save(r, w)
database.Connection.Id(session.Values["id"].(int)).Update(&user)
} else {
fmt.Println(errPng.Error())
}
// If image is Jpg this will generate the Image //
jpgI, errJpg := jpeg.Decode(res)
if errJpg == nil {
f, _ = os.OpenFile(newpath + "/" + uid.String() + ".jpg", os.O_WRONLY | os.O_CREATE, 0777)
jpeg.Encode(f, jpgI, &jpeg.Options{Quality: 75})
fmt.Println("Jpg created")
} else {
fmt.Println(errJpg.Error())
}
defer func() {
f.Close()
}()
render.Json(w, "ok")
}
Input dataurl is:
"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAIBAQIBAQICAgICAgICAwUDAwMDAwYEBAMFBwYHBwcGBwcICQsJCAgKCAcHCg0KCgsMDAwMBwkODw0MDgsMDAz/2wBDAQICAgMDAwYDAwYMCAcIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAz/wAARCADeAN4DASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDtKKKK/cD8rCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAP/Z"
This might help
You're passing your io.Reader to png.Decode(), which begins consuming the reader, only to discover that the input is not a valid PNG, so returns an error.
Then your partly-consumed reader is passed to jpeg.Decode(), which reads the data not yet read, which is not a valid JPEG, and returns the error you observe.
You need to create a new reader for each decoder:
pngI, errPng := png.Decode(bytes.NewReader(unbased))
// ...
jpgI, errJpg := jpeg.Decode(bytes.NewReader(unbased))
Or better yet, consider the MIME type, and only call the proper decoder:
switch strings.TrimSuffix(image[5:coI], ";base64") {
case "image/png":
pngI, err = png.Decode(res)
// ...
case "image/jpeg":
jpgI, err = jpeg.Decode(res)
// ...
}
Here's something which may help, demonstrates quite a few other things too (you need to have two files: flower.jpg and mouse.png to make this work, available in the repository https://github.com/rravishankar/golangtraining/tree/master/test/jpegencode):
package main
import (
"bufio"
"encoding/base64"
"fmt"
"image"
"image/jpeg"
"image/png"
"strings"
"log"
"os"
)
func main() {
createJpg()
createPng()
base64toPng()
base64toJpg(getJPEGbase64("flower.jpg"))
}
//Take an existing jpg srcFileName and decode/encode it
func createJpg() {
srcFileName := "flower.jpg"
dstFileName := "newFlower.jpg"
// Decode the JPEG data. If reading from file, create a reader with
reader, err := os.Open(srcFileName)
if err != nil {
log.Fatal(err)
}
defer reader.Close()
//Decode from reader to image format
m, formatString, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
return
}
fmt.Println("Got format String", formatString)
fmt.Println(m.Bounds())
//Encode from image format to writer
f, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0777)
if err != nil {
log.Fatal(err)
return
}
err = jpeg.Encode(f, m, &jpeg.Options{Quality: 75})
if err != nil {
log.Fatal(err)
return
}
fmt.Println("Jpg file", dstFileName, "created")
}
//Take an existing png srcFileName and decode/encode it
func createPng() {
srcFileName := "mouse.png"
dstFileName := "newMouse.png"
reader, err := os.Open(srcFileName)
if err != nil {
log.Fatal(err)
}
defer reader.Close()
//Decode from reader to image format
m, formatString, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
return
}
fmt.Println("Got format String", formatString)
fmt.Println(m.Bounds())
//Encode from image format to writer
f, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0777)
if err != nil {
log.Fatal(err)
return
}
err = png.Encode(f, m)
if err != nil {
log.Fatal(err)
return
}
fmt.Println("Png file", dstFileName, "created")
}
//Converts pre-existing base64 data (found in example of https://golang.org/pkg/image/#Decode) to test.png
func base64toPng() {
const data = `
/9j/4AAQSkZJRgABAQIAHAAcAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdA
SFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2Nj
Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCABnAJYDASIAAhEBAxEB/8QA
HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh
MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW
V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG
x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF
BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV
YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE
hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq
8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDlwKMD0pwzSiuK57QzGDxS7D6in8Y5ximnAPUfSlcq4m3ilUYp
2OKXHvRcVxnTtS7c07HNFK4DQPakC4PNOA+tOx70XAjK/So5gBGP94fzqfvUVx/qxx/EP51UXqRP4WSE
cmgjilP3jSEZqS0IO/NGDnpUiocDg/McDjvV6HTPOdVWYgsM5KcfzzQ2JySM2jp6VYu7SWzmMUwG4cgj
kMPUVBjjtTGtRu0Zopw+lFFxhinrGzuqqMsxAA9yaXFSRv5cqSEcIwYj6GpuZ30O30fSLKzhUpbpNMv3
5XGTn29BV28jt7pPLuIVljPBBFVreYx+VbqAjycgt3x14zRcNOxGyVFHQkIc/wA61exyKLbuzjdZ046d
ftEuTEw3Rk9SPT8P8Kpbea3tchbyVae4JkjbbGpGdwOM89Af6ViFTWUtGdcXoM2+woK1JtpNtTcoZt+l
Jt7ZqTbRtouFyPFRXI/c9D94fzqzioLsfuD/ALw/nVReqIn8LJCOTSY+tSMOTmkIpXLRu+F0t5pJxPHG
wjjUAuBjJJz1+laD6Pai+WaK9SBX6puzn6ZP+NV/Dkdtc6ZNbyAFwxLAHDYPv6VoQ21nPNEEiQGEFRtk
Gf0NaWTOeW7Of8QwGG4MRZnEbYXPJwRnOR0zWNXW+KrqBLUWi5EjbWCgcAA9c/gRXKYqZaGlK/LqMH0F
FLtHvRSNiYD2pSDTgpp6p0ywUHoTULXYxcktzrdCf7Xo8LP/AKyEmMNjJ46dfbFWJ5TDGNwB9lFUvDV9
YrbfYGbyrjcWG88S57g+vtV26ZIvMlumKwwjLZ6V0WfU54yTvYwtbubea2WNWbzg4bYQeBgj8OtYeKhj
u4y2HQxqxOD1xzxmrWAQCCGB6EGsaikndmsJxeiYzBo280/Z7UbayuaXGY5oIp+2lx9KLjIsVDeD/Rj/
ALy/zq1t96r3y4tT/vL/ADq4P3kRP4WSleTSFKkkKoCW4GaqNcMxIjXj1pxjKT0FKrGC1Nrw3vGrKkYz
5kTAr6455/HH510UdwPtRgWCbzF5+YYUf4Vwun39xpmoR3qASMmQUJwGU9Rnt/8AWrpbrxhb8/ZdOmaQ
gAGZwFH5ZJrpVKVlY5ZYhN6kXiu2eO/ikZlIljAAB5yM549OawSOOlPuLqe+umuLqTfM4OSOAo7ADsKh
hl/cRsTuJHPv7mlKi3sVTxNtGP20VJhThgSQaK52mnZnUqsWrpkyeUrr5pABOAPU1AGaXUCWJISHGPfP
P8qL7BiKnsMg46H3qrbzupbj5mPTPTpXVSglG551SpzSsXJ4/MBUgYIxyKpySyGBYJriV1D7kRpCVH4V
bSeNJ4xchni3DeqnBI+td7F4b0mKIRjT45VbktJlzk455+n6VtYzv2PNwFZWBHBGKVJDGVC54/nXQeMN
NttLNkba1jgWVWDmM8bhg4/nzXLSSbXVj6fyNKUdNRp21RtIRJGrjuM0u3FQ2DbodvcEkfQmrW2vLqLl
k0ejCXNFMj2/jQV9qkxSYNRcsZiq2oI32N2CkhWXJxwOe9XMcVt6hoPn6dFaW0wgRpNzvKDlz6+/0rai
ryv2Jm9LHJai+ZRGCBjnr71ErdAxAY9B611t1Y2cunbbaOQ3FvKZI3UqGlZMbiWwfcfhV231iwvLSM3U
lt5Uq52TuZG+hGMA12xXJGxxzjzybOQtNOvb5j9ktZJhnBIHyg+5PFX38JayqK/2eLJIBUTgkDA9q7ex
itrSHFpGsUbndhRgc+g7VNIyfZJAoJZUbb3I46CtFJMylBo8sdWhmYMuCnylc9wef5VUT7+1chc5NS7h
sUZO5RtIPUH3pkBDOxxxmqM9TQtn+WilhHfHaik43KTG3Z4IyPyrNVjGCsZ+dmwv6V3cXhSG8sYpJLud
JJIwxChdoJGcYx/Wkg8DafA4knvLiQr/ALqj+VQpKw3FtnFFfvbiSMgZJ6/jXp2n3d9cQRBTFsKD96EP
oOxPU/8A68VVtbbRtMVntbePKDLTSHJH/Aj/AEqHTvE66rq72VugMMcbSGTnL4wMAfjT5n0HyW3L+s6b
baxaJBdzN+7bcrxkAhun0rz3VNCv7e7lgigknWI43xLu6jjIHTjtXqfkpPGVYsBkghTikgsYIN/lhgXb
cxLkknp/ShczQ7xtY8vtEmhkj8yGRBuCnehUcnHcVtmwfJ/fQ8e7f/E12txZW91C0U6b42xlST2OR/Ko
Bo1gM/uW55/1jf41nOipu7LhV5FZHIGzI6zwj/vr/Ck+yr3uYf8Ax7/CutbQdMb71tn/ALaN/jSf8I/p
X/PoP++2/wAan6rAr6wzkWt0II+1Rc/7Lf4Vd1eeCSKBbdZDdShYoiZNoyfY10P/AAj2lf8APmP++2/x
oPh/SjKspsozIuNrZORjp3qo0FHYPb3OZt7ae3SzjuItsiRSAgnccl/UA+3Q1yNjKLR4ZZYY5VD7tkv3
WwO/+e1evPp9nI257aJm6bioz1z1+tY+s6Hplnot9PbWMMcqwOFcLyOO1bJWMZSTOPHi+9w3mosrlyd2
9lCj02g9P/1e9a3hzxAbl2ikZRcdQueHHt7j864Y8Z4I4oRzG6urFWU5BHBB7HNJxTFGbR6he6Vpmtgm
eLy5zwZI/lb8fX8azIvBUUTHdfSFP4QsYB/HNZ+k+KEnRY75hHOvAk6K/v7H9K6yyvlnQBmDZ6GsnzR0
N0oy1RzOtaN/Y1tHNFO06u+zYy4I4Jzx9KKveJblXuordSGES5b6n/62PzorKVdp2LjQTVyWz8UWEWlq
jSgyxfJt6EgdDzWTdeLIZGO7zHI/hVajGmWWP+PWL8qwlAIURrhpMAHHJA71pRcZrToZzcoEuo6heakA
GHk245CZ6/X1qPTLq40q+W5t2QybSpDAkEEc55/zilk5k2r91eKhLDzWz2rpsczbbuemeD76fUNG865I
MiysmQMZAAwa3a5j4ftu0ByP+fh/5CulkLLG7INzhSVHqe1Fh3uOoqn9qQQxyhndmHIxwOmSR2xQ13KD
KoiBZOV9JBnt707MVy5RWdNdy7wRGf3bfMinnO1jg+vY03WXLaJO3mhQ20b0zwpYf0qlG7S7icrJs08U
VwumgC+YiQyeVtZH567hzj8aSL949oGhE/2v5pJCDkksQwBHC4/+vXQ8LZ2uYxxCavY7us/xCcaBfn0h
b+VP0bnSrb94ZMJgOecj1rl/GfidUE2k2gy5+SeQjgA/wj3rlas2jdao48qrjLAGkSKPk4Gc1WMj92I+
lIJnU8OfxPWo5inBokmtQTmM4OOh71b0q6vbFmWCbaxHyqQGAP0PT8KhSTzVyo5ocSKA5VfTOTmqsmRd
pl99XjPzThzK3zOeOSeveirNmkgg/fIpYsTkYORxRXmzlTjJqx6EVUcU7mhkKCzdAK59QI9zYxtG1fYU
UVtgtmY4nZEa8Ak9aqFv3rfSiiu1nMeifDv/AJF+T/r4f+QrqqKKQwzQenNFFMCOKFIgNuThdoJ5OPSk
ubeK6t3gnXdG4wwziiii/UTKMOg6dbzJLFE4dSCP3rEdeOM8805tDsGMvySgSsS6rM6gk9eAcUUVftZt
3uyVGNthuq3Eei6DK8H7sRR7YuMgHtXkc8rzTNLM26RyWY+p70UVnLY0iEsUipG7rhZBlDkc1HgYoorM
0HwyBXGeRjmrcUhMg2ghezd//rUUVcTKW5s2jZtY/QDaOKKKK8ip8bPRj8KP/9k=
`
reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
m, formatString, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
}
bounds := m.Bounds()
fmt.Println(bounds, formatString)
//Encode from image format to writer
pngFilename := "test.png"
f, err := os.OpenFile(pngFilename, os.O_WRONLY|os.O_CREATE, 0777)
if err != nil {
log.Fatal(err)
return
}
err = png.Encode(f, m)
if err != nil {
log.Fatal(err)
return
}
fmt.Println("Png file", pngFilename, "created")
}
//Given a base64 string of a JPEG, encodes it into an JPEG image test.jpg
func base64toJpg(data string) {
reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
m, formatString, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
}
bounds := m.Bounds()
fmt.Println("base64toJpg", bounds, formatString)
//Encode from image format to writer
pngFilename := "test.jpg"
f, err := os.OpenFile(pngFilename, os.O_WRONLY|os.O_CREATE, 0777)
if err != nil {
log.Fatal(err)
return
}
err = jpeg.Encode(f, m, &jpeg.Options{Quality: 75})
if err != nil {
log.Fatal(err)
return
}
fmt.Println("Jpg file", pngFilename, "created")
}
//Gets base64 string of an existing JPEG file
func getJPEGbase64(fileName string) string {
imgFile, err := os.Open(fileName)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
defer imgFile.Close()
// create a new buffer base on file size
fInfo, _ := imgFile.Stat()
var size = fInfo.Size()
buf := make([]byte, size)
// read file content into buffer
fReader := bufio.NewReader(imgFile)
fReader.Read(buf)
imgBase64Str := base64.StdEncoding.EncodeToString(buf)
//fmt.Println("Base64 string is:", imgBase64Str)
return imgBase64Str
}
You may also want to read the example in https://golang.org/pkg/image/#Decode
Hope this helps.
I am new to Golang and have a function that uploads an image to my Amazon s3 account and saves it . Everything works great however I was looking for a way to resize images as some images are up to 4MB in size. I found a package that works correctly for resizing images https://github.com/disintegration/imaging . My question is how can I use the new resized image instead of the old file to upload ? For instance this is my original code that uploads an image and does not resize
func UploadProfile(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
var buff bytes.Buffer
var result string
sess, _ := "access keys"
svc := s3.New(sess)
file, handler, err := r.FormFile("file")
if err != nil {
fmt.Println("Error Uploading Image")
return
}
defer file.Close()
read_file,err := ioutil.ReadAll(file)
fileBytes := bytes.NewReader(read_file)
if err != nil {
fmt.Println("Error Reading file")
return
}
file.Read(read_file)
path := handler.Filename
params := &s3.PutObjectInput{
Bucket: aws.String("amazon-bucket"),
Key: aws.String(path),
Body: fileBytes,
}
resp, err := svc.PutObject(params)
if err != nil {
fmt.Printf("bad response: %s", err)
}
}
The issue I am now having is with this snippet below
file_open,err := imaging.Open("myImage.jpg")
if err != nil {
print("Imaging Open error")
}
new_image := imaging.Resize(file_open, 300, 300, imaging.Lanczos)
errs := imaging.Save(new_image, "dst.jpg")
if errs != nil {
print(err)
}
The code above gets any image and resizes it to 300 by 300 which is exactly what I want, now how can I use that new Image and send it to my s3 image bucket ? The part that confuses me is that the new_image is of type image.NRGBA while the original image is of type Multipart.File . When I upload an image to Amazon it wants to know how many bytes it has and I can't do something like
read_file,err := ioutil.ReadAll(new_image)
if err != nil {
fmt.Println("Error Reading file")
return
}
because it only expects something of type io.Reader is there any work around this ? so that I can save my new Image to Amazon s3 ?
You're saving the new image to a file, then not doing anything with that file. You could read the file off the disk if you want, or you could encode it in memory:
...
resized := imaging.Resize(fileOpen, 300, 300, imaging.Lanczos)
var buf byte.Buffer
err = imaging.Encode(&buf, resized, imaging.JPEG)
if err != nil {
log.Println(err)
return
}
params := &s3.PutObjectInput{
Bucket: aws.String("amazon-bucket"),
Key: aws.String(path),
Body: buf.Bytes(),
}
...