Beispiel #1
5
//水印
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()
}
Beispiel #2
0
func Fuzz(data []byte) int {
	cfg, err := png.DecodeConfig(bytes.NewReader(data))
	if err != nil {
		return 0
	}
	if cfg.Width*cfg.Height > 1e6 {
		return 0
	}
	img, err := png.Decode(bytes.NewReader(data))
	if err != nil {
		return 0
	}
	for _, c := range []png.CompressionLevel{png.DefaultCompression, png.NoCompression, png.BestSpeed, png.BestCompression} {
		var w bytes.Buffer
		e := &png.Encoder{c}
		err = e.Encode(&w, img)
		if err != nil {
			panic(err)
		}
		img1, err := png.Decode(&w)
		if err != nil {
			panic(err)
		}
		if !reflect.DeepEqual(img.Bounds(), img1.Bounds()) {
			fmt.Printf("bounds0: %#v\n", img.Bounds())
			fmt.Printf("bounds1: %#v\n", img1.Bounds())
			panic("bounds have changed")
		}
	}
	return 1
}
Beispiel #3
0
func main() {

	f, err := os.Open(os.Args[1])
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	i50, err := png.Decode(f)
	if err != nil {
		fmt.Println(err)
		return
	}
	if f, err = os.Open(os.Args[2]); err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	i100, err := png.Decode(f)
	if err != nil {
		fmt.Println(err)
		return
	}
	if i50.ColorModel() != i100.ColorModel() {
		fmt.Println("different color models")
		return
	}
	b := i50.Bounds()
	if !b.Eq(i100.Bounds()) {
		fmt.Println("different image sizes")
		return
	}
	var sum int64
	for y := b.Min.Y; y < b.Max.Y; y++ {
		for x := b.Min.X; x < b.Max.X; x++ {
			r1, g1, b1, _ := i50.At(x, y).RGBA()
			r2, g2, b2, _ := i100.At(x, y).RGBA()
			if r1 > r2 {
				sum += int64(r1 - r2)
			} else {
				sum += int64(r2 - r1)
			}
			if g1 > g2 {
				sum += int64(g1 - g2)
			} else {
				sum += int64(g2 - g1)
			}
			if b1 > b2 {
				sum += int64(b1 - b2)
			} else {
				sum += int64(b2 - b1)
			}
		}
	}
	nPixels := (b.Max.X - b.Min.X) * (b.Max.Y - b.Min.Y)
	fmt.Printf("Image difference: %f%%\n",
		float64(sum*100)/(float64(nPixels)*0xffff*3))
}
Beispiel #4
0
func init() {
	var err error

	Terrain, err = png.Decode(bytes.NewReader(TerrainPng))
	if err != nil {
		panic(err)
	}
	TerrainPng = nil

	Actors, err = png.Decode(bytes.NewReader(ActorsPng))
	if err != nil {
		panic(err)
	}
	ActorsPng = nil
}
Beispiel #5
0
func fixtureImageObj(fpath string) image.Image {
	f, _ := os.Open(fpath)
	buf, _ := ioutil.ReadFile(f.Name())
	img, _ := png.Decode(bytes.NewReader(buf))
	// *image.RGBA
	return img
}
Beispiel #6
0
//func loadSize(ctxt *fs.Context, name string, max int) *image.RGBA
func loadSize(name string, max int) *image.RGBA {
	//data, _, err := ctxt.Read("qr/upload/" + name + ".png")
	f1, err := os.Open(name + ".png")
	fmt.Println(name + ".png")
	if err != nil {
		panic(err)
	}
	i, err := png.Decode(f1)
	if err != nil {
		panic(err)
	}
	b := i.Bounds()
	fmt.Printf("%v, %v,max%v", b.Dx(), b.Dy(), max)
	dx, dy := max, max
	if b.Dx() > b.Dy() {
		dy = b.Dy() * dx / b.Dx()
	} else {
		dx = b.Dx() * dy / b.Dy()
	}
	fmt.Printf("%v, %v,", dx, 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)
	default:
		fmt.Println("default")

	}
	fmt.Println("prereturnload")
	fmt.Printf("%v, %v,", irgba.Bounds().Dx(), irgba.Bounds().Dy())
	return irgba
}
Beispiel #7
0
func main() {
	if len(os.Args) != 2 {
		fmt.Println("Please select one picture to makeascii...")
		return
	}
	fileName := os.Args[1]
	isJpeg, _ := regexp.MatchString(".+\\.jpg", fileName)
	isPng, _ := regexp.MatchString(".+\\.png", fileName)
	var picture image.Image
	var imageErr error
	fileIn, errIn := os.Open(fileName)
	if errIn != nil {
		fmt.Println(errIn.Error())
		return
	}
	if isJpeg {
		picture, imageErr = jpeg.Decode(fileIn)
	} else if isPng {
		picture, imageErr = png.Decode(fileIn)
	} else {
		fmt.Println("File type is not supported...")
		return
	}
	if imageErr != nil {
		fmt.Println(imageErr.Error())
		return
	}
	fmt.Print(MakeAscii(GetImage(picture)))
}
Beispiel #8
0
func createTexture(r io.Reader) (textureId gl.Uint, err error) {
	img, err := png.Decode(r)
	if err != nil {
		return 0, err
	}

	rgbaImg, ok := img.(*image.NRGBA)
	if !ok {
		return 0, errors.New("texture must be an NRGBA image")
	}

	gl.GenTextures(1, &textureId)
	gl.BindTexture(gl.TEXTURE_2D, textureId)
	gl.TexParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
	gl.TexParameterf(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)

	// flip image: first pixel is lower left corner
	imgWidth, imgHeight := img.Bounds().Dx(), img.Bounds().Dy()
	data := make([]byte, imgWidth*imgHeight*4)
	lineLen := imgWidth * 4
	dest := len(data) - lineLen
	for src := 0; src < len(rgbaImg.Pix); src += rgbaImg.Stride {
		copy(data[dest:dest+lineLen], rgbaImg.Pix[src:src+rgbaImg.Stride])
		dest -= lineLen
	}
	gl.TexImage2D(gl.TEXTURE_2D, 0, 4, gl.Sizei(imgWidth), gl.Sizei(imgHeight), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Pointer(&data[0]))

	return textureId, nil
}
Beispiel #9
0
func TestDescriptor(t *testing.T) {
	square, err := os.Open("../test/images/square.png")
	if err != nil {
		t.Fatal(err)
	}
	img, err := png.Decode(square)

	points := make(chan image.Point, 2)

	go func() {
		points <- image.Point{16, 16}
		close(points)
	}()

	desc := make(chan Descriptor)
	CalcDescriptors(points, img, desc, RGBPointValue)

	i := 0
	for d := range desc {
		if d.base != 16191 {
			t.Logf("Base value of descriptor should be 15, instead it was %v", d.base)
			t.Fail()
		}
		i++
	}
	if i != 1 {
		t.Logf("CalcDescriptor should have returned exactly 1 descriptor, given 1 point")
		t.Fail()
	}
}
Beispiel #10
0
func readTarget(name string) ([][]int, error) {
	f, err := os.Open(name)
	if err != nil {
		return nil, err
	}
	m, err := png.Decode(f)
	if err != nil {
		return nil, fmt.Errorf("decode %s: %v", name, err)
	}
	rect := m.Bounds()
	target := make([][]int, rect.Dy())
	for i := range target {
		target[i] = make([]int, rect.Dx())
	}
	for y, row := range target {
		for x := range row {
			a := int(color.RGBAModel.Convert(m.At(x, y)).(color.RGBA).A)
			t := int(color.GrayModel.Convert(m.At(x, y)).(color.Gray).Y)
			if a == 0 {
				t = -1
			}
			row[x] = t
		}
	}
	return target, nil
}
Beispiel #11
0
func main() {
	var file *os.File
	var outFile *os.File
	var img image.Image
	var err error

	if file, err = os.Open("pkg.png"); err != nil {
		println("Error", err)
		return
	}
	defer file.Close()

	if img, err = png.Decode(file); err != nil {
		println("Error", err)
		return
	}

	if outFile, err = os.Create("out_pkg.jpeg"); err != nil {
		println("Error", err)
		return
	}

	option := &jpeg.Options{Quality: 100}
	if err = jpeg.Encode(outFile, img, option); err != nil {
		println()
		return
	}
	defer outFile.Close()
}
Beispiel #12
0
func CountColor(_png io.Reader) int {
	/* modify here */
	config, err := png.DecodeConfig(_png)
	if err != nil {
		log.Fatal(err)
	}

	width := config.Width * 10
	height := config.Height * 10

	_png = GetPngBinary()

	img, err := png.Decode(_png)
	if err != nil {
		log.Fatal(err)
	}

	var r, g, b, a uint32
	var str string
	m := make(map[string]int)
	for x := 0; x < width; x++ {
		for y := 0; y < height; y++ {

			r, g, b, a = img.At(x, y).RGBA()
			str = strconv.Itoa(int(r)) + strconv.Itoa(int(g)) + strconv.Itoa(int(b)) + strconv.Itoa(int(a))
			m[str] = 1
		}
	}

	return len(m - 1)
}
Beispiel #13
0
func convertPNGToJPEG(w io.Writer, r io.Reader, quality int) error {
	img, err := png.Decode(r)
	if err != nil {
		return err
	}
	return jpeg.Encode(w, img, &jpeg.Options{Quality: quality})
}
Beispiel #14
0
func main() {
	flag.Parse()

	if len(flag.Args()) != 1 {
		fmt.Println("Usage: goicns -o IconSet.icns image.png")
		return
	}

	path := flag.Args()[0]

	f, err := os.OpenFile(path, os.O_RDONLY, 0600)
	if err != nil {
		fmt.Println("Error opening image %s: %s", path, err.Error())
		return
	}

	img, err := png.Decode(f)
	if err != nil {
		fmt.Println("Error decoding image %s: %s", path, err.Error())
		return
	}

	icns := goicns.NewICNS(img)
	if err = icns.Construct(); err != nil {
		fmt.Println("Error encofing ICNS %s: %s", path, err.Error())
		return
	}

	icns.WriteToFile(*flOut, 0666)
}
Beispiel #15
0
func main() {
	pngImgFile, err := os.Open("./2.png")

	if err != nil {
		fmt.Println("2.png file not found!")
		os.Exit(1)
	}

	defer pngImgFile.Close()

	imgSrc, err := png.Decode(pngImgFile)

	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	newImg := image.NewRGBA(imgSrc.Bounds())
	draw.Draw(newImg, newImg.Bounds(), &image.Uniform{color.White}, image.Point{}, draw.Src)

	draw.Draw(newImg, newImg.Bounds(), imgSrc, imgSrc.Bounds().Min, draw.Over)

	jpgImgFile, err := os.Create("./draw.jpg")

	if err != nil {
		fmt.Println("Cannot create draw.jpg !")
		fmt.Println(err)
		os.Exit(1)
	}

	defer jpgImgFile.Close()
}
Beispiel #16
0
func run() error {
	qml.Init(nil)
	engine := qml.NewEngine()
	engine.AddImageProvider("pwd", func(id string, width, height int) image.Image {
		f, err := os.Open(id)
		if err != nil {
			panic(err)
		}
		defer f.Close()
		image, err := png.Decode(f)
		if err != nil {
			panic(err)
		}
		return image
	})

	component, err := engine.LoadFile("imgprovider.qml")
	if err != nil {
		return err
	}

	win := component.CreateWindow(nil)
	win.Show()
	win.Wait()

	return nil
}
Beispiel #17
0
func (vr *VaultRenderer) LoadTexture(name string) *splish.Sprite {
	if tex, ok := textures[name]; ok {
		return tex
	}

	// get an asset path
	imgName := name
	if !strings.HasSuffix(imgName, ".png") {
		imgName += ".png"
	}
	parts := strings.Split("assets/"+imgName, "/")
	path := filepath.Join(parts...)
	f, err := os.Open(path)
	if err != nil {
		log.Println("Couldn't open file:", path, err)
		return textures["blank"]
	}

	// decode png, convert to RGBA
	img, err := png.Decode(f)
	if err != nil {
		log.Println("Couldn't decode file:", err)
		return textures["blank"]
	}
	rgba := image.NewRGBA(img.Bounds())
	draw.Draw(rgba, rgba.Bounds(), img, image.ZP, draw.Src)

	// Push it out to the window to get uploaded
	tex := vr.Scene.NewSprite(rgba)
	textures[name] = tex

	return tex
}
func TestNewRevisitImageWithPNG(t *testing.T) {
	pngMsg, err := NewRevisitMsgFromFiles("./fixtures/connie.png")
	if err != nil {
		t.Fatal(err)
	}

	ri, err := NewRevisitImageFromMsg(pngMsg)
	if err != nil {
		t.Fatal(err)
	}

	if len(ri.Rgbas) != 1 {
		t.Errorf("ri.Rgbas length should be 1, is %d", len(ri.Rgbas))
	}

	if len(ri.Delay) != 1 {
		t.Errorf("ri.Delay length should be 1, is %d", len(ri.Delay))
	}

	if ri.LoopCount != 0 {
		t.Errorf("LoopCount should be 0, is %d", ri.LoopCount)
	}

	ri.Transform(mockTransform)

	m, err := ri.RevisitMsg()
	if err != nil {
		t.Error(err)
	}

	_, err = png.Decode(m.ImageByteReader())
	if err != nil {
		t.Error(err)
	}
}
Beispiel #19
0
func (s *Screening) createGIF(force bool) error {
	fn := s.GIFPath()
	if !force {
		if _, err := os.Stat(fn); err == nil {
			return nil
		}
	}

	outGIF := &gif.GIF{}
	for i := uint(0); i < s.Steps; i++ {
		f, err := os.Open(s.ScreenshotPath(i))
		if err != nil {
			return err
		}
		defer f.Close()

		img, err := png.Decode(f)
		if err != nil {
			return err
		}

		paletted := image2paletted(720, img)
		outGIF.Image = append(outGIF.Image, paletted)
		outGIF.Delay = append(outGIF.Delay, 100)
	}

	f, err := os.Create(fn)
	if err != nil {
		return err
	}
	defer f.Close()
	return gif.EncodeAll(f, outGIF)
}
Beispiel #20
0
func readImagePng(filename string) (image []Spectrum, width, height int) {
	f, err := os.Open(filename)
	defer f.Close()
	if err != nil {
		Error("Error reading PNG \"%s\"", filename)
		return nil, 0, 0
	}

	pngImage, err := png.Decode(f)
	if err != nil {
		Error("Error decoding PNG \"%s\"", filename)
		return nil, 0, 0
	}

	bounds := pngImage.Bounds()

	width = bounds.Dx()
	height = bounds.Dy()
	image = make([]Spectrum, width*height, width*height)

	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			rb, gb, bb, _ := pngImage.At(x, y).RGBA()
			r := float64(rb) / float64(0xffff)
			g := float64(gb) / float64(0xffff)
			b := float64(bb) / float64(0xffff)
			image[y*width+x] = *NewSpectrumRGB(r, g, b)
		}
	}
	return image, width, height
}
Beispiel #21
0
func loadImage() ([]byte, int, int) {
	// Open the file.
	file, err := os.Open("gopher.png")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// Decode the image.
	img, err := png.Decode(file)
	if err != nil {
		log.Fatal(err)
	}
	bounds := img.Bounds()
	width, height := bounds.Size().X, bounds.Size().Y
	buffer := make([]byte, width*height*4)
	index := 0
	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()
			buffer[index] = byte(r)
			buffer[index+1] = byte(g)
			buffer[index+2] = byte(b)
			buffer[index+3] = byte(a)
			index += 4
		}
	}
	return buffer, width, height
}
func main() {
	f, err := os.Open("Pentagon.png")
	if err != nil {
		fmt.Println(err)
		return
	}
	pent, err := png.Decode(f)
	if err != nil {
		fmt.Println(err)
		return
	}
	if err = f.Close(); err != nil {
		fmt.Println(err)
	}
	h := hough(pent, 460, 360)
	if f, err = os.Create("hough.png"); err != nil {
		fmt.Println(err)
		return
	}
	if err = png.Encode(f, h); err != nil {
		fmt.Println(err)
	}
	if cErr := f.Close(); cErr != nil && err == nil {
		fmt.Println(err)
	}
}
Beispiel #23
0
func readImage(data []byte, format string) (image.Image, error) {
	reader := bytes.NewReader(data)
	if format == "png" {
		return png.Decode(reader)
	}
	return jpeg.Decode(reader)
}
Beispiel #24
0
// Using biom borders to generate slow but random-tolerance tile hash
func generateBorderHash(imagePath string) []byte {
	var invalidHash []byte = nil
	file, err := os.Open(imagePath)
	if err != nil {
		fmt.Printf("Cannot generate image hash #1\n")
		return invalidHash
	}
	defer file.Close()
	tileImage, err := png.Decode(file)
	if err != nil {
		fmt.Printf("Cannot generate image '%s' hash #2: %s\n", imagePath, err.Error())
		return invalidHash
	}
	bounds := tileImage.Bounds()
	h := md5.New()
	blackCount := 0
	pixelsCount := 0
	// some tiles contain artifacts near the borders
	for x := 5; x < bounds.Max.X-5; x++ {
		for y := 5; y < bounds.Max.Y-5; y++ {
			pixel := tileImage.At(x, y)
			r, g, b, _ := pixel.RGBA()
			if r == 0 && g == 0 && b == 0 {
				binary.Write(h, binary.LittleEndian, []byte(strconv.Itoa(x)))
				binary.Write(h, binary.LittleEndian, []byte(strconv.Itoa(y)))
				blackCount++
			}
			pixelsCount++
		}
	}
	if blackCount == 0 || blackCount == pixelsCount {
		return invalidHash
	}
	return h.Sum(nil)
}
Beispiel #25
0
func loadLogos(context appengine.Context, globpaths ...string) map[string][]image.Image {
	logoImagesByName := make(map[string][]image.Image)

	for _, path := range globpaths {
		logoFolders, err := filepath.Glob(path + "/*")
		check(err, context)

		for _, logoFolder := range logoFolders {
			logoFiles, err := filepath.Glob(logoFolder + "/*")
			check(err, context)

			filename := filepath.Base(logoFolder)
			logoImages := make([]image.Image, 0)

			for _, logoFile := range logoFiles {
				//fmt.Fprintf(os.Stderr, "%s\n", logoFile)
				logoData, err := os.Open(logoFile)
				defer logoData.Close()
				check(err, context)

				reader := bufio.NewReader(logoData)
				logoImage, err := png.Decode(reader)
				check(err, context)

				logoImages = append(logoImages, logoImage)
			}

			logoImagesByName[filename] = logoImages

		}
	}

	return logoImagesByName
}
Beispiel #26
0
func loader(inChan chan loaderRequest, outChan chan *Image, errChan chan *Error, stopChan chan int) {
	for {
		select {
		case req := <-inChan:
			switch strings.ToLower(path.Ext(req.name)) {
			case ".jpg":
				if img, err := jpeg.Decode(req.reader); err == nil {
					outChan <- &Image{Name: req.name, Data: img}
				} else {
					errChan <- &Error{Name: req.name, Message: err.Error()}
				}
			case ".png":
				if img, err := png.Decode(req.reader); err == nil {
					outChan <- &Image{Name: req.name, Data: img}
				} else {
					errChan <- &Error{Name: req.name, Message: err.Error()}
				}
			}

			if err := req.reader.Close(); err != nil {
				fmt.Errorf("%s\n", err)
			}
		case <-stopChan:
			return
		}
	}
}
Beispiel #27
0
// TestMean tests the mean quantizer on png files found in the source
// directory.  Output files are prefixed with _mean_.  Files begining with
// _ are skipped when scanning for input files.  Note nothing is tested
// with a fresh source tree--drop a png or two in the source directory
// before testing to give the test something to work on.  Png files in the
// parent directory are similarly used for testing.  Put files there
// to compare results of the different quantizers.
func TestMean(t *testing.T) {
	for _, p := range glob(t) {
		f, err := os.Open(p)
		if err != nil {
			t.Log(err) // skip files that can't be opened
			continue
		}
		img, err := png.Decode(f)
		f.Close()
		if err != nil {
			t.Log(err) // skip files that can't be decoded
			continue
		}
		pDir, pFile := filepath.Split(p)
		for _, n := range []int{16, 256} {
			// prefix _ on file name marks this as a result
			fq, err := os.Create(fmt.Sprintf("%s_mean_%d_%s", pDir, n, pFile))
			if err != nil {
				t.Fatal(err) // probably can't create any others
			}
			var q quant.Quantizer = mean.Quantizer(n)
			if err = png.Encode(fq, q.Image(img)); err != nil {
				t.Fatal(err) // any problem is probably a problem for all
			}
		}
	}
}
Beispiel #28
0
func OpenBAMD(r io.ReadSeeker, palettePath string) (*BAM, error) {
	var d decoder
	if err := d.decode_bamd(r); err != nil {
		return nil, err
	}
	bam := &BAM{
		Image:           d.image,
		Sequences:       d.sequences,
		SequenceToImage: d.FrameLUT,
		Width:           d.width,
		Height:          d.height,
		Frames:          d.Frames,
		Palette:         d.colorMap,
	}
	bam.RebuildSequencesAndDropFrames()
	if _, err := os.Stat(palettePath); err == nil {
		log.Printf("Using palette at: %s\n", palettePath)
		paletteFile, err := os.Open(palettePath)
		if err != nil {
			return nil, fmt.Errorf("Unable to open palette %s: %v", palettePath, err)
		}
		defer paletteFile.Close()

		palette_template_img, err := png.Decode(paletteFile)
		if err != nil {
			return nil, fmt.Errorf("Unable to decode png %s: %v", palettePath, err)
		}
		bam.Palette = palette_template_img.ColorModel().(color.Palette)
	}

	return bam, nil
}
Beispiel #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)
}
Beispiel #30
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
}