Golang jpeg.Options類代碼示例

func procImage(fileName string) (string, error) {
	reader, err := os.Open(fileName)
	if err != nil {
		fmt.Errorf("Failed to open image with error: %s\n", err)
		return "", err
	}
	defer reader.Close()

	src, _, err := image.Decode(reader)
	if err != nil {
		fmt.Errorf("Failed to decode image with error: %s\n", err)
		return "", err
	}

	g := gift.New(
		gift.Invert(),
	)

	dst := image.NewRGBA(g.Bounds(src.Bounds()))
	g.Draw(dst, src)

	var opt jpeg.Options
	opt.Quality = 100

	fileName = fileName + "_processed.jpg"

	out, _ := os.Create(fileName)
	err = jpeg.Encode(out, dst, &opt)
	if err != nil {
		fmt.Errorf("Failed to encode image with error: %s\n", err)
		return "", err
	}

	return fileName, nil
}

func InvertImage(input string, outfile string) {
	reader, err := os.Open(input)
	if err != nil {
		panic(err)
	}
	defer reader.Close()
	img, _, err := image.Decode(reader)
	if err != nil {
		panic(err)
	}
	bounds := img.Bounds()
	inverted := image.NewNRGBA(bounds)
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			r, g, b, a := img.At(x, y).RGBA()
			r = 255 - r>>8
			g = 255 - g>>8
			b = 255 - b>>8
			inverted.SetNRGBA(x, y, color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
		}
	}
	pwd, _ := os.Getwd()
	fileName := path.Join(pwd, outfile)
	fp, err := os.Create(fileName)
	if err != nil {
		panic(err)
	}
	idx := strings.LastIndex(fileName, ".")
	if idx == -1 {
		panic(errors.New("you dont have a supported output file"))
	}
	ext := fileName[idx+1:]
	if ext == "png" {
		err = png.Encode(fp, inverted)
		if err != nil {
			panic(err)
		}
	} else if ext == "jpeg" || ext == "jpg" {
		var opt jpeg.Options
		opt.Quality = 100
		err = jpeg.Encode(fp, inverted, &opt)
		if err != nil {
			panic(err)
		}
	} else if ext == "gif" {
		var opt gif.Options
		opt.NumColors = 256
		err = gif.Encode(fp, inverted, &opt)
	} else {
		panic(errors.New("you dont have a supported output file"))
	}
}

func WriteToFile(filename string, img *image.RGBA) error {
	out, _ := os.Create(filename)

	switch ext := path.Ext(filename); ext {
	case ".jpg", ".jpeg":
		var opt jpeg.Options
		opt.Quality = 1000
		jpeg.Encode(out, img, &opt)
	case ".png":
		png.Encode(out, img)
	default:
		return errors.New("Unable to encode image")
	}
	return nil
}

func writeToJPEG(imageData image.Image) {

	out, osCreateErr := os.Create(outputImage)
	if osCreateErr != nil {
		log.Println("Create File (OS): ", osCreateErr)
	}
	defer out.Close()

	var opt jpeg.Options
	opt.Quality = 100

	jpegErr := jpeg.Encode(out, imageData, &opt)
	if jpegErr != nil {
		log.Println("Create File (JPEG Encode): ", jpegErr)
	}
}

func SameToDisk(context *common.AppContext, imagePath string, imageToSave *image.Image) error {
	if imgFilePng, err := os.Create(imagePath); err != nil {
		context.Log.Printf("Error saving PNG image: %s\n", err)
		return err
	} else {
		defer imgFilePng.Close()
		buffer := bufio.NewWriter(imgFilePng)
		var opt jpeg.Options
		opt.Quality = 95
		err := jpeg.Encode(buffer, *imageToSave, &opt)
		if err != nil {
			context.Log.Printf("Error encoding image:%s", err)
			return err
		}
		buffer.Flush()
		return nil
	}
}

