Golang NewNRGBA示例

说明

golang newnrgba示例是从最受好评的开源项目中提取的实现代码，你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: image

示例#1

文件： file.go 项目： elvizlai/MGBlog

//水印
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()
}

示例#2

文件： process.go 项目： spideynn/imgd

// Sets skin.Processed to an isometric render of the head from a top-left angle (showing 3 sides).
func (skin *mcSkin) GetCube(width int) error {
	// Crop out the top of the head
	topFlat := imaging.Crop(skin.Image, image.Rect(8, 0, 16, 8))
	// Resize appropriately, so that it fills the `width` when rotated 45 def.
	topFlat = imaging.Resize(topFlat, int(float64(width)*math.Sqrt(2)/3+1), 0, imaging.NearestNeighbor)
	// Create the Gift filter
	filter := gift.New(
		gift.Rotate(45, color.Transparent, gift.LinearInterpolation),
	)
	bounds := filter.Bounds(topFlat.Bounds())
	top := image.NewNRGBA(bounds)
	// Draw it on the filter, then smush it!
	filter.Draw(top, topFlat)
	top = imaging.Resize(top, width+2, width/3, imaging.NearestNeighbor)
	// Skew the front and sides at 15 degree angles to match up with the
	// head that has been smushed
	front := skin.cropHead(skin.Image).(*image.NRGBA)
	side := imaging.Crop(skin.Image, image.Rect(0, 8, 8, 16))
	front = imaging.Resize(front, width/2, int(float64(width)/1.75), imaging.NearestNeighbor)
	side = imaging.Resize(side, width/2, int(float64(width)/1.75), imaging.NearestNeighbor)
	front = skewVertical(front, math.Pi/12)
	side = skewVertical(imaging.FlipH(side), math.Pi/-12)

	// Create a new image to assemble upon
	skin.Processed = image.NewNRGBA(image.Rect(0, 0, width, width))
	// Draw each side
	draw.Draw(skin.Processed.(draw.Image), image.Rect(0, width/6, width/2, width), side, image.Pt(0, 0), draw.Src)
	draw.Draw(skin.Processed.(draw.Image), image.Rect(width/2, width/6, width, width), front, image.Pt(0, 0), draw.Src)
	// Draw the top we created
	draw.Draw(skin.Processed.(draw.Image), image.Rect(-1, 0, width+1, width/3), top, image.Pt(0, 0), draw.Over)

	return nil
}

示例#3

文件： orientation.go 项目： netroby/seaweedfs

func rotate(im image.Image, angle int) image.Image {
	var rotated *image.NRGBA
	// trigonometric (i.e counter clock-wise)
	switch angle {
	case 90:
		newH, newW := im.Bounds().Dx(), im.Bounds().Dy()
		rotated = image.NewNRGBA(image.Rect(0, 0, newW, newH))
		for y := 0; y < newH; y++ {
			for x := 0; x < newW; x++ {
				rotated.Set(x, y, im.At(newH-1-y, x))
			}
		}
	case -90:
		newH, newW := im.Bounds().Dx(), im.Bounds().Dy()
		rotated = image.NewNRGBA(image.Rect(0, 0, newW, newH))
		for y := 0; y < newH; y++ {
			for x := 0; x < newW; x++ {
				rotated.Set(x, y, im.At(y, newW-1-x))
			}
		}
	case 180, -180:
		newW, newH := im.Bounds().Dx(), im.Bounds().Dy()
		rotated = image.NewNRGBA(image.Rect(0, 0, newW, newH))
		for y := 0; y < newH; y++ {
			for x := 0; x < newW; x++ {
				rotated.Set(x, y, im.At(newW-1-x, newH-1-y))
			}
		}
	default:
		return im
	}
	return rotated
}

示例#4

文件： signer.go 项目： ailncode/ufop

