Пример #1
0
func NewRaytracer(cfg Config) *Raytracer {
	rect := cfg.Images[0].Bounds()
	numCPU := 1

	if cfg.MultiThreaded {
		numCPU = runtime.NumCPU()
		for numCPU%rect.Max.Y != 0 {
			numCPU++
		}
	}

	rt := &Raytracer{
		cfg:        cfg,
		frame:      uint32(cfg.FrameSeed),
		clear:      color.RGBA{0, 0, 0, 255},
		numThreads: numCPU,
		work:       make(chan rtJob, numCPU*2),
	}

	if cfg.Depth {
		rect := cfg.Images[0].Bounds()
		rt.depth = [2]*image.Gray16{image.NewGray16(rect), image.NewGray16(rect)}
	}

	for i := 0; i < numCPU; i++ {
		go rt.workerLoop()
	}

	return rt
}
Пример #2
0
func to_img(brot *[size][size]uint, max uint) {
	gray := image.NewGray16(image.Rect(0, 0, size, size))
	norm_gray := image.NewGray16(image.Rect(0, 0, size, size))
	for x := 0; x < size; x++ {
		for y := 0; y < size; y++ {
			pix := brot[x][y]
			norm := float64(brot[x][y]*4) / float64(max) * 65534
			if norm > 65534 {
				norm = 65534
			}
			if pix > 65534 {
				pix = 65534
			}
			gray.SetGray16(
				x, y,
				color.Gray16{uint16(pix)})
			norm_gray.SetGray16(
				x, y,
				color.Gray16{uint16(norm)})
		}
	}
	w, _ := os.OpenFile("./brot.png", os.O_CREATE|os.O_WRONLY, 0666)
	png.Encode(w, gray)
	n, _ := os.OpenFile("./brot-norm.png", os.O_CREATE|os.O_WRONLY, 0666)
	png.Encode(n, norm_gray)
}
Пример #3
0
// NewDrawableSize returns a new draw.Image with the same type as p and the given bounds.
// If p is not a draw.Image, another type is used.
func NewDrawableSize(p image.Image, r image.Rectangle) draw.Image {
	switch p := p.(type) {
	case *image.RGBA:
		return image.NewRGBA(r)
	case *image.RGBA64:
		return image.NewRGBA64(r)
	case *image.NRGBA:
		return image.NewNRGBA(r)
	case *image.NRGBA64:
		return image.NewNRGBA64(r)
	case *image.Alpha:
		return image.NewAlpha(r)
	case *image.Alpha16:
		return image.NewAlpha16(r)
	case *image.Gray:
		return image.NewGray(r)
	case *image.Gray16:
		return image.NewGray16(r)
	case *image.Paletted:
		pl := make(color.Palette, len(p.Palette))
		copy(pl, p.Palette)
		return image.NewPaletted(r, pl)
	case *image.CMYK:
		return image.NewCMYK(r)
	default:
		return image.NewRGBA(r)
	}
}
Пример #4
0
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")
}
Пример #5
0
func Draw(f Function, re_from, re_to, im_from, im_to float64, pix_size float64) image.Image {
	w := re_to - re_from
	h := im_to - im_from
	if w < 0 || h < 0 {
		panic("negative width or height")
	}

	if pix_size < 0 {
		panic("negative pixel size")
	}

	c := coords{pix_size, complex(re_from, im_from)}

	resx := int(w / pix_size)
	resy := int(h / pix_size)

	m := image.NewGray16(image.Rect(0, 0, resx, resy))

	bounds := m.Bounds()
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			z := c.At(x, y)

			o := Orbit(f, z, 2, 500)

			if o < 0 {
				m.Set(x, y, color.Black)
			} else {
				m.Set(x, y, color.Gray16{uint16(o * 0x10000 / 32)})
			}
		}
	}

	return m
}
Пример #6
0
// Return an image of the grid, with black blocks for true items and
// white blocks for false items, with the given block size and margin.
func (g *BitGrid) ImageWithMargin(blockSize, margin int) image.Image {
	width := blockSize * (2*margin + g.Width())
	height := blockSize * (2*margin + g.Height())
	i := image.NewGray16(image.Rect(0, 0, width, height))
	for y := 0; y < blockSize*margin; y++ {
		for x := 0; x < width; x++ {
			i.Set(x, y, color.White)
			i.Set(x, height-1-y, color.White)
		}
	}
	for y := blockSize * margin; y < height-blockSize*margin; y++ {
		for x := 0; x < blockSize*margin; x++ {
			i.Set(x, y, color.White)
			i.Set(width-1-x, y, color.White)
		}
	}
	for y, w, h := 0, g.Width(), g.Height(); y < h; y++ {
		for x := 0; x < w; x++ {
			x0 := blockSize * (x + margin)
			y0 := blockSize * (y + margin)
			c := color.White
			if g.Get(x, y) {
				c = color.Black
			}
			for dy := 0; dy < blockSize; dy++ {
				for dx := 0; dx < blockSize; dx++ {
					i.Set(x0+dx, y0+dy, c)
				}
			}
		}
	}
	return i
}
Пример #7
0
Файл: icm.go Проект: paddie/icm
func (u *UGM) WriteToFile(path string, img image.Image) {
	// create in memory image based on ICM results matrix
	newImg := image.NewGray16(img.Bounds())
	for x := 0; x < u.X(); x++ {
		for y := 0; y < u.Y(); y++ {
			if u.Node(x, y).X() == -1 {
				newImg.SetGray16(x, y, color.Black)
			} else {
				newImg.SetGray16(x, y, color.White)
			}
		}
	}
	// create/overwrite file to write to
	imgFile, err := os.Create(path)
	if err != nil {
		fmt.Printf("%v", err)
		os.Exit(1)
	}
	defer imgFile.Close() // close when exiting..

	// write png to file
	if err := png.Encode(imgFile, newImg); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}
