Esempio n. 1
0
func Contrast(picture *image.Gray, contrast uint8) *image.Gray {
	bounds := picture.Bounds()
	newPic := image.NewGray(bounds)
	average := getAverage(picture)
	for x := 0; x < bounds.Dx(); x++ {
		for y := 0; y < bounds.Dy(); y++ {
			pixel := picture.At(x, y).(color.Gray).Y
			if pixel > average {
				if pixel+contrast < pixel {
					pixel = 0xff
				} else {
					pixel += contrast
				}
			} else if pixel < average {
				if pixel-contrast > pixel {
					pixel = 0x00
				} else {
					pixel -= contrast
				}
			}
			newPic.Set(x, y, color.Gray{pixel})
		}
	}
	return newPic
}
Esempio n. 2
0
func valueAt(img *image.Gray, x, y float32) float32 {
	dx, dy := x/float32(screenWidth), y/float32(screenHeight)
	b := img.Bounds().Max
	px, py := int(dx*float32(b.X)), int(dy*float32(b.Y))
	v := float32(img.At(px, py).(color.Gray).Y) / 255
	return v
}
Esempio n. 3
0
func getAverage(picture *image.Gray) uint8 {
	var sum uint64 = 0
	bounds := picture.Bounds()
	for x := 0; x < bounds.Dx(); x++ {
		for y := 0; y < bounds.Dy(); y++ {
			sum += uint64(picture.At(x, y).(color.Gray).Y)
		}
	}
	return uint8(sum / uint64(bounds.Dx()*bounds.Dy()))
}
Esempio n. 4
0
func GrayImageToMatrix(src image.Gray) (*matrix.Dense, error) {
	bounds := src.Bounds()
	mtx := make([][]float64, bounds.Max.X)
	for x := 0; x < bounds.Max.X; x++ {
		mtx[x] = make([]float64, bounds.Max.Y)
		for y := 0; y < bounds.Max.Y; y++ {
			_, _, b, _ := src.At(x, y).RGBA()
			mtx[x][y] = float64(b)
		}
	}
	return matrix.NewDense(mtx)
}
Esempio n. 5
0
func GrayImageToMatrix(src image.Gray) (*mat64.Dense, error) {
	bounds := src.Bounds()
	rows := bounds.Max.Y
	cols := bounds.Max.X

	mtx := make([]float64, rows*cols)
	for x := 0; x < cols; x++ {
		for y := 0; y < rows; y++ {
			_, _, b, _ := src.At(x, y).RGBA()
			mtx[y*cols+x] = float64(b)
		}
	}
	return mat64.NewDense(rows, cols, mtx), nil
}
Esempio n. 6
0
func (entity *Entity) deviation(model *image.Gray) float64 {
	deviation := 0.0
	actual := entity.render()

	for x := 0; x < entity.width; x++ {
		for y := 0; y < entity.height; y++ {
			actualColor := float64(actual.At(x, y).(color.Gray).Y)
			modelColor := float64(model.At(x, y).(color.Gray).Y)
			dev := actualColor - modelColor
			deviation += dev * dev
		}
	}

	return deviation
}
Esempio n. 7
0
func dctPoint(img image.Gray, u, v, N, M int) float64 {
	sum := 0.0
	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			_, _, b, _ := img.At(i, j).RGBA()
			// sum += math.Cos( ( float64(2*i+1)/float64(2*N) ) * float64( u ) * math.Pi ) *
			//        math.Cos( ( float64(2*j+1)/float64(2*M) ) * float64( v ) * math.Pi ) *
			//        float64(b)

			sum += math.Cos(math.Pi/(float64(N))*(float64(i)+1/2)*float64(u)) *
				math.Cos(math.Pi/(float64(M))*(float64(j)+1/2)*float64(v)) *
				float64(b)
		}
	}
	return sum * ((coefficient(u) * coefficient(v)) / 4.0)
}
Esempio n. 8
0
func average(oldPic *image.Gray) *Picture {
	bounds := oldPic.Bounds()
	newWidth := charWidth * (bounds.Dx() / charWidth)
	newHeight := charHeight * (bounds.Dy() / charHeight)
	newPic := New(newWidth/charWidth, newHeight/charHeight)
	for x := 0; x < newWidth-charWidth; x += charWidth {
		for y := 0; y < newHeight-charHeight; y += charHeight {
			sum := 0
			for i := x; i < x+charWidth; i++ {
				for j := y; j < y+charHeight; j++ {
					sum += int(oldPic.At(i, j).(color.Gray).Y)
				}
			}
			newPic.Set(x/charWidth, y/charHeight, uint8(sum/(charWidth*charHeight)))
		}
	}
	return newPic
}
// kf3 is a generic convolution 3x3 kernel filter that operatates on
// images of type image.Gray from the Go standard image library.
func kf3(k *[9]float64, src, dst *image.Gray) {
	for y := src.Rect.Min.Y; y < src.Rect.Max.Y; y++ {
		for x := src.Rect.Min.X; x < src.Rect.Max.X; x++ {
			var sum float64
			var i int
			for yo := y - 1; yo <= y+1; yo++ {
				for xo := x - 1; xo <= x+1; xo++ {
					if (image.Point{xo, yo}).In(src.Rect) {
						sum += k[i] * float64(src.At(xo, yo).(color.Gray).Y)
					} else {
						sum += k[i] * float64(src.At(x, y).(color.Gray).Y)
					}
					i++
				}
			}
			dst.SetGray(x, y,
				color.Gray{uint8(math.Min(255, math.Max(0, sum)))})
		}
	}
}
Esempio n. 10
0
func addPixelsToGray(src image.Image, sx, sy int, dst image.Gray, dx, dy int) {
	clr := src.At(sx, sy)
	greyColor, _ := color.GrayModel.Convert(clr).(color.Gray)
	dst.Set(dx, dy, color.Gray{dst.At(dx, dy).(color.Gray).Y + greyColor.Y})
}