func (this *Signer) GetMoreLineImage(text string, text_color image.Image, l int, fix_top, fix_bottom int) (image.Image, error) {
	r := image.Rect(0, 0, 414, 96)
	img := image.NewNRGBA(r)
	c := freetype.NewContext()
	c.SetDPI(this.Dpi)
	c.SetFont(this.font)
	c.SetFontSize(this.FontSize)
	c.SetClip(img.Bounds())
	c.SetDst(img)
	c.SetSrc(text_color)

	//pt := freetype.Pt(0, 0)
	pt := freetype.Pt(0, 0+int(c.PointToFix32(this.FontSize)>>8))
	var err error
	limit := c.PixToFix32(l)
	str := strings.Split(text, "\r\n")
	for i, s := range str {
		pt, err = c.DrawString(s, pt, limit)
		if err != nil {
			fmt.Println("c.DrawString(%s) error(%v)", s, err)
			return nil, err
		}
		if i < len(str)-1 {
			pt.Y += c.PointToFix32(this.FontSize * 1.5)
		}
	}
	x, y := l, c.Fix32ToPix(pt.Y)
	sub_r := image.Rect(0, 0, x+20, y+(fix_bottom-fix_top))

	sub_img := image.NewNRGBA(sub_r)
	draw.Draw(sub_img, sub_r, img, image.Point{0, fix_top}, draw.Src)
	return sub_img, nil
}

示例#5

文件： slide.go 项目： ayatk/MinecraftRecipeMaker

// imgの片方の辺をずらして変形する
// (option=trueで縦/falseで横に伸ばす/option2=trueで左上固定/falseで右下固定)
// ＿　　　 ＿
// | |　→ / /
// ￣　　　￣
//
func Slide(img *image.Image, length int, option bool, option2 bool) image.Image {
	size := (*img).Bounds().Size()
	//横を伸ばす場合は横の長さがx+x/lenになる
	img2 := image.NewNRGBA(image.Rect(0, 0, size.X+int(float64(size.X)/float64(length)), size.Y))
	if option {
		//縦を伸ばす場合は縦の長さがx+x/lenになる
		img2 = image.NewNRGBA(image.Rect(0, 0, size.X, size.Y+int(float64(size.Y)/float64(length))))
	}
	size2 := (*img2).Bounds().Size()
	//統一で扱うために長い方を取得
	sizeB := size2.Y
	if size2.X > size2.Y {
		sizeB = size2.X
	}

	offset := 0
	for x, x2 := 0, 0; x < sizeB; x++ {
		//逆スタートの場合は反転
		x2 = x
		if option2 {
			if option {
				x2 = size2.X - x
			} else {
				x2 = size2.Y - x
			}
		}

		for y, y2 := 0, 0; y < sizeB; y++ {
			//逆スタートの場合は反転
			y2 = y
			if option2 {
				if option {
					y2 = size2.Y - y
				} else {
					y2 = size2.X - y
				}
			}

			c := (*img).At(x2, y2)
			r, g, b, _ := c.RGBA()
			if !(r == 0 && g == 0 && b == 0) {
				//縦横の入れ替えの場合
				if option {
					img2.Set(x2, y2+offset, c)
				} else {
					img2.Set(y2+offset, x2, c)
				}
			}
		}

		//ずらす分
		if x2%length == 0 {
			offset++
		}
	}
	return img2
}

示例#6

文件： perceptual_test.go 项目： crhym3/imgdiff

func BenchmarkPCompare(b *testing.B) {
	m1 := image.NewNRGBA(image.Rect(0, 0, 100, 100))
	m2 := image.NewNRGBA(image.Rect(0, 0, 100, 100))
	d := NewDefaultPerceptual()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			d.Compare(m1, m2)
		}
	})
}

示例#7

文件： helpers_test.go 项目： mf1389004071/platform

