Golang Gray.PixOffset方法代碼示例

func newAtFuncGray(p *image.Gray) AtFunc {
	return func(x, y int) (r, g, b, a uint32) {
		i := p.PixOffset(x, y)
		yy := uint32(p.Pix[i])
		yy |= yy << 8
		return yy, yy, yy, 0xffff
	}
}

// Interpolate uint8/pixel images.
func interpolate1x8(src *image.Gray, 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(src.Pix[pixOffset])
			pixOffset++

			// 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.NewGray(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++ {
			dst.Pix[pixOffset] = uint8(sum[index] / n)
			pixOffset++
			index++
		}
	}
	return dst
}

// grayToY stores the 8x8 region of m whose top-left corner is p in yBlock.
func grayToY(m *image.Gray, p image.Point, yBlock *block) {
	b := m.Bounds()
	xmax := b.Max.X - 1
	ymax := b.Max.Y - 1
	pix := m.Pix
	for j := 0; j < 8; j++ {
		for i := 0; i < 8; i++ {
			idx := m.PixOffset(min(p.X+i, xmax), min(p.Y+j, ymax))
			yBlock[8*j+i] = int32(pix[idx])
		}
	}
}

// Fill in missing pixels
func interpolateMissingPixels(img image.Gray, mask []bool) {
	var wg sync.WaitGroup
	newMask := make([]bool, len(mask), len(mask))
	copy(newMask, mask)
	couldNotFill := false

	imgWidth := img.Bounds().Max.X
	imgHeight := img.Bounds().Max.Y
	for x := 0; x < imgWidth; x++ {
		wg.Add(1)
		go func(x int) {
			for y := 0; y < imgHeight; y++ {
				imgPos := img.PixOffset(x, y)
				if mask[imgPos] == true {
					continue
				}

				var sum int
				cnt := 0

				if x > 0 && mask[imgPos-1] {
					sum += int(img.Pix[imgPos-1])
					cnt++
				}
				if x < imgWidth-1 && mask[imgPos+1] {
					sum += int(img.Pix[imgPos+1])
					cnt++
				}
				if y > 0 && mask[imgPos-img.Stride] {
					sum += int(img.Pix[imgPos-img.Stride])
					cnt++
				}
				if y < imgHeight-1 && mask[imgPos+img.Stride] {
					sum += int(img.Pix[imgPos+img.Stride])
					cnt++
				}
				if cnt != 0 {
					img.Pix[imgPos] = uint8(sum / cnt)
					newMask[imgPos] = true
				} else {
					couldNotFill = true
				}
			}
			wg.Done()
		}(x)
	}

	wg.Wait()
	if couldNotFill {
		interpolateMissingPixels(img, newMask)
	}
}

//AutoCorrelateProjections calculates a cross-correlation of each radial
//projection with itself
func AutoCorrelateProjections(projections image.Gray) []float64 {
	size := projections.Bounds().Size()
	width := size.X
	nbProj := size.Y

	out := make([]float64, nbProj*width)

	// for each projection
	for θ := 0; θ < nbProj; θ++ {
		// log.Println("θ:", θ)
		left := projections.PixOffset(0, θ)
		right := projections.PixOffset(width, θ)
		projection := projections.Pix[left:right]
		out = append(out, AutoCorrelateSeries(projection)...)
	}

	return out
}

func meanVertical(src image.Gray, radius int) (dst image.Gray) {
	var wg sync.WaitGroup
	norm := float64(radius*2 + 1)
	dst = *image.NewGray(src.Bounds())
	width, height := src.Bounds().Max.X, src.Bounds().Max.Y

	for x := 0; x < width; x++ {
		wg.Add(1)
		go func(x int) {

			total := 0.0

			for ky := -radius; ky <= radius; ky++ {
				total += float64(src.Pix[src.PixOffset(x, inRange(ky, height))])
			}
			dst.Pix[dst.PixOffset(x, 0)] = uint8(total / norm)

			for y := 1; y < height; y++ {
				total -= float64(src.Pix[src.PixOffset(x, inRange(y-radius-1, height))])
				total += float64(src.Pix[src.PixOffset(x, inRange(y+radius, height))])

				dst.Pix[dst.PixOffset(x, y)] = uint8(total / norm)
			}
			wg.Done()
		}(x)
	}
	wg.Wait()
	return
}