func main() {
	//image.RegisterFormat(name, magic, decode, decodeConfig)
	file, err := os.Open("E:\\psds18291.jpg")
	if err != nil {
		log.Fatal("open file err:", err)
	}
	defer file.Close()
	img, str, err := image.Decode(file)
	if err != nil {
		log.Fatal("decode image err:", err)
	}
	log.Println(img.Bounds(), str)
	outfilepng, err := os.OpenFile("c:\\test1.jpg", os.O_CREATE|os.O_WRONLY, 0666)
	if err != nil {
		return
	}
	outfilejpg, err := os.OpenFile("c:\\test.jpg", os.O_CREATE|os.O_WRONLY, 0666)
	if err != nil {
		return
	}
	defer outfilejpg.Close()
	defer outfilepng.Close()
	rect := img.Bounds()
	rect = rect.Inset(10)
	m0 := image.NewRGBA(image.Rect(0, 0, 80, 50))
	for i := 0; i < m0.Bounds().Dx(); i++ {
		for j := 0; j < m0.Bounds().Dy(); j++ {
			m0.Set(i, j, color.RGBA{255, 0, 0, 255})
		}
	}
	m1, _ := m0.SubImage(image.Rect(1, 2, 5, 5)).(*image.RGBA)
	fmt.Println(m0.Bounds().Dx(), m1.Bounds().Dx())
	fmt.Println(m0.Stride == m1.Stride)
	m2 := m0.SubImage(image.Rect(0, 0, m0.Bounds().Dx(), m0.Bounds().Dy()))
	fmt.Println(m2.Bounds().Dx(), m2.Bounds().Dy())
	opt := jpeg.Options{Quality: 10}
	jpeg.Encode(outfilejpg, img, &opt)
	//png.Encode(outfilepng, img)
	//png.Encode(outfilepng, m0)
	uniform := image.NewUniform(color.RGBA{255, 255, 0, 0})
	//png.Encode(outfilepng, uniform)
	opt.Quality = 100
	jpeg.Encode(outfilepng, uniform, &opt)
}

func extractAndProcess(context *common.AppContext, fileNames <-chan string, results chan<- string, errChan chan<- error, directoryName string) {
	for fileName := range fileNames {
		filePath := common.DownloadBasePath + directoryName + "/" + fileName
		imageFile, err := os.Open(filePath)
		if err != nil {
			context.Log.Printf("Unable to open the image file %v Error is %v \n", fileName, err)
			errChan <- err
		}
		img, _, err := image.Decode(imageFile)
		if err != nil {
			context.Log.Println("ERROR: Not able to decode the image file. Error is: ", err)
			errChan <- err
		}

		nrgbaImage := ToNRGBA(img)
		bounds := nrgbaImage.Bounds()
		boundsString := fmt.Sprintln(bounds)
		context.Log.Println("The bounds BEFORE the resize are: ", boundsString)

		nrgbaImage = Resize(context, nrgbaImage, tileSize, tileSize)

		bounds = nrgbaImage.Bounds()
		boundsString = fmt.Sprintln(bounds)
		context.Log.Println("The bounds AFTER the resize are: ", boundsString)

		var opt jpeg.Options

		opt.Quality = 80

		imageFile.Close()
		writeFile, err := os.Create(filePath)
		if err != nil {
			context.Log.Println("Unable to open the file for writing. Error is:", err)
		}
		err = jpeg.Encode(writeFile, nrgbaImage, &opt)
		if err != nil {
			context.Log.Println("ERROR: Not able to write to file with JPEG encoding", err)
			errChan <- err
		}

		results <- boundsString
		writeFile.Close()
	}
}

func Barcode(data string) (pdf *gofpdf.Fpdf, err error) {
	b, err := code128.Encode(data)
	if err != nil {
		return
	}

	b, err = barcode.Scale(b, b.Bounds().Size().X, 10)
	if err != nil {
		panic(err)
	}

	out, err := ioutil.TempFile("", "lblmgrpnpbarcode")
	if err != nil {
		panic(err)
	}
	var opt jpeg.Options

	opt.Quality = 100
	err = jpeg.Encode(out, b, &opt)
	if err != nil {
		return
	}

	imgHeight := float64(b.Bounds().Size().Y)
	imgWidth := float64(b.Bounds().Size().X / 3)

	pdf = gofpdf.NewCustom(&gofpdf.InitType{
		UnitStr: "mm",
		Size:    gofpdf.SizeType{Wd: imgWidth, Ht: imgHeight},
	})

	pdf.AddPage()

	height, width := pdf.GetPageSize()
	pdf.Image(out.Name(), 0, 0, height, width, false, "jpg", 0, "")

	pdf.SetFillColor(255, 255, 255)
	pdf.Rect(0, 7, imgWidth, 5, "F")
	pdf.SetFont("Arial", "B", 6)
	pdf.Text(0, 9.1, data)
	out.Close()
	os.Remove(out.Name())
	return
}