func TestEncodeDecode(t *testing.T) {
	imgWithAlpha := image.NewNRGBA(image.Rect(0, 0, 3, 3))
	imgWithAlpha.Pix = []uint8{
		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
		127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
		244, 245, 246, 247, 248, 249, 250, 252, 252, 253, 254, 255,
	}

	imgWithoutAlpha := image.NewNRGBA(image.Rect(0, 0, 3, 3))
	imgWithoutAlpha.Pix = []uint8{
		0, 1, 2, 255, 4, 5, 6, 255, 8, 9, 10, 255,
		127, 128, 129, 255, 131, 132, 133, 255, 135, 136, 137, 255,
		244, 245, 246, 255, 248, 249, 250, 255, 252, 253, 254, 255,
	}

	for _, format := range []Format{JPEG, PNG, GIF, BMP, TIFF} {
		img := imgWithoutAlpha
		if format == PNG {
			img = imgWithAlpha
		}

		buf := &bytes.Buffer{}
		err := Encode(buf, img, format)
		if err != nil {
			t.Errorf("fail encoding format %s", format)
			continue
		}

		img2, err := Decode(buf)
		if err != nil {
			t.Errorf("fail decoding format %s", format)
			continue
		}
		img2cloned := Clone(img2)

		delta := 0
		if format == JPEG {
			delta = 3
		} else if format == GIF {
			delta = 16
		}

		if !compareNRGBA(img, img2cloned, delta) {
			t.Errorf("test [DecodeEncode %s] failed: %#v %#v", format, img, img2cloned)
			continue
		}
	}

	buf := &bytes.Buffer{}
	err := Encode(buf, imgWithAlpha, Format(100))
	if err != ErrUnsupportedFormat {
		t.Errorf("expected ErrUnsupportedFormat")
	}
}

示例#8

文件： resize_test.go 项目： donlzx/rez

func TestNrgbaPlanes(t *testing.T) {
	w, h := 256, 256
	src := readImage(t, "testdata/nrgba.png")
	ref := image.NewNRGBA(src.Bounds())
	err := Convert(ref, src, nil)
	expect(t, err, nil)
	raw := image.NewNRGBA(image.Rect(0, 0, w*2, h*2))
	dst := raw.SubImage(image.Rect(7, 7, 7+w, 7+h))
	err = Convert(dst, src, NewBicubicFilter())
	expect(t, err, nil)
	err = Convert(src, dst, NewBicubicFilter())
	expect(t, err, nil)
	checkPsnrs(t, ref, src, image.Rectangle{}, []float64{39})
}

示例#9

文件： functions.go 项目： alexchipliev/go-start

func NewImageOfTypeRect(src image.Image, bounds image.Rectangle) image.Image {
	switch i := src.(type) {
	case *image.Alpha:
		return image.NewAlpha(bounds)
	case *image.Alpha16:
		return image.NewAlpha16(bounds)
	case *image.Gray:
		return image.NewGray(bounds)
	case *image.Gray16:
		return image.NewGray16(bounds)
	case *image.NRGBA:
		return image.NewNRGBA(bounds)
	case *image.NRGBA64:
		return image.NewNRGBA64(bounds)
	case *image.Paletted:
		return image.NewPaletted(bounds, i.Palette)
	case *image.RGBA:
		return image.NewRGBA(bounds)
	case *image.RGBA64:
		return image.NewRGBA64(bounds)
	case *image.YCbCr:
		return image.NewYCbCr(bounds, i.SubsampleRatio)
	}
	panic("Unknown image type")
}

示例#10

文件： imageproxy_test.go 项目： LimiQS/imageproxy

func (t testTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	var raw string

	switch req.URL.Path {
	case "/ok":
		raw = "HTTP/1.1 200 OK\n\n"
	case "/error":
		return nil, errors.New("http protocol error")
	case "/nocontent":
		raw = "HTTP/1.1 204 No Content\n\n"
	case "/etag":
		raw = "HTTP/1.1 200 OK\nEtag: \"tag\"\n\n"
	case "/png":
		m := image.NewNRGBA(image.Rect(0, 0, 1, 1))
		img := new(bytes.Buffer)
		png.Encode(img, m)

		raw = fmt.Sprintf("HTTP/1.1 200 OK\nContent-Length: %d\n\n%s", len(img.Bytes()), img.Bytes())
	default:
		raw = "HTTP/1.1 404 Not Found\n\n"
	}

	buf := bufio.NewReader(bytes.NewBufferString(raw))
	return http.ReadResponse(buf, req)
}

示例#11

文件： swatches.go 项目： jqln-0/colorshow

func createSwatch(col color.Color, size int) image.Image {
	log.Printf("Creating swatch for %v\n", col)
	bounds := image.Rect(0, 0, size, size)
	img := image.NewNRGBA(bounds)
	draw.Draw(img, img.Bounds(), image.NewUniform(col), img.Bounds().Min, draw.Src)
	return img
}

示例#12

文件： main.go 项目： jf/gwp

