Example #1
13
//download image from town
func (t *Townparser) downloadImage(url string, name string) error {
	defer func() {
		if err := recover(); err != nil {
			log.Info("%s recovered from panic", TAG)
			return
		}
	}()
	if url == "0" {
		return nil
	}
	exist, err := exists("templates/static/images/" + name + ".jpg")
	if err != nil {
		log.Error("%s %s", TAG, err.Error())
	}

	if !exist {
		resp, err := t.Tc.Get(url)
		if err != nil {
			log.Error("%s image download failed, name: %v, url: %v", TAG, name, url)
			log.Error("%s %s", TAG, err.Error())
			return err
		}
		defer resp.Body.Close()
		if strings.Contains(url, "jpg") || strings.Contains(url, "jpeg") {
			img, _ := jpeg.Decode(resp.Body)
			m := resize.Resize(300, 0, img, resize.Lanczos2Lut)
			out, err := os.Create("templates/static/images/" + name + ".jpg")
			if err != nil {
				log.Error("%s %s", TAG, err.Error())
				return nil
			}

			// write new image to file
			jpeg.Encode(out, m, nil)
			out.Close()
		} else if strings.Contains(url, "png") {
			img, err := png.Decode(resp.Body)
			if err != nil {
				log.Error("%s %s", TAG, err.Error())
			}
			m := resize.Resize(300, 0, img, resize.Lanczos2Lut)
			out, err := os.Create("templates/static/images/" + name + ".png")
			if err != nil {
				log.Error("%s %s", TAG, err.Error())
				return nil
			}

			// write new image to file
			jpeg.Encode(out, m, nil)
			out.Close()
		}
	}
	time.Sleep(200 * time.Millisecond)
	return nil
}
Example #2
13
func thumbnailHandler() http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

		filename, err := url.QueryUnescape(r.URL.String())
		checkErr(err)

		fmt.Println("handling request for", filename)

		file, err := os.Open(filename)
		checkErr(err)
		defer file.Close()

		img, filetype, err := image.Decode(file)
		checkErr(err)

		var newImage image.Image

		if thumbnailSize < img.Bounds().Dx() || thumbnailSize < img.Bounds().Dy() {
			if img.Bounds().Dx() > img.Bounds().Dy() {
				newImage = resize.Resize(uint(thumbnailSize), 0, img, resize.Lanczos3)
			} else {
				newImage = resize.Resize(0, uint(thumbnailSize), img, resize.Lanczos3)
			}
		} else {
			newImage = img
		}

		switch filetype {
		case "png":
			err = png.Encode(w, newImage)
		case "gif":
			err = gif.Encode(w, newImage, nil)
		case "jpeg", "jpg":
			err = jpeg.Encode(w, newImage, nil)
		case "bmp":
			err = bmp.Encode(w, newImage)
		case "tiff":
			err = tiff.Encode(w, newImage, nil)
		default:
			// not sure how you got here but what are we going to do with you?
			fmt.Println("Unknown image type: ", filetype)
			io.Copy(w, file)
		}
		checkErr(err)
		fmt.Println("done handling request")

	})
}
Example #3
0
func (p *photo) Transform(crop image.Rectangle, width, height uint, dontenlarge bool, format string, resample resize.InterpolationFunction) (Image, error) {
	img, err := p.Image()
	if err != nil {
		return nil, e.Forward(err)
	}

	imgResized := img
	if !(width == 0 && height == 0) {
		rect := img.Bounds()
		w := uint(rect.Max.X - rect.Min.X)
		h := uint(rect.Max.Y - rect.Min.Y)

		if (width >= w || height >= h) && !dontenlarge {
			imgResized = resize.Resize(width, height, img, resample)
		} else if width < w && height < h {
			imgResized = resize.Resize(width, height, img, resample)
		}
	}

	b := make([]byte, 0, 1024)
	buf := bytes.NewBuffer(b)

	err = jpeg.Encode(buf, imgResized, nil)
	if err != nil {
		return nil, e.Forward(err)
	}

	return &photo{Buf: buf.Bytes()}, nil
}
func resizeImage(im image.Image, width int, height int) image.Image {
	if width > height {
		return resize.Resize(0, uint(height), im, resize.Lanczos3)
	}

	return resize.Resize(uint(width), 0, im, resize.Lanczos3)
}
Example #5
0
//funcion resize imagen
func (u Util) ImgRZ(s string) {

	//cargamos archivo de imageb jpg
	file, err := os.Open("static/images/fotos_ori/" + s)
	if err != nil {
		log.Fatal("en este 1", err)
	}

	// decode jpeg  image.Image
	img, err := jpeg.Decode(file)
	if err != nil {
		log.Fatal("en este 2", err)
	}
	file.Close()

	// resize to width 1000 using Lanczos resampling
	// and preserve aspect ratio
	m := resize.Resize(216, 162, img, resize.Lanczos3)

	out, err := os.Create("static/images/fotos_rz/" + s)
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()

	// write new image to file
	jpeg.Encode(out, m, nil)

	return

}
Example #6
0
// Make thumbnail for the selected file
func MakeThumb(src string, dst_sane string, dst_thumb string) error {
	file, err := os.Open(src)
	defer file.Close()
	if err != nil {
		return err
	}

	img, err := jpeg.Decode(file)
	if err != nil {
		return err
	}

	sane := resize.Resize(1080, 0, img, resize.Bilinear)

	out_sane, err := os.Create(dst_sane)
	if err != nil {
		return err
	}
	defer out_sane.Close()

	jpeg.Encode(out_sane, sane, nil)

	thumb := resize.Thumbnail(200, 200, img, resize.Bilinear)

	out_thumb, err := os.Create(dst_thumb)
	if err != nil {
		return err
	}
	defer out_thumb.Close()

	jpeg.Encode(out_thumb, thumb, nil)
	return nil
}
Example #7
0
func createSmallPic(file io.Reader, fileSmall string, w, h int) error {
	// decode jpeg into image.Image
	img, err := jpeg.Decode(file)
	if err != nil {
		return err
	}
	b := img.Bounds()
	if w > b.Dx() {
		w = b.Dx()
	}
	if h > b.Dy() {
		h = b.Dy()
	}
	// resize to width 1000 using Lanczos resampling
	// and preserve aspect ratio
	m := resize.Resize(uint(w), uint(h), img, resize.Lanczos3)

	out, err := os.Create(fileSmall)
	if err != nil {
		return err
	}
	defer out.Close()

	// write new image to file
	return jpeg.Encode(out, m, nil)
}
Example #8
0
func ConvertMenuIcon(i image.Image) *BitmapImage {
	menubarHeigh := GetSystemMenuImageSize()

	c := resize.Resize(menubarHeigh, menubarHeigh, i, resize.Lanczos3)

	return BitmapImageNew(c)
}
Example #9
0
func renderThumbs() {
	images, err := ioutil.ReadDir("src/assets/photos")
	if err != nil {
		log.Printf("Error: %v\n", err.Error())
		return
	}

	for _, img := range images {
		if !img.IsDir() {
			f, err := os.Open(fmt.Sprintf("src/assets/photos/%v", img.Name()))
			if err != nil {
				log.Printf("Error: %v\n", err.Error())
			} else {
				i, err := jpeg.Decode(f)
				if err != nil {
					log.Printf("Error: %v\n", err.Error())
				} else {
					f.Close()

					thumb := resize.Resize(400, 0, i, resize.Lanczos3)

					out, err := os.Create(fmt.Sprintf("src/assets/photos/thumbs/%v", img.Name()))
					if err != nil {
						log.Printf("Error: %v\n", err.Error())
					} else {
						defer out.Close()
						jpeg.Encode(out, thumb, nil)
					}
				}
			}
		}
	}
}
Example #10
0
func (r *ResizeConverter) Convert(inFile string, outFile string, rect Rect) error {
	in, err := os.Open(inFile)
	if err != nil {
		log.Fatalf("Runner(File): cannot open source file '%s' for reading (%s).", inFile, err)
	}
	defer in.Close()

	out, err := os.Create(outFile)
	if err != nil {
		log.Printf("ERROR: cannot create new file %s (%s)", outFile, err)
	}
	defer out.Close()

	source, _, err := image.Decode(in)
	if err != nil {
		return err
	}

	interp, ok := interpolations[r.Interpolation]
	if !ok {
		interp = interpolations["l3"]
	}

	resized := resize.Resize(rect.Width, rect.Height, source, interp)
	png.Encode(out, resized)
	return nil
}
Example #11
0
func NewThumbnail(uri string, width, height uint) (filepath, mediatype string, w, h int, err error) {
	fp, mediatype, _, err := document.DefaultCurl().Download(uri)
	if err != nil {
		return
	}
	f, err := os.Open(fp)
	if err != nil {
		return
	}
	defer f.Close()
	img, mediatype, err := image.Decode(f)
	if err != nil {
		return
	}
	imgnew := resize.Resize(width, height, img, resize.MitchellNetravali)
	w = imgnew.Bounds().Max.X
	h = imgnew.Bounds().Max.Y

	of, err := ioutil.TempFile("", "")
	if err != nil {
		return
	}
	defer of.Close()
	err = jpeg.Encode(of, imgnew, &jpeg.Options{90})
	if err != nil {
		return
	}
	filepath = of.Name()
	return
}
Example #12
0
func writeAnsiImage(img image.Image, file *os.File, width int) {
	m := resize.Resize(uint(width), uint(float32(width)*PROPORTION), img, resize.Lanczos3)
	var current, previous string
	bounds := m.Bounds()
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			current = toAnsiCode(m.At(x, y))
			if current != previous {
				fmt.Print(current)
				file.WriteString(current)
			}
			if ANSI_RESET != current {
				char := string(CHARACTERS[rand.Int()%len(CHARACTERS)])
				fmt.Print(char)
				file.WriteString(char)
			} else {
				fmt.Print(" ")
				file.WriteString(" ")
			}
		}
		fmt.Print("\n")
		file.WriteString("\n")
	}
	fmt.Print(ANSI_RESET)
	file.WriteString(ANSI_RESET)
}
Example #13
0
// Generates a resized image image from the original.
func (s *Store) generate(name, size, interp string) (path string, err error) {
	uSize, err := strconv.ParseUint(size, 10, 0)

	if err != nil {
		return
	}
	interpolation, ok := interpolations[interp]

	if !ok {

		return "", errors.New("Unknown interpolation: " + interp)
	}
	f, err := os.Open(s.hashedPath(name, "orig"))

	if err != nil {
		return
	}
	defer f.Close()

	img, _, err := image.Decode(f)

	if err != nil {
		return
	}
	newImg := resize.Resize(uint(uSize), 0, img, interpolation)

	return s.store(filepath.Join(size, interp), name, newImg)
}
Example #14
0
//截图生成文件
func resizeImage2file(src_img, dest_img string) {
	file, err := os.Open(src_img)
	if err != nil {
		fmt.Println(err)
		return
	}

	// decode jpeg into image.Image
	img, err := jpeg.Decode(file)
	if err != nil {
		fmt.Println(err)
		return
	}

	file.Close()
	m := resize.Resize(0, 1000, img, resize.Lanczos2)
	out, err := os.Create(dest_img)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer out.Close()

	err = jpeg.Encode(out, m, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
}
Example #15
0
func imgToFile(ic *iconf) (string, error) {
	img := resize.Resize(ic.width, 0, ic.image, resize.NearestNeighbor)
	ic.height = uint(img.Bounds().Size().Y)
	ic.fid = fmt.Sprintf("%s-%s-%s-%s-%s-%s-%d-%d", ic.machine, ic.format, ic.density, ic.ui, ic.hash, ic.color, ic.width, ic.height)
	dir := fmt.Sprintf("%s/%s/%s/%s/%s/%s/%s", conf.SushiobrolStore, ic.machine, ic.format, ic.density, ic.ui, ic.hash[0:2], ic.hash[2:4])
	ic.path = fmt.Sprintf("%s/%s", dir, ic.fid)
	out, err := os.Create(ic.path)
	if err != nil {
		log.Println(err)
		return "", err
	}
	defer out.Close()
	if conf.InputType == "jpeg" {
		err = jpeg.Encode(out, img, nil) // write image to file
		if err != nil {
			fmt.Println("ERROR: Unable to Encode into webp")
			return "", err
		}
	} else {
		if webp.Encode(out, img, &webp.Options{conf.Lossless, conf.Quality}); err != nil {
			fmt.Println("ERROR: Unable to Encode into webp")
			return "", err
		}
	}
	return ic.fid, err
}
Example #16
0
// Resize all images given to it
func resizeImages(path string, dim *Dimensions, progress chan int) {
	file, err := os.Open(path)
	if err != nil {
		log.Fatal(err)
		progress <- 1
		return
	}
	img, err := jpeg.Decode(file)
	file.Close()
	if err != nil {
		log.Fatal(err)
		progress <- 1
		return
	}
	res := resize.Resize(dim.height, dim.width, img, resize.Lanczos3)
	out, err := os.Create(PutImagePath + strconv.FormatInt(rand.Int63(), 36) + ".jpg")
	if err != nil {
		log.Fatal(err)
		progress <- 1
		return
	}
	defer out.Close()
	jpeg.Encode(out, res, nil)
	progress <- 1
}
Example #17
0
func ResizeImage(src, dst string) (err error) {
	// open "test.jpg"
	file, err := os.Open(src)
	if err != nil {
		// mlog.Error(err)
		return err
	}
	defer file.Close()

	// decode jpeg into image.Image
	img, err := jpeg.Decode(file)
	if err != nil {
		// mlog.Error(err)
		return err
	}
	// file.Close()

	// resize to width 1000 using Lanczos resampling
	// and preserve aspect ratio
	m := resize.Resize(80, 0, img, resize.Lanczos3)

	out, err := os.Create(dst)
	if err != nil {
		// mlog.Error(err)
		return err
	}
	defer out.Close()

	// write new image to file
	return jpeg.Encode(out, m, nil)
}
Example #18
0
func createIconButton(driver gxui.Driver, theme gxui.Theme, iconPath string) gxui.Button {
	button := theme.CreateButton()
	button.SetType(gxui.PushButton)

	fileBytes, err := assets.Asset(iconPath)
	if err != nil {
		log.Printf("Error: Failed to read asset %s: %s", iconPath, err)
		return button
	}
	f := bytes.NewBuffer(fileBytes)
	src, _, err := image.Decode(f)
	if err != nil {
		log.Printf("Error: Failed to decode image %s: %s", iconPath, err)
		return button
	}
	src = resize.Resize(24, 24, src, resize.Bilinear)

	rgba := image.NewRGBA(src.Bounds())
	draw.Draw(rgba, src.Bounds(), src, image.ZP, draw.Src)
	texture := driver.CreateTexture(rgba, 1)

	icon := theme.CreateImage()
	icon.SetTexture(texture)
	button.AddChild(icon)
	return button
}
Example #19
0
// DifferenceHash computes the difference hash of an image.
func DifferenceHash(source image.Image) uint64 {

	const sw, sh, hw, hh = 9, 8, 8, 8

	// Convert the image to the grayscale colourspace.
	bounds := source.Bounds()
	width, height := bounds.Max.X, bounds.Max.Y
	gray := image.NewGray(source.Bounds())
	for x := 0; x < width; x++ {
		for y := 0; y < height; y++ {
			gray.Set(x, y, source.At(x, y))
		}
	}

	// Resize the image.
	shrunk := resize.Resize(sw, sh, gray, resize.NearestNeighbor).(*image.Gray)

	// Compute the difference hash.
	var hash uint64
	for y := 0; y < hh; y++ {
		for x := 0; x < hw; x++ {
			if shrunk.GrayAt(x, y).Y < shrunk.GrayAt(x+1, y).Y {
				hash |= 1 << uint64((y*hw)+x)
			}
		}
	}
	return hash

}
Example #20
0
func (c *appContext) uploadPic(a *multipart.FileHeader) (string, string) {
	log.Println("In upload pic territory")

	bucket := c.bucket

	file, err := a.Open()
	defer file.Close()
	if err != nil {
		panic(err.Error())
	}

	if err != nil {
		panic(err)
	}

	buf, _ := ioutil.ReadAll(file)

	fn := uuid.New()
	fname := "places/" + fn + path.Ext(a.Filename)
	thumbname := "placesthumb/" + fn + path.Ext(a.Filename)
	log.Println(fname)

	b := "http://s3-us-west-2.amazonaws.com/" + c.bucket.Name + "/" + fname
	d := "http://s3-us-west-2.amazonaws.com/" + c.bucket.Name + "/" + thumbname

	filetype := http.DetectContentType(buf)

	err = bucket.Put(fname, buf, filetype, s3.PublicRead)

	if err != nil {
		log.Println("bucket put error for main image")
		panic(err.Error())

	}
	log.Print("added a full image")
	img, err := jpeg.Decode(bytes.NewReader(buf))

	if err != nil {
		log.Println(err.Error())
	}

	m := resize.Resize(200, 200, img, resize.Lanczos2)

	buf2 := new(bytes.Buffer)
	err = jpeg.Encode(buf2, m, nil)
	if err != nil {
		fmt.Println(err.Error())
	}
	thumb := buf2.Bytes()
	filetype2 := http.DetectContentType(thumb)
	err = bucket.Put(thumbname, thumb, filetype2, s3.PublicRead)

	if err != nil {
		log.Println("bucket put error for thumbnail")
		panic(err.Error())
	}
	log.Println("uploaded one thumb image")
	return b, d

}
func (converter *ImageConverter) convertToType(path string, newType string, channel chan int) {
	file, _ := os.Open(path)

	pathParts := strings.Split(path, "/")
	filename := pathParts[len(pathParts)-1]

	picture, format, _ := image.Decode(file)
	rectangle := picture.Bounds()

	modifier := converter.widthModifier(newType)
	newWidth := uint(modifier * float32(rectangle.Dx()))

	if newWidth < 1 {
		newWidth = 1
	}

	newImage := resize.Resize(newWidth, 0, picture, resize.NearestNeighbor)
	typeDirectory := strings.Join([]string{converter.Directory, "..", newType}, "/")

	os.Mkdir(typeDirectory, 0700)

	newFile, _ := os.Create(strings.Join([]string{typeDirectory, filename}, "/"))

	switch format {
	case "jpeg":
		jpeg.Encode(newFile, newImage, nil)
	case "png":
		png.Encode(newFile, newImage)
	}

	file.Close()
	newFile.Close()
	channel <- 1
}
Example #22
0
func main() {
	// open "1.jpg"
	file, err := os.Open("3.jpg")
	if err != nil {
		log.Fatal(err)
	}

	// decode jpeg into image.Image
	img, err := jpeg.Decode(file)
	if err != nil {
		log.Fatal(err)
	}
	file.Close()

	// resize to width 1000 using Lanczos resampling
	// and preserve aspect ratio
	m := resize.Resize(1, 0, img, resize.NearestNeighbor)

	r, g, b, _ := m.At(0, 0).RGBA()

	fmt.Printf("%X%X%X", r>>8, g>>8, b>>8) // removing 1 byte 9A16->9A

	out, err := os.Create("test_resized3.jpg")
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()

	// write new image to file
	jpeg.Encode(out, m, nil)
}
Example #23
0
func thumb() image.Image {
	imageName := "test.jpg"
	imageFile, err := os.Open(imageName)
	if err != nil {
		log.Fatal(err)
	}

	var myImage *image.Image

	switch strings.ToLower(path.Ext(imageName)) {
	case ".jpg", ".jpeg":
		img, err := jpeg.Decode(imageFile)
		if err != nil {
			log.Fatal(err)
		}
		myImage = &img
	case ".png":
		img, err := png.Decode(imageFile)
		if err != nil {
			log.Fatal(err)
		}
		myImage = &img
	}
	imageFile.Close()

	m := resize.Resize(0, 200, *myImage, resize.MitchellNetravali)

	return m
}
Example #24
0
func MakeThumb(r io.Reader, w, h int, orient int) ([]byte, error) {
	img, _, err := image.Decode(r)
	if err != nil {
		return nil, err
	}

	m := resize.Resize(uint(w), uint(h), img, resize.Bicubic)

	switch orient {
	case 3, 4:
		m = imaging.Rotate180(m)
	case 5, 6:
		m = imaging.Rotate270(m)
	case 7, 8:
		m = imaging.Rotate90(m)
	}

	switch orient {
	case 2, 5, 4, 7:
		m = imaging.FlipH(m)
	}

	var buf bytes.Buffer
	err = jpeg.Encode(&buf, m, nil)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}
Example #25
0
// 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()
}
Example #26
0
func convertTrayIcon(i image.Image) NSImage {
	menubarHeight := uint(22) // FontHeight(NSFontMenuBarFontOfSize(0))

	c := resize.Resize(menubarHeight, menubarHeight, i, resize.Lanczos3)

	return NSImageImage(c)
}
Example #27
0
// 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()
}
Example #28
0
func convertMenuIcon(i image.Image) NSImage {
	menubarHeight := FontHeight(NSFontMenuFontOfSize(0))

	c := resize.Resize(menubarHeight, menubarHeight, i, resize.Lanczos3)

	return NSImageImage(c)
}
Example #29
0
// default image format: jpeg
func (this *Avatar) Encode(wr io.Writer, size int) (err error) {
	var img image.Image
	decodeImageFile := func(file string) (img image.Image, err error) {
		fd, err := os.Open(file)
		if err != nil {
			return
		}
		defer fd.Close()

		if img, err = jpeg.Decode(fd); err != nil {
			fd.Seek(0, os.SEEK_SET)
			img, err = png.Decode(fd)
		}
		return
	}
	imgPath := this.imagePath
	if !this.HasCache() {
		if this.AlterImage == "" {
			return errors.New("request image failed, and no alt image offered")
		}
		imgPath = this.AlterImage
	}

	if img, err = decodeImageFile(imgPath); err != nil {
		return
	}
	m := resize.Resize(uint(size), 0, img, resize.NearestNeighbor)
	return jpeg.Encode(wr, m, nil)
}
Example #30
0
func generateThumbnails(file multipart.File, userId, pathPrefix string, bucket *s3.Bucket) error {
	file.Seek(0, 0)

	img, _, err := image.Decode(file)
	if err != nil {
		log.Println("Error decoding image", err)
		return err
	}

	var buf bytes.Buffer
	for _, i := range THUMBNAIL_SIZES {
		resized := resize.Resize(uint(i), 0, img, resize.Lanczos3)
		err = jpeg.Encode(&buf, resized, nil)
		if err != nil {
			return err
		}
		path := fmt.Sprintf("%s/%d.jpg", pathPrefix, i)
		err = bucket.Put(path, buf.Bytes(), "image/jpeg", s3.PublicRead)
		if err != nil {
			return err
		}
		buf.Reset()
	}

	return err
}