func meanHorizontal(src image.Gray, radius int) (dst image.Gray) {
	var wg sync.WaitGroup
	norm := float64(radius*2 + 1)
	dst = *image.NewGray(src.Bounds())
	width, height := src.Bounds().Max.X, src.Bounds().Max.Y

	for y := 0; y < height; y++ {
		wg.Add(1)
		go func(y int) {
			total := 0.0

			for kx := -radius; kx <= radius; kx++ {
				total += float64(src.Pix[src.PixOffset(inRange(kx, width), y)])
			}
			dst.Pix[dst.PixOffset(0, y)] = uint8(total / norm)

			for x := 1; x < width; x++ {
				total -= float64(src.Pix[src.PixOffset(inRange(x-radius-1, width), y)])
				total += float64(src.Pix[src.PixOffset(inRange(x+radius, width), y)])

				dst.Pix[dst.PixOffset(x, y)] = uint8(total / norm)
			}
			wg.Done()
		}(y)
	}
	wg.Wait()
	return
}

func evaluateGrids(src image.Gray, grids []lineGrid) []lineGrid {
	for _, grid := range grids {
		hCount := len(grid.Horizontal)
		vCount := len(grid.Vertical)
		fragments := make([]lineFragment, hCount+vCount)

		firstVertLine := grid.Vertical[0]
		lastVertLine := grid.Vertical[vCount-1]
		for j, h := range grid.Horizontal {
			_, start := intersection(h, firstVertLine)
			_, end := intersection(h, lastVertLine)
			fragments[j] = lineFragment{start, end}
		}

		firstHorizLine := grid.Horizontal[0]
		lastHorizLine := grid.Horizontal[hCount-1]
		for j, h := range grid.Vertical {
			_, start := intersection(h, firstHorizLine)
			_, end := intersection(h, lastHorizLine)
			fragments[hCount+j] = lineFragment{start, end}
		}

		score := 0.0
		for _, fragment := range fragments {
			points := pointsOnLineFragment(fragment)
			value := 1.0 / fragment.Length()
			for _, point := range points {
				if src.Pix[src.PixOffset(point.X, point.Y)] != 0 {
					score += value
				}
			}
		}
		grid.Score = grid.Score * score / float64(len(fragments))
	}

	sort.Sort(lineGridByScore(grids))

	return grids
}

// copies and resizes src into dst's r
func scaleDownTo(dst *image.Gray, r image.Rectangle, src *image.Gray) error {
	if src.Bounds().Dx()%r.Dx() != 0 || src.Bounds().Dy()%r.Dy() != 0 {
		return errors.New("Source image size not multiple of rectagle size")
	}

	dx := src.Bounds().Dx() / r.Dx()
	dy := src.Bounds().Dy() / r.Dy()
	area := dx * dy
	for y := r.Min.Y; y < r.Max.Y; y++ {
		for x := r.Min.X; x < r.Max.X; x++ {
			col := 0
			for v := 0; v < dy; v++ {
				for u := 0; u < dx; u++ {
					offset := src.PixOffset((x-r.Min.X)*dx+u, (y-r.Min.Y)*dy+v)
					col += int(src.Pix[offset])
				}
			}
			dst.SetGray(x, y, color.Gray{uint8(col / area)})
		}
	}
	return nil
}