// cut out the image and return individual channels with image.Image
// no encoding of JPEG
func cut(original image.Image, db *map[string][3]float64, tileSize, x1, y1, x2, y2 int) <-chan image.Image {
	c := make(chan image.Image)
	sp := image.Point{0, 0}
	go func() {
		newimage := image.NewNRGBA(image.Rect(x1, y1, x2, y2))
		for y := y1; y < y2; y = y + tileSize {
			for x := x1; x < x2; x = x + tileSize {
				r, g, b, _ := original.At(x, y).RGBA()
				color := [3]float64{float64(r), float64(g), float64(b)}
				nearest := nearest(color, db)
				file, err := os.Open(nearest)
				if err == nil {
					img, _, err := image.Decode(file)
					if err == nil {
						t := resize(img, tileSize)
						tile := t.SubImage(t.Bounds())
						tileBounds := image.Rect(x, y, x+tileSize, y+tileSize)
						draw.Draw(newimage, tileBounds, tile, sp, draw.Src)
					} else {
						fmt.Println("error in decoding nearest", err, nearest)
					}
				} else {
					fmt.Println("error opening file when creating mosaic:", nearest)
				}
				file.Close()
			}
		}
		c <- newimage.SubImage(newimage.Rect)
	}()

	return c
}

示例#13

文件： image.go 项目： gilmae/mandelbrot

func draw_image(filename string, plot_map map[Key]Point, width int, height int, gradient string) {
	build_gradient(gradient)
	fill_palette()

	bounds := image.Rect(0, 0, width, height)

	b := image.NewNRGBA(bounds)
	draw.Draw(b, bounds, image.NewUniform(color.Black), image.ZP, draw.Src)

	for x := 0; x < width; x += 1 {
		for y := 0; y < height; y += 1 {
			var p = plot_map[Key{x, y}]
			b.Set(p.X, p.Y, get_colour(p.Escape))
		}
	}
	file, err := os.Create(filename)
	if err != nil {
		fmt.Println(err)
	}

	if err = jpeg.Encode(file, b, &jpeg.Options{jpeg.DefaultQuality}); err != nil {
		fmt.Println(err)
	}

	if err = file.Close(); err != nil {
		fmt.Println(err)
	}
}

示例#14

文件： adjust.go 项目： ChrisOHu/platform

// AdjustFunc applies the fn function to each pixel of the img image and returns the adjusted image.
//
// Example:
//
// 	dstImage = imaging.AdjustFunc(
// 		srcImage,
// 		func(c color.NRGBA) color.NRGBA {
// 			// shift the red channel by 16
//			r := int(c.R) + 16
//			if r > 255 {
// 				r = 255
// 			}
// 			return color.NRGBA{uint8(r), c.G, c.B, c.A}
// 		}
// 	)
//
func AdjustFunc(img image.Image, fn func(c color.NRGBA) color.NRGBA) *image.NRGBA {
	src := toNRGBA(img)
	width := src.Bounds().Max.X
	height := src.Bounds().Max.Y
	dst := image.NewNRGBA(image.Rect(0, 0, width, height))

	parallel(height, func(partStart, partEnd int) {
		for y := partStart; y < partEnd; y++ {
			for x := 0; x < width; x++ {
				i := y*src.Stride + x*4
				j := y*dst.Stride + x*4

				r := src.Pix[i+0]
				g := src.Pix[i+1]
				b := src.Pix[i+2]
				a := src.Pix[i+3]

				c := fn(color.NRGBA{r, g, b, a})

				dst.Pix[j+0] = c.R
				dst.Pix[j+1] = c.G
				dst.Pix[j+2] = c.B
				dst.Pix[j+3] = c.A
			}
		}
	})

	return dst
}

示例#15

文件： imageRenderer.go 项目： gmacd/rt