Пример #8
0
func EdgesGray16(radius int, img Channel) *image.Gray16 {
	bounds := img.Bounds()
	edgeImage := image.NewGray16(bounds)
	if radius < 1 {
		return edgeImage
	}

	// Compute the horizontal and vertical averages.
	hGA := RowAverageGray16(radius, img)
	vGA := ColumnAverageGray16(radius, img)

	QuickRP(
		AllPointsRP(
			func(pt image.Point) {
				e := float64(hGA.Gray16At(pt.X, pt.Y).Y)
				w := float64(hGA.Gray16At(pt.X-radius+1, pt.Y).Y)
				n := float64(vGA.Gray16At(pt.X, pt.Y).Y)
				s := float64(vGA.Gray16At(pt.X, pt.Y-radius+1).Y)
				edgeImage.Set(pt.X, pt.Y,
					color.Gray16{
						Y: uint16(math.Max(math.Abs(e-w), math.Abs(s-n))), //uint16((math.Abs(e-w) + math.Abs(s-n)) / 2.0),
					},
				)
			},
		),
	)(bounds)

	return edgeImage
}
Пример #9
0
//BackProjectGray computes back projection of img
// in Gray16 by performing an addition
// of backprojection by line.
// 16Gray avoids white noise.
func BackProjectGray(img image.Gray) (*image.Gray16, error) {
	size := img.Bounds().Size()
	width := size.Y
	nbProj := size.X
	step := 180.0 / float64(nbProj)

	out := image.NewGray16(image.Rect(0, 0, width, width))

	for X := 0; X < nbProj; X++ {
		//Extract a 1D-projection (one row Y of sinogram)
		line := img.SubImage(image.Rect(X, 0, X+1, width)).(*image.Gray)

		// 3- Do the backprojection and rotate accordingly
		wideLine := resize.Resize(uint(width), uint(width), line, resize.Lanczos3).(*image.Gray)

		θ := manipulator.Rad(float64(X)*step) + math.Pi/2
		rotatedWideLine := image.NewGray(image.Rect(0, 0, width, width))
		err := graphics.Rotate(rotatedWideLine, wideLine, &graphics.RotateOptions{Angle: θ})
		if err != nil {
			return out, err
		}

		// 4- Add the rotated backprojection in the output image
		for x := 0; x < width; x++ {
			for y := 0; y < width; y++ {
				point := uint16(out.At(x, y).(color.Gray16).Y) + uint16(rotatedWideLine.At(x, y).(color.Gray).Y)
				out.Set(x, y, color.Gray16{uint16(point)})
			}
		}
	}

	return out, nil
}
Пример #10
0
func createRandomImage(maxPaletteSize int) image.Image {
	r := image.Rectangle{Min: image.Point{0, 0}, Max: image.Point{gen.Rand(32) + 1, gen.Rand(32) + 1}}
	var img Image
	switch gen.Rand(10) {
	case 0:
		img = image.NewAlpha(r)
	case 1:
		img = image.NewAlpha16(r)
	case 2:
		img = image.NewCMYK(r)
	case 3:
		img = image.NewGray(r)
	case 4:
		img = image.NewGray16(r)
	case 5:
		img = image.NewNRGBA(r)
	case 6:
		img = image.NewNRGBA64(r)
	case 7:
		img = image.NewPaletted(r, randPalette(maxPaletteSize))
	case 8:
		img = image.NewRGBA(r)
	case 9:
		img = image.NewRGBA64(r)
	default:
		panic("bad")
	}
	fill := gen.Rand(19)
	var palette []color.Color
	if fill == 17 {
		palette = randPalette(maxPaletteSize)
	}
	for y := 0; y < r.Max.Y; y++ {
		for x := 0; x < r.Max.X; x++ {
			switch {
			case fill <= 15:
				img.Set(x, y, color.RGBA64{
					^uint16(0) * uint16((fill>>0)&1),
					^uint16(0) * uint16((fill>>1)&1),
					^uint16(0) * uint16((fill>>2)&1),
					^uint16(0) * uint16((fill>>3)&1),
				})
			case fill == 16:
				img.Set(x, y, randColor())
			case fill == 17:
				img.Set(x, y, palette[gen.Rand(len(palette))])
			case fill == 18:
				if gen.Rand(3) != 0 {
					img.Set(x, y, color.RGBA64{})
				} else {
					img.Set(x, y, randColor())
				}
			default:
				panic("bad")
			}
		}
	}
	return img.(image.Image)
}
Пример #11
0
func setup() {
	w, h := termbox.Size()

	board := image.NewGray16(image.Rect(0, 0, w, h))
	draw.Draw(board, board.Bounds(), &image.Uniform{color.White}, image.ZP, draw.Src)

	ant = &Ant{X: w / 2, Y: h / 2, W: w, H: h, D: direction, B: board}
}
Пример #12
0
// ConvertToGray16 returns an *image.Gray16 instance by asserting the given
// ImageReader has that type or, if it does not, using Copy to concurrently
// set the color.Color values of a new *image.Gray16 instance with the same
// bounds.
func ConvertToGray16(src ImageReader) *image.Gray16 {
	if dst, ok := src.(*image.Gray16); ok {
		return dst
	}
	dst := image.NewGray16(src.Bounds())
	Copy(dst, src)
	return dst
}
Пример #13
0
func tToGray16(m image.Image) *image.Gray16 {
	if p, ok := m.(*image.Gray16); ok {
		return p
	}
	p := image.NewGray16(m.Bounds())
	xdraw.Draw(p, p.Bounds(), m, image.Pt(0, 0), xdraw.Src)
	return p
}
Пример #14
0
func Test_ZeroImg(t *testing.T) {
	zeroImg := image.NewGray16(image.Rect(0, 0, 0, 0))

	m := Resize(0, 0, zeroImg, NearestNeighbor)
	if m.Bounds() != zeroImg.Bounds() {
		t.Fail()
	}
}
Пример #15
0
func Test_CorrectResize(t *testing.T) {
	zeroImg := image.NewGray16(image.Rect(0, 0, 256, 256))

	m := Resize(60, 0, zeroImg, NearestNeighbor)
	if m.Bounds() != image.Rect(0, 0, 60, 60) {
		t.Fail()
	}
}
Пример #16
0
func TestSubImage(t *testing.T) {
	testData := []struct {
		desc string
		img  draw.Image
		ok   bool
	}{
		{
			"sub image (Gray)",
			image.NewGray(image.Rect(0, 0, 10, 10)),
			true,
		},
		{
			"sub image (Gray16)",
			image.NewGray16(image.Rect(0, 0, 10, 10)),
			true,
		},
		{
			"sub image (RGBA)",
			image.NewRGBA(image.Rect(0, 0, 10, 10)),
			true,
		},
		{
			"sub image (RGBA64)",
			image.NewRGBA64(image.Rect(0, 0, 10, 10)),
			true,
		},
		{
			"sub image (NRGBA)",
			image.NewNRGBA(image.Rect(0, 0, 10, 10)),
			true,
		},
		{
			"sub image (NRGBA64)",
			image.NewNRGBA64(image.Rect(0, 0, 10, 10)),
			true,
		},
		{
			"sub image (fake)",
			fakeDrawImage{image.Rect(0, 0, 10, 10)},
			false,
		},
	}

	for _, d := range testData {
		simg, ok := getSubImage(d.img, image.Pt(3, 3))
		if ok != d.ok {
			t.Errorf("test [%s] failed: expected %#v, got %#v", d.desc, d.ok, ok)
		} else if ok {
			simg.Set(5, 5, color.NRGBA{255, 255, 255, 255})
			r, g, b, a := d.img.At(5, 5).RGBA()
			if r != 0xffff || g != 0xffff || b != 0xffff || a != 0xffff {
				t.Errorf("test [%s] failed: expected (0xffff, 0xffff, 0xffff, 0xffff), got (%d, %d, %d, %d)", d.desc, r, g, b, a)
			}
		}
	}

}
Пример #17
0
func convertToGray16QuickDraw(src ImageReader) *image.Gray16 {
	dst := image.NewGray16(src.Bounds())
	QuickRP(
		func(rect image.Rectangle) {
			draw.Draw(dst, rect, src, rect.Min, draw.Over)
		},
	)(src.Bounds())
	return dst
}
Пример #18
0
// WriteGreyImagePng handles writing a Noiser out to a PNG image. It samples
// the noise space in increments specified by noiseSampleDelta. The image is
// generated using multiple goroutines to handle slower methods. It also
// normalizes the image to provide full greyscale values.
//
// The minimum X and minimum Y determine the lower-left point in noise space to
// begin sampling. The number of samples to do in the X and Y directions also
// determines the width and height of the resulting image. Finally, the
// noise sampling delta determines the distance between two sampled points in
// noise space. Setting this parameter to one will yield a black image for
// Perlin Noise.
func WriteGreyImagePng(w io.Writer, noiser Noiser, minX, minY, numberSamplesX, numberSamplesY int, noiseSampleDelta float64) error {
	if numberSamplesX <= 0 || numberSamplesY <= 0 {
		return errors.New("invalid dimensions")
	}

	grays := make([][]float64, numberSamplesY)
	noiseY := float64(minY)
	done := make(chan struct{ MinValue, MaxValue float64 })
	for y := 0; y < numberSamplesY; y++ {
		go func(y int, noiseY float64) {
			grays[y] = make([]float64, numberSamplesX)
			noiseX := float64(minX)
			minValue := 0.0
			maxValue := 0.0
			for x := 0; x < numberSamplesX; x++ {
				grays[y][x] = noiser.Noise(noiseX, noiseY)
				if x == 0 && y == 0 {
					minValue = grays[y][x]
					maxValue = minValue
				} else if grays[y][x] > maxValue {
					maxValue = grays[y][x]
				} else if grays[y][x] < minValue {
					minValue = grays[y][x]
				}
				noiseX += noiseSampleDelta
			}
			done <- struct{ MinValue, MaxValue float64 }{minValue, maxValue}
		}(y, noiseY)
		noiseY += noiseSampleDelta
	}
	minValue := 0.0
	maxValue := 0.0
	for y := 0; y < numberSamplesY; y++ {
		mm := <-done
		if y == 0 {
			minValue = mm.MinValue
			maxValue = mm.MaxValue
		} else if mm.MinValue < minValue {
			minValue = mm.MinValue
		} else if mm.MaxValue > maxValue {
			maxValue = mm.MaxValue
		}
	}
	img := image.NewGray16(image.Rect(0, 0, numberSamplesX, numberSamplesY))

	for y := 0; y < numberSamplesY; y++ {
		for x := 0; x < numberSamplesX; x++ {
			frac := (grays[y][x] - minValue) / (maxValue - minValue)
			uIntVal := uint16(linearInterpolation(0, 65535, frac))
			shade := color.Gray16{uIntVal}
			img.SetGray16(x, numberSamplesY-y-1, shade)
		}
	}

	return png.Encode(w, img)
}
Пример #19
0
// Interpolate uint16/pixel images.
func interpolate1x16(src *image.Gray16, 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, dstW*dstH)
	for y := 0; y < srcH; y++ {
		pixOffset := src.PixOffset(0, y)
		for x := 0; x < srcW; x++ {
			// Get the source pixel.
			val64 := uint64(binary.BigEndian.Uint16([]byte(src.Pix[pixOffset+0 : pixOffset+2])))
			pixOffset += 2

			// 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 := (py/dy)*ww + (px / dx)
				for remx := ww; remx > 0; {
					qx := dx - (px % dx)
					if qx > remx {
						qx = remx
					}
					qxy := qx * qy
					sum[index] += val64 * qxy
					index++
					px += qx
					remx -= qx
				}
				py += qy
				remy -= qy
			}
		}
	}
	dst := image.NewGray16(image.Rect(0, 0, dstW, dstH))
	index := 0
	for y := 0; y < dstH; y++ {
		pixOffset := dst.PixOffset(0, y)
		for x := 0; x < dstW; x++ {
			binary.BigEndian.PutUint16(dst.Pix[pixOffset+0:pixOffset+2], uint16(sum[index]/n))
			pixOffset += 2
			index++
		}
	}
	return dst
}
Пример #20
0
// ToGray16 converts the image to a 16-bit integer gray image.
// Maps [0, 1] to [0, math.MaxUint16].
// Caps to [0, math.MaxUint16].
func ToGray16(f *Image) *image.Gray16 {
	g := image.NewGray16(image.Rect(0, 0, f.Width, f.Height))
	for x := 0; x < f.Width; x++ {
		for y := 0; y < f.Height; y++ {
			v := round(math.MaxUint16 * f.At(x, y))
			v = min(math.MaxUint16, max(0, v))
			g.SetGray16(x, y, color.Gray16{uint16(v)})
		}
	}
	return g
}
Пример #21
0
func convertToGray16QuickAllPoints(src ImageReader) *image.Gray16 {
	dst := image.NewGray16(src.Bounds())
	QuickRP(
		AllPointsRP(
			func(pt image.Point) {
				dst.Set(pt.X, pt.Y, src.At(pt.X, pt.Y))
			},
		),
	)(src.Bounds())
	return dst
}
func ToImage(face eigenface.FaceVector) image.Image {
	bounds := image.Rect(0, 0, face.Width, face.Height)
	im := image.NewGray16(bounds)
	for y := 0; y < face.Height; y++ {
		for x := 0; x < face.Width; x++ {
			// ORL database images are 16-bit grayscale
			value := uint16(face.Pixels[(y*face.Width)+x])
			im.SetGray16(x, y, color.Gray16{value})
		}
	}
	return im
}
Пример #23
0
func TestColorspaceLinearToSRGB(t *testing.T) {
	vals := []float32{
		0.00000,
		0.34919,
		0.48453,
		0.58383,
		0.66519,
		0.73536,
		0.79774,
		0.85431,
		0.90633,
		0.95469,
		1.00000,
	}

	imgs := []draw.Image{
		image.NewGray(image.Rect(0, 0, 11, 11)),
		image.NewGray(image.Rect(0, 0, 111, 111)),
		image.NewGray16(image.Rect(0, 0, 11, 11)),
		image.NewGray16(image.Rect(0, 0, 1111, 1111)),
	}
	for _, img := range imgs {
		for i := 0; i <= 10; i++ {
			img.Set(i, 0, color.Gray{uint8(255 * float32(i) / 10.0)})
		}
		img2 := image.NewGray(img.Bounds())
		New(ColorspaceLinearToSRGB()).Draw(img2, img)
		if !img2.Bounds().Size().Eq(img.Bounds().Size()) {
			t.Errorf("ColorspaceLinearRGBToSRGB bad result size: expected %v got %v", img.Bounds().Size(), img2.Bounds().Size())
		}
		for i := 0; i <= 10; i++ {
			expected := uint8(vals[i]*255.0 + 0.5)
			c := img2.At(i, 0).(color.Gray)
			if math.Abs(float64(c.Y)-float64(expected)) > 1 {
				t.Errorf("ColorspaceLinearRGBToSRGB bad color value at index %v expected %v got %v", i, expected, c.Y)
			}
		}
	}

}
Пример #24
0
func TestColorspaceSRGBToLinear(t *testing.T) {
	vals := []float32{
		0.00000,
		0.01002,
		0.03310,
		0.07324,
		0.13287,
		0.21404,
		0.31855,
		0.44799,
		0.60383,
		0.78741,
		1.00000,
	}

	imgs := []draw.Image{
		image.NewGray(image.Rect(0, 0, 11, 11)),
		image.NewGray(image.Rect(0, 0, 111, 111)),
		image.NewGray16(image.Rect(0, 0, 11, 11)),
		image.NewGray16(image.Rect(0, 0, 1111, 1111)),
	}
	for _, img := range imgs {
		for i := 0; i <= 10; i++ {
			img.Set(i, 0, color.Gray{uint8(255 * float32(i) / 10.0)})
		}
		img2 := image.NewGray(img.Bounds())
		New(ColorspaceSRGBToLinear()).Draw(img2, img)
		if !img2.Bounds().Size().Eq(img.Bounds().Size()) {
			t.Errorf("ColorspaceSRGBToLinear bad result size: expected %v got %v", img.Bounds().Size(), img2.Bounds().Size())
		}
		for i := 0; i <= 10; i++ {
			expected := uint8(vals[i]*255.0 + 0.5)
			c := img2.At(i, 0).(color.Gray)
			if math.Abs(float64(c.Y)-float64(expected)) > 1 {
				t.Errorf("ColorspaceSRGBToLinear bad color value at index %v expected %v got %v", i, expected, c.Y)
			}
		}
	}
}
Пример #25
0
func TestNewPixelGetter(t *testing.T) {
	var img image.Image
	var pg *pixelGetter
	img = image.NewNRGBA(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itNRGBA || pg.imgNRGBA == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter NRGBA")
	}
	img = image.NewNRGBA64(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itNRGBA64 || pg.imgNRGBA64 == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter NRGBA64")
	}
	img = image.NewRGBA(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itRGBA || pg.imgRGBA == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter RGBA")
	}
	img = image.NewRGBA64(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itRGBA64 || pg.imgRGBA64 == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter RGBA64")
	}
	img = image.NewGray(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itGray || pg.imgGray == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter Gray")
	}
	img = image.NewGray16(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itGray16 || pg.imgGray16 == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter Gray16")
	}
	img = image.NewYCbCr(image.Rect(0, 0, 1, 1), image.YCbCrSubsampleRatio422)
	pg = newPixelGetter(img)
	if pg.imgType != itYCbCr || pg.imgYCbCr == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter YCbCr")
	}
	img = image.NewUniform(color.NRGBA64{0, 0, 0, 0})
	pg = newPixelGetter(img)
	if pg.imgType != itGeneric || pg.imgGeneric == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter Generic(Uniform)")
	}
	img = image.NewAlpha(image.Rect(0, 0, 1, 1))
	pg = newPixelGetter(img)
	if pg.imgType != itGeneric || pg.imgGeneric == nil || !img.Bounds().Eq(pg.imgBounds) {
		t.Error("newPixelGetter Generic(Alpha)")
	}
}
Пример #26
0
func convert_to_gray(img image.Image) image.Image {
	width, height := get_image_dims(img)

	gray_img := image.NewGray16(width, height)

	for x := 0; x < width; x++ {
		for y := 0; y < height; y++ {
			r, g, b, _ := img.At(x, y).RGBA()
			avg := (r + g + b) / 3.0
			gray_img.Set(x, y, image.Gray16Color{uint16(avg)})
		}
	}

	return gray_img
}
Пример #27
0
func decodePlainGray16(r io.Reader, c PNMConfig) (image.Image, error) {
	m := image.NewGray16(image.Rect(0, 0, c.Width, c.Height))
	var col uint16

	for y := 0; y < c.Height; y++ {
		for x := 0; x < c.Width; x++ {
			if _, err := fmt.Fscan(r, &col); err != nil {
				return nil, err
			}
			m.Set(x, y, color.Gray16{col})
		}
	}

	return m, nil
}
Пример #28
0
func makeImages(r image.Rectangle) []image.Image {
	return []image.Image{
		image.NewGray(r),
		image.NewGray16(r),
		image.NewNRGBA(r),
		image.NewNRGBA64(r),
		image.NewPaletted(r, somePalette),
		image.NewRGBA(r),
		image.NewRGBA64(r),
		image.NewYCbCr(r, image.YCbCrSubsampleRatio444),
		image.NewYCbCr(r, image.YCbCrSubsampleRatio422),
		image.NewYCbCr(r, image.YCbCrSubsampleRatio420),
		image.NewYCbCr(r, image.YCbCrSubsampleRatio440),
	}
}
Пример #29
0
func imgType(im image.Image, w, h int) imageng {
	var scaled imageng
	switch im.ColorModel() {
	case image.RGBAColorModel:
		scaled = image.NewRGBA(w, h)
	case image.NRGBAColorModel:
		scaled = image.NewNRGBA(w, h)
	case image.GrayColorModel:
		scaled = image.NewGray(w, h)
	case image.Gray16ColorModel:
		scaled = image.NewGray16(w, h)
	default:
		scaled = image.NewRGBA64(w, h)
	}
	return scaled
}
Пример #30
0
func GetChunkImage(chunk [][]float32) *image.Gray16 {

	h := len(chunk)
	w := len(chunk[0])

	img := image.NewGray16(image.Rect(0, 0, h, w))

	for x, r := range chunk {
		for y, v := range r {
			img.SetGray16(x, y, color.Gray16{MapFloat32HeightToGray(v)})

		}
	}

	return img
}