func writeImgToFile(img image.Image, filename string) {
	out, err := os.Create(filename)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	var opt jpeg.Options

	opt.Quality = 100
	// ok, write out the data into the new JPEG file

	err = jpeg.Encode(out, img, &opt) // put quality to 80%
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	fmt.Println("Generated image to " + filename + " \n")
}

func writeToJP(t int) {

	outFile := fmt.Sprint("/Users/muralib/go/output/output", strconv.Itoa(t), ".jpg")
	if t < 10 {
		outFile = fmt.Sprint("/Users/muralib/go/output/output00", strconv.Itoa(t), ".jpg")
	} else if t < 100 {
		outFile = fmt.Sprint("/Users/muralib/go/output/output0", strconv.Itoa(t), ".jpg")
	}

	out, err := os.Create(outFile)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	imgRect := image.Rect(0, 0, gridSize*10, gridSize*10)
	img := image.NewGray(imgRect)
	draw.Draw(img, img.Bounds(), &image.Uniform{color.White}, image.ZP, draw.Src)
	for x := 0; x < gridSize; x++ {
		for y := 0; y < gridSize; y++ {
			fill := &image.Uniform{color.White}
			if Env[x][y] == -1 {
				fill = &image.Uniform{color.Black}
			} else if Env[x][y] > 1 {
				c := color.Gray{uint8(Env[x][y] * 20)}
				fill = &image.Uniform{c}
			}

			draw.Draw(img, image.Rect((x-1)*10, (y-1)*10, x*10, y*10), fill, image.ZP, draw.Src)
		}
	}

	var opt jpeg.Options

	opt.Quality = 80
	// ok, write out the data into the new JPEG file
	err = jpeg.Encode(out, img, &opt) // put quality to 80%
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	fmt.Println("Generated image to output.jpg \n")
}

func main() {
	flag.Parse()
	rand.Seed(time.Now().UTC().UnixNano())

	for i := 1; i < 10; i++ {
		outFile := fmt.Sprint("/Users/muralib/go/output/output", strconv.Itoa(i), ".jpg")
		out, err := os.Create(outFile)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}

		// generate some QR code look a like image
		c := color.Gray{uint8(128)}
		imgRect := image.Rect(0, 0, 100, 100)
		img := image.NewGray(imgRect)
		draw.Draw(img, img.Bounds(), &image.Uniform{color.White}, image.ZP, draw.Src)
		for y := 0; y < 100; y += 10 {
			for x := 0; x < 100; x += 10 {
				fill := &image.Uniform{c}
				if rand.Intn(10)%2 == 0 {
					fill = &image.Uniform{color.White}
				}
				draw.Draw(img, image.Rect(x, y, x+10, y+10), fill, image.ZP, draw.Src)
			}
		}

		var opt jpeg.Options

		opt.Quality = 80
		// ok, write out the data into the new JPEG file

		err = jpeg.Encode(out, img, &opt) // put quality to 80%
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}

		fmt.Println("Generated image to output.jpg \n")
	}
}

func ConvertToJpeg(filename string) (string, error) {
	pngImageFile, err := os.Open(filename)

	if err != nil {
		return "", err
	}

	defer pngImageFile.Close()

	pngSource, err := png.Decode(pngImageFile)

	if err != nil {
		return "", err
	}

	jpegImage := image.NewRGBA(pngSource.Bounds())

	draw.Draw(jpegImage, jpegImage.Bounds(), &image.Uniform{color.White}, image.Point{}, draw.Src)
	draw.Draw(jpegImage, jpegImage.Bounds(), pngSource, pngSource.Bounds().Min, draw.Over)

	outfile := fmt.Sprintf("%s_jpg", filename)
	jpegImageFile, err := os.Create(outfile)

	if err != nil {
		return "", err
	}

	defer jpegImageFile.Close()

	var options jpeg.Options
	options.Quality = 100

	err = jpeg.Encode(jpegImageFile, jpegImage, &options)

	if err != nil {
		fmt.Printf("JPEG Encoding Error: %v\n", err)
		os.Exit(1)
	}

	return outfile, nil
}

func WriteImage(img image.Image, ext string, w io.Writer) error {
	var err error
	if ext == "png" {
		err = png.Encode(w, img)
		if err != nil {
			return err
		}
	} else if ext == "jpeg" || ext == "jpg" {
		var opt jpeg.Options
		opt.Quality = 100
		err = jpeg.Encode(w, img, &opt)
		if err != nil {
			return err
		}
	} else if ext == "gif" {
		var opt gif.Options
		opt.NumColors = 256
		err = gif.Encode(w, img, &opt)
	} else {
		return errors.New("you dont have a supported output file")
	}
	return nil
}