func (ir *ImageRenderer) RenderToFile(filename string) {
	img := image.NewNRGBA(image.Rect(0, 0, ir.Width, ir.Height))

	for y := 0; y < ir.Height; y++ {
		for x := 0; x < ir.Width; x++ {
			i := y*ir.Width*4 + x*4
			r := uint8(ir.Pixels[i] * 255.0)
			g := uint8(ir.Pixels[i+1] * 255.0)
			b := uint8(ir.Pixels[i+2] * 255.0)
			a := uint8(ir.Pixels[i+3] * 255.0)
			c := color.NRGBA{r, g, b, a}

			img.Set(x, y, c)
		}
	}

	imgWriter, _ := os.Create(filename)
	defer imgWriter.Close()

	var err error
	switch filepath.Ext(filename) {
	case ".png":
		err = png.Encode(imgWriter, img)
	case ".jpg", ".jpeg":
		err = jpeg.Encode(imgWriter, img, &jpeg.Options{Quality: jpeg.DefaultQuality})
	}

	if err != nil {
		fmt.Printf("Error writing out %v: %v", filename, err)
	}
}

示例#16

文件： font.go 项目： Kunde21/engi

func (f *Font) Render(text string) *Texture {
	width, height, yBearing := f.TextDimensions(text)
	font := f.ttf
	size := f.Size

	// Colors
	fg := image.NewUniform(color.NRGBA{f.FG.R, f.FG.G, f.FG.B, f.FG.A})
	bg := image.NewUniform(color.NRGBA{f.BG.R, f.BG.G, f.BG.B, f.BG.A})

	// Create the font context
	c := freetype.NewContext()

	nrgba := image.NewNRGBA(image.Rect(0, 0, width, height))
	draw.Draw(nrgba, nrgba.Bounds(), bg, image.ZP, draw.Src)

	c.SetDPI(dpi)
	c.SetFont(font)
	c.SetFontSize(size)
	c.SetClip(nrgba.Bounds())
	c.SetDst(nrgba)
	c.SetSrc(fg)

	// Draw the text.
	pt := freetype.Pt(0, int(yBearing))
	_, err := c.DrawString(text, pt)
	if err != nil {
		log.Println(err)
		return nil
	}

	// Create texture
	imObj := &ImageObject{nrgba}
	return NewTexture(imObj)

}

示例#17

文件： imageio.go 项目： rweyrauch/gopbrt

func writeImagePng(filename string, pixels []float32, xres, yres int) {
	outImage := image.NewNRGBA(image.Rect(0, 0, xres, yres))

	to_byte := func(v float32) uint8 {
		// apply gamma and convert to 0..255
		return uint8(Clamp(255.0*math.Pow(float64(v), 1.0/2.2), 0.0, 255.0))
	}

	for y := 0; y < yres; y++ {
		for x := 0; x < xres; x++ {
			var fcolor color.NRGBA
			fcolor.R = to_byte(pixels[3*(y*xres+x)+0])
			fcolor.G = to_byte(pixels[3*(y*xres+x)+1])
			fcolor.B = to_byte(pixels[3*(y*xres+x)+2])
			fcolor.A = 0xff
			outImage.Set(x, y, fcolor)
		}
	}
	f, err := os.Create(filename)
	defer f.Close()

	if err != nil {
		Error("Error writing PNG \"%s\"", filename)
	} else {
		png.Encode(f, outImage)
	}
}

示例#18

文件： resample.go 项目： hamstah/imaging

// fast nearest-neighbor resize, no filtering
func resizeNearest(src *image.NRGBA, width, height int) *image.NRGBA {
	dstW, dstH := width, height

	srcBounds := src.Bounds()
	srcW := srcBounds.Max.X
	srcH := srcBounds.Max.Y

	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))

	dx := float64(srcW) / float64(dstW)
	dy := float64(srcH) / float64(dstH)

	Parallel(dstH, func(partStart, partEnd int) {

		for dstY := partStart; dstY < partEnd; dstY++ {
			fy := (float64(dstY)+0.5)*dy - 0.5

			for dstX := 0; dstX < dstW; dstX++ {
				fx := (float64(dstX)+0.5)*dx - 0.5

				srcX := int(math.Min(math.Max(math.Floor(fx+0.5), 0.0), float64(srcW)))
				srcY := int(math.Min(math.Max(math.Floor(fy+0.5), 0.0), float64(srcH)))

				srcOff := srcY*src.Stride + srcX*4
				dstOff := dstY*dst.Stride + dstX*4

				copy(dst.Pix[dstOff:dstOff+4], src.Pix[srcOff:srcOff+4])
			}
		}

	})

	return dst
}

示例#19

文件： convolution.go 项目： tcsc/squaddie