func (p *perspectiveTrasnformation) warpPerspective(src image.Gray) image.Gray {
	var wg sync.WaitGroup
	maxX := 0.0
	maxY := 0.0
	for _, p := range p.dstPoints {
		maxX = math.Max(maxX, p.X)
		maxY = math.Max(maxY, p.Y)
	}
	dst := *image.NewGray(image.Rect(0, 0, int(maxX), int(maxY)))
	mask := make([]bool, len(dst.Pix), len(dst.Pix))

	srcWidth := src.Bounds().Max.X
	srcHeight := src.Bounds().Max.Y
	for x := 0; x < srcWidth; x++ {
		wg.Add(1)
		go func(x int) {
			for y := 0; y < srcHeight; y++ {
				newX, newY := p.Project(float64(x), float64(y))
				if newX < 0 || newX >= maxX || newY < 0 || newY >= maxY {
					continue
				}

				g := src.Pix[src.PixOffset(x, y)]

				dstPos := dst.PixOffset(int(newX), int(newY))
				dst.Pix[dstPos] = g
				mask[dstPos] = true
			}
			wg.Done()
		}(x)
	}

	wg.Wait()
	interpolateMissingPixels(dst, mask)
	return dst
}

func sdfize(img *image.Gray) {
	w := img.Bounds().Size().X
	h := img.Bounds().Size().Y
	g1 := make([]xys, w*h)
	g2 := make([]xys, w*h)

	for y := 0; y < h; y++ {
		for x := 0; x < w; x++ {
			a := img.Pix[img.PixOffset(x, y)]
			if a < 0x7F {
				g2[y*w+x] = infinity
			} else {
				g1[y*w+x] = infinity
			}
		}
	}

	generateSDF(int16(w), int16(h), g1)
	generateSDF(int16(w), int16(h), g2)

	for y := 0; y < h; y++ {
		for x := 0; x < w; x++ {
			pos := y*w + x
			dist1 := distance(g1[pos].x, g1[pos].y)
			dist2 := distance(g2[pos].x, g2[pos].y)
			dist := 2 * 128 * (dist1 - dist2) / float64(w)
			if dist < -128 {
				dist = -128
			} else if dist > 127 {
				dist = 127
			}
			c := uint8(128 + dist)
			img.SetGray(x, y, color.Gray{c})
		}
	}
}

// Scale the source image down to the destination image.
// Preserves aspect ratio, leaving unused destination pixels untouched.
// At present it just uses a simple box filter.
// It might be possible to improve performance and clarity by making all
// pixel fractions 1/16 and using essentially fixed-point arithmetic.
func scaleDown(src SippImage, dst *image.Gray) {
	srcRect := src.Bounds()
	dstRect := dst.Bounds()
	//fmt.Println("srcRect:<", srcRect, ">")
	//fmt.Println("dstRect:<", dstRect, ">")

	srcWidth := srcRect.Dx()
	srcHeight := srcRect.Dy()
	dstWidth := dstRect.Dx()
	dstHeight := dstRect.Dy()
	//fmt.Println("srcWidth:<", srcWidth, ">")
	//fmt.Println("srcHeight:<", srcHeight, ">")
	//fmt.Println("dstWidth:<", dstWidth, ">")
	//fmt.Println("dstHeight:<", dstHeight, ">")

	srcAR := float64(srcWidth) / float64(srcHeight)
	dstAR := float64(dstWidth) / float64(dstHeight)
	//fmt.Println("srcAR:<", srcAR, ">")
	//fmt.Println("dstAR:<", dstAR, ">")

	var scale float64
	var outWidth int
	var outHeight int
	if srcAR < dstAR {
		// scale vertically and use a horizontal offset
		scale = float64(srcHeight) / float64(dstHeight)
		outWidth = int(float64(srcWidth) / scale)
		outHeight = dstHeight
		//fmt.Println("Scaling vertically")
	} else {
		// scale horizontally and use a vertical offset
		scale = float64(srcWidth) / float64(dstWidth)
		outHeight = int(float64(srcHeight) / scale)
		outWidth = dstWidth
		//fmt.Println("Scaling horizontally")
	}
	//fmt.Println("scale:<", scale, ">")
	//fmt.Println("outWidth:<", outWidth, ">")
	//fmt.Println("outHeight:<", outHeight, ">")

	// One of the following will be 0.
	hoff := (dstWidth - outWidth) / 2
	voff := (dstHeight - outHeight) / 2

	// Scale 16-bit images down to 8. We incour the cost spuriously for 8-bit
	// images so that we can access the source polymorphically.
	var scaleBpp float64 = 1.0
	if src.Bpp() == 16 {
		scaleBpp = 1.0 / 256.0
	}

	//fmt.Println("scaleBpp:", scaleBpp)

	hfilter := preComputeFilter(scale, outWidth, srcWidth, scaleBpp)

	intrm := image.NewGray(image.Rect(0, 0, outWidth, srcHeight))

	for inty := 0; inty < srcHeight; inty++ {
		// Apply the filter to the source row, generating an intermediate row
		for intx := 0; intx < outWidth; intx++ {
			var val float64
			for i := 0; i < hfilter[intx].n; i++ {
				val = val + src.Val(hfilter[intx].idx+i, inty)*hfilter[intx].weights[i]
			}
			val = math.Floor(val + 0.5)
			if val > 255.0 {
				intrm.Pix[intrm.PixOffset(intx, inty)] = 255
			} else {
				intrm.Pix[intrm.PixOffset(intx, inty)] = uint8(val)
			}
		}
	}

	vfilter := preComputeFilter(scale, outHeight, srcHeight, 1.0)

	for outx := 0; outx < outWidth; outx++ {
		// Apply the filter to the intermediate column, generating an output column
		for outy := 0; outy < outHeight; outy++ {
			var val float64
			for i := 0; i < vfilter[outy].n; i++ {
				index := intrm.PixOffset(outx, vfilter[outy].idx+i)
				val = val + float64(intrm.Pix[index])*vfilter[outy].weights[i]
			}
			dst.Pix[dst.PixOffset(outx+hoff, outy+voff)] = uint8(math.Floor(val + 0.5))
		}
	}
}