//.........這裏部分代碼省略.........

				width, height, exact_size, err := parseSize(thumb_size)
				if err != nil {
					return err
				}

				if Exists(thumb_file_path) && overwrite == false {
					log.Printf("Nothing to do, thumb %s already exists\n", thumb_file_path)
				} else {
					var img image.Image

					file, err := os.Open(source_image)
					if err != nil {
						return err
					}

					if mime == "image/jpeg" {
						img, err = jpeg.Decode(file)
						if err != nil {
							return err
						}
					} else if mime == "image/gif" {
						img, err = gif.Decode(file)
						if err != nil {
							return err
						}
					} else if mime == "image/png" {
						img, err = png.Decode(file)
						if err != nil {
							return err
						}
					}

					file.Close()

					var resized_image image.Image

					if exact_size {
						img_width, img_height, err := getImageDimensions(source_image)
						if err != nil {
							return err
						}

						img_ratio := float64(img_width) / float64(img_height)

						thumb_ratio := float64(width) / float64(height)

						resize_width := uint(width)
						resize_height := uint(height)

						if img_ratio > thumb_ratio {
							resize_width = uint(img_width * 5)
						} else {
							resize_height = uint(img_height * 5)
						}

						image := resize.Thumbnail(resize_width, resize_height, img, resize.Lanczos3)

						resized_image, err = cutter.Crop(image, cutter.Config{
							Width:  width,
							Height: height,
						})
						if err != nil {
							return err
						}

					} else {
						resized_image = resize.Thumbnail(uint(width), uint(height), img, resize.Lanczos3)
					}

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

					defer out.Close()

					if mime == "image/jpeg" {
						var jpeg_opt jpeg.Options
						jpeg_opt.Quality = viper.GetInt("jpeg_quality")
						jpeg.Encode(out, resized_image, &jpeg_opt)
					} else if mime == "image/gif" {
						var gif_opt gif.Options
						gif_opt.NumColors = 256

						gif.Encode(out, resized_image, &gif_opt)
					} else if mime == "image/png" {
						png.Encode(out, resized_image)
					}
				}
			} else {
				return errors.New("Can't create thumbnails. " + thumb_folder_path + " must be a directory")
			}
		}
	} else {
		return errors.New("Thumbs folder doesn't exist or is not a Folder")
	}

	return err
}

func main() {
	image1Ptr := flag.String("i1", "", "input image 1")
	image2Ptr := flag.String("i2", "", "input image 2")
	image1OutPtr := flag.String("o1", "", "output image 1")
	image2OutPtr := flag.String("o2", "", "output image 2")

	flag.Parse()

	if *image1Ptr == "" {
		log.Fatal("Need to provide i1 flag for path to image 1")
	}

	if *image2Ptr == "" {
		log.Fatal("Need to provide i2 flag for path to image 2")
	}

	image1File, err := os.Open(*image1Ptr)
	if err != nil {
		log.Fatalf("Failed to open image %s, %v", *image1Ptr, err)
	}
	defer image1File.Close()

	image2File, err := os.Open(*image2Ptr)
	if err != nil {
		log.Fatalf("Failed to open image %s, %v", *image2Ptr, err)
	}
	defer image2File.Close()

	im1, _, err := image.Decode(image1File)
	if err != nil {
		log.Fatalf("Failed to decode image %v", err)
	}

	im2, _, err := image.Decode(image2File)
	if err != nil {
		log.Fatalf("Failed to decode image %v", err)
	}

	hash1 := phash.GreyscaleDctMatrix(im1)
	hash2 := phash.GreyscaleDctMatrix(im2)

	distance := phash.HammingDistance(hash1, hash2)

	log.Printf("Image 1 hash: %x\n", hash1)
	log.Printf("Image 2 hash: %x\n", hash2)
	log.Printf("Hamming Distance: %d", distance)

	if *image1OutPtr != "" {
		im1 := phash.HashToImage(hash1)
		out, _ := os.Create(*image1OutPtr)
		var opt jpeg.Options
		opt.Quality = 100
		_ = jpeg.Encode(out, im1, &opt) // put quality to 80%
	}

	if *image2OutPtr != "" {
		im2 := phash.HashToImage(hash2)
		out, _ := os.Create(*image2OutPtr)
		var opt jpeg.Options
		opt.Quality = 100
		_ = jpeg.Encode(out, im2, &opt) // put quality to 80%
	}
}