func convolve(img *plugin.MMapImage, matrix Matrix) {
	bounds := img.Bounds()
	height := bounds.Dy()
	width := bounds.Dx()
	out := image.NewNRGBA(img.Bounds())

	log.Info("Convolving with %d x %d image", width, height)
	mwOn2 := matrix.width / 2
	mhOn2 := matrix.height / 2
	for py := 0; py < height; py++ {
		for px := 0; px < width; px++ {
			var r, g, b int
			for y := 0; y < matrix.height; y++ {
				dy := y - mhOn2
				for x := 0; x < matrix.width; x++ {
					dx := x - mwOn2
					coef := matrix.At(x, y)
					p := img.NRGBAAt(px+dx, py+dy)
					r += (coef * int(p.R))
					g += (coef * int(p.G))
					b += (coef * int(p.B))
				}
			}

			out.SetNRGBA(px, py, nrgba(r, g, b, 255))
		}
	}

	// memcpy the result back over the input buffer
	copy(img.Pix(), out.Pix)
}

示例#20

文件： qrcoded.go 项目： Catorpilor/go_tdd

func GenerateQRCode(w io.Writer, code string, version Version) error {
	size := version.MappedSize()
	img := image.NewNRGBA(image.Rect(0, 0, size, size))
	//buf := new(bytes.Buffer)
	return png.Encode(w, img)
	//return buf.Bytes()
}

示例#21

文件： effects.go 项目： ChrisOHu/platform

// Sharpen produces a sharpened version of the image.
// Sigma parameter must be positive and indicates how much the image will be sharpened.
//
// Usage example:
//
//		dstImage := imaging.Sharpen(srcImage, 3.5)
//
func Sharpen(img image.Image, sigma float64) *image.NRGBA {
	if sigma <= 0 {
		// sigma parameter must be positive!
		return Clone(img)
	}

	src := toNRGBA(img)
	blurred := Blur(img, sigma)

	width := src.Bounds().Max.X
	height := src.Bounds().Max.Y
	dst := image.NewNRGBA(image.Rect(0, 0, width, height))

	parallel(height, func(partStart, partEnd int) {
		for y := partStart; y < partEnd; y++ {
			for x := 0; x < width; x++ {
				i := y*src.Stride + x*4
				for j := 0; j < 4; j++ {
					k := i + j
					val := int(src.Pix[k]) + (int(src.Pix[k]) - int(blurred.Pix[k]))
					if val < 0 {
						val = 0
					} else if val > 255 {
						val = 255
					}
					dst.Pix[k] = uint8(val)
				}
			}
		}
	})

	return dst
}

示例#22

文件： resize.go 项目： train860/picfit

func resizeHorizontal(src *image.NRGBA, width int, filter ResampleFilter) *image.NRGBA {
	srcBounds := src.Bounds()
	srcW := srcBounds.Max.X
	srcH := srcBounds.Max.Y

	dstW := width
	dstH := srcH

	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))

	weights := precomputeWeights(dstW, srcW, filter)

	parallel(dstH, func(partStart, partEnd int) {
		for dstY := partStart; dstY < partEnd; dstY++ {
			for dstX := 0; dstX < dstW; dstX++ {
				var c [4]int32
				for _, iw := range weights[dstX].iwpairs {
					i := dstY*src.Stride + iw.i*4
					c[0] += int32(src.Pix[i+0]) * iw.w
					c[1] += int32(src.Pix[i+1]) * iw.w
					c[2] += int32(src.Pix[i+2]) * iw.w
					c[3] += int32(src.Pix[i+3]) * iw.w
				}
				j := dstY*dst.Stride + dstX*4
				sum := weights[dstX].wsum
				dst.Pix[j+0] = clampint32(int32(float32(c[0])/float32(sum) + 0.5))
				dst.Pix[j+1] = clampint32(int32(float32(c[1])/float32(sum) + 0.5))
				dst.Pix[j+2] = clampint32(int32(float32(c[2])/float32(sum) + 0.5))
				dst.Pix[j+3] = clampint32(int32(float32(c[3])/float32(sum) + 0.5))
			}
		}
	})

	return dst
}

示例#23

文件： image.go 项目： hanslovsky/dvid