func newSetFuncGray(p *image.Gray) SetFunc {
	return func(x, y int, r, g, b, a uint32) {
		i := p.PixOffset(x, y)
		p.Pix[i] = uint8(((299*r + 587*g + 114*b + 500) / 1000) >> 8)
	}
}

func houghLines(src image.Gray, thetas []float64, threshold uint64, limit int) []polarLine {
	if thetas == nil {
		thetas = generateThetas(-math.Pi/2, math.Pi/2, math.Pi/180.0)
	}
	maxY, maxX := src.Bounds().Max.Y, src.Bounds().Max.X
	maxR := 2 * math.Hypot(float64(maxX), float64(maxY))
	offset := maxR / 2

	hAcc := make([][]uint64, int(maxR), int(maxR))
	for i := range hAcc {
		hAcc[i] = make([]uint64, len(thetas), len(thetas))
	}

	sin := make([]float64, len(thetas), len(thetas))
	cos := make([]float64, len(thetas), len(thetas))
	for i, th := range thetas {
		sin[i] = math.Sin(th)
		cos[i] = math.Cos(th)
	}

	var wg sync.WaitGroup
	for y := 0; y < maxY; y++ {
		wg.Add(1)
		go func(y int) {
			for x := 0; x < maxX; x++ {
				val := src.Pix[src.PixOffset(x, y)]
				if val == 0 {
					continue
				}

				for i := range thetas {
					r := float64(x)*cos[i] + float64(y)*sin[i]
					iry := int(r + offset)
					atomic.AddUint64(&hAcc[iry][i], 1)
				}
			}
			wg.Done()
		}(y)
	}
	wg.Wait()

	linesSet := make(map[string]bool)
	var lines []polarLine
	for i := range hAcc {
		r := i - int(offset)
		thetaOffset := 0.0
		if r < 0 {
			thetaOffset = math.Pi
			r *= -1
		}
		for j, count := range hAcc[i] {
			if count < 2 || count < threshold {
				continue
			}

			line := polarLine{
				Theta:    thetas[j] + thetaOffset,
				Distance: r,
				Count:    count,
			}
			hash := line.HashKey()
			if !linesSet[hash] {
				linesSet[hash] = true
				lines = append(lines, line)
			}
		}
	}

	sort.Sort(polarLinesByCount(lines))

	if limit > 0 && len(lines) > limit {
		lines = lines[:limit]
	}

	return lines
}