// Interpolate 4 interleaved uint8 per pixel images.
func interpolate4x8(src *image.NRGBA, dstW, dstH int) image.Image {
	srcRect := src.Bounds()
	srcW := srcRect.Dx()
	srcH := srcRect.Dy()

	ww, hh := uint64(dstW), uint64(dstH)
	dx, dy := uint64(srcW), uint64(srcH)

	n, sum := dx*dy, make([]uint64, 4*dstW*dstH)
	for y := 0; y < srcH; y++ {
		pixOffset := src.PixOffset(0, y)
		for x := 0; x < srcW; x++ {
			// Get the source pixel.
			r64 := uint64(src.Pix[pixOffset+0])
			g64 := uint64(src.Pix[pixOffset+1])
			b64 := uint64(src.Pix[pixOffset+2])
			a64 := uint64(src.Pix[pixOffset+3])
			pixOffset += 4
			// Spread the source pixel over 1 or more destination rows.
			py := uint64(y) * hh
			for remy := hh; remy > 0; {
				qy := dy - (py % dy)
				if qy > remy {
					qy = remy
				}
				// Spread the source pixel over 1 or more destination columns.
				px := uint64(x) * ww
				index := 4 * ((py/dy)*ww + (px / dx))
				for remx := ww; remx > 0; {
					qx := dx - (px % dx)
					if qx > remx {
						qx = remx
					}
					qxy := qx * qy
					sum[index+0] += r64 * qxy
					sum[index+1] += g64 * qxy
					sum[index+2] += b64 * qxy
					sum[index+3] += a64 * qxy
					index += 4
					px += qx
					remx -= qx
				}
				py += qy
				remy -= qy
			}
		}
	}
	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
	for y := 0; y < dstH; y++ {
		pixOffset := dst.PixOffset(0, y)
		for x := 0; x < dstW; x++ {
			dst.Pix[pixOffset+0] = uint8(sum[pixOffset+0] / n)
			dst.Pix[pixOffset+1] = uint8(sum[pixOffset+1] / n)
			dst.Pix[pixOffset+2] = uint8(sum[pixOffset+2] / n)
			dst.Pix[pixOffset+3] = uint8(sum[pixOffset+3] / n)
			pixOffset += 4
		}
	}
	return dst
}

示例#24

文件： helpers.go 项目： maleck13/locals-api

// New creates a new image with the specified width and height, and fills it with the specified color.
func New(width, height int, fillColor color.Color) *image.NRGBA {
	if width <= 0 || height <= 0 {
		return &image.NRGBA{}
	}

	dst := image.NewNRGBA(image.Rect(0, 0, width, height))
	c := color.NRGBAModel.Convert(fillColor).(color.NRGBA)

	if c.R == 0 && c.G == 0 && c.B == 0 && c.A == 0 {
		return dst
	}

	cs := []uint8{c.R, c.G, c.B, c.A}

	// fill the first row
	for x := 0; x < width; x++ {
		copy(dst.Pix[x*4:(x+1)*4], cs)
	}
	// copy the first row to other rows
	for y := 1; y < height; y++ {
		copy(dst.Pix[y*dst.Stride:y*dst.Stride+width*4], dst.Pix[0:width*4])
	}

	return dst
}

示例#25

文件： cacphtcode.go 项目： yunkaiyueming/go_code

func NewImage(digits []byte, width, height int) *Image {
	img := new(Image)
	r := image.Rect(img.width, img.height, stdWidth, stdHeight)
	img.NRGBA = image.NewNRGBA(r)

	img.color = &color.NRGBA{
		uint8(rand.Intn(129)),
		uint8(rand.Intn(129)),
		uint8(rand.Intn(129)),
		0xFF,
	}
	// Draw background (10 random circles of random brightness)
	img.calculateSizes(width, height, len(digits))
	img.fillWithCircles(10, img.dotsize)

	maxx := width - (img.width+img.dotsize)*len(digits) - img.dotsize
	maxy := height - img.height - img.dotsize*2

	x := rnd(img.dotsize*2, maxx)
	y := rnd(img.dotsize*2, maxy)

	// Draw digits.
	for _, n := range digits {
		img.drawDigit(font[n], x, y)
		x += img.width + img.dotsize
	}

	// Draw strike-through line.
	img.strikeThrough()
	return img
}

示例#26

文件： engi_glfw.go 项目： EtienneBruines/engi

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}
}

示例#27

文件： image_test.go 项目： hajimehoshi/ebiten

func BenchmarkCopyImageNRGBA(b *testing.B) {
	img := image.NewNRGBA(image.Rect(0, 0, 4096, 4096))
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		CopyImage(img)
	}
}

示例#28

文件： himawari.go 项目： avinashbot/satellite

// Join the matrix of images into a single image.
func (h Himawari) joinGrid(grid [][]image.Image) image.Image {
	dst := image.NewNRGBA(image.Rect(0, 0, gridSize*h.Depth, gridSize*h.Depth))

	var wg sync.WaitGroup
	for i := range grid {
		for j := range grid[i] {
			if grid[i][j] == nil {
				break
			}
			wg.Add(1)
			go func(i, j int) {
				defer wg.Done()
				// Modification is performed pixel-by-pixel, so async
				// should be fine, theoretically.
				src := grid[i][j]
				sdx, sdy := src.Bounds().Dx(), src.Bounds().Dy()
				rect := image.Rect(
					i*sdx, j*sdy, i*sdx+sdx, j*sdy+sdy,
				)
				draw.Draw(dst, rect, src, image.ZP, draw.Src)
			}(i, j)
		}
	}
	wg.Wait()

	return dst
}

示例#29

文件： escroller.go 项目： EtienneBruines/engi

// generateBackground creates a background of green tiles - might not be the most efficient way to do this
func generateBackground() *ecs.Entity {
	rect := image.Rect(0, 0, int(worldWidth), int(worldHeight))
	img := image.NewNRGBA(rect)
	c1 := color.RGBA{102, 153, 0, 255}
	c2 := color.RGBA{102, 173, 0, 255}
	for i := rect.Min.X; i < rect.Max.X; i++ {
		for j := rect.Min.Y; j < rect.Max.Y; j++ {
			if i%40 > 20 {
				if j%40 > 20 {
					img.Set(i, j, c1)
				} else {
					img.Set(i, j, c2)
				}
			} else {
				if j%40 > 20 {
					img.Set(i, j, c2)
				} else {
					img.Set(i, j, c1)
				}
			}
		}
	}
	bgTexture := engi.NewImageObject(img)
	field := ecs.NewEntity([]string{"RenderSystem"})
	fieldRender := engi.NewRenderComponent(engi.NewTexture(bgTexture), engi.Point{1, 1}, "Background1")
	fieldRender.SetPriority(engi.Background)
	fieldSpace := &engi.SpaceComponent{engi.Point{0, 0}, worldWidth, worldHeight}
	field.AddComponent(fieldRender)
	field.AddComponent(fieldSpace)
	return field
}

示例#30

文件： debugger.go 项目： abarax/gomeboycolor

//IMAGE DUMP FUNCTIONS - SLOPPY CODE!!!!
func SpritesToImage(sprites [40][8][8]types.RGB, w, h int) (*image.NRGBA, error) {
	out := image.NewNRGBA(image.Rect(0, 0, w, h))

	font, err := GetFont("../resources/FreeUniversal-Regular.ttf")
	if err != nil {
		return out, err
	}
	draw.Draw(out, out.Bounds(), &image.Uniform{color.RGBA{200, 200, 200, 255}}, image.ZP, draw.Src)
	DrawTextOnImage("Sprites", font, out, 8, (out.Bounds().Dx()/2)-10, 2)
	plotX, plotY, imgX, imgY := 4, 26, 0, 0

	var spacing int = 8
	for i, spr := range sprites {
		for y := 0; y < 8; y++ {
			for x := 0; x < 8; x++ {
				cr := color.RGBA{spr[y][x].Red, spr[y][x].Green, spr[y][x].Blue, 0xFF}
				out.Set(imgX+plotX, imgY+plotY, cr)
				imgX++
			}
			imgX = 0
			imgY++
		}
		imgY = 0
		DrawTextOnImage(fmt.Sprint(i), font, out, 4, plotX, plotY+12)
		plotX += 8 + spacing
		if plotX >= 490 {
			plotY += 24 + spacing
			plotX = 4
		}
	}
	return out, nil
}