Golang color.RGBA函數代碼示例

func ToVector(filename string) eigenface.FaceVector {
	im := readImage(filename)

	face := eigenface.FaceVector{
		Width:  im.Bounds().Max.X - im.Bounds().Min.X,
		Height: im.Bounds().Max.Y - im.Bounds().Min.Y,
	}
	face.Pixels = make([]float64, face.Width*face.Height)
	minX := im.Bounds().Min.X
	minY := im.Bounds().Min.Y

	// iterate through image row by row
	for y := 0; y < face.Height; y++ {
		for x := 0; x < face.Width; x++ {
			color := im.At(x-minX, y-minY)
			// ORL database images are 16-bit grayscale, so can use any of RGB values
			value, _, _, _ := color.RGBA()
			face.Pixels[(y*face.Width)+x] = float64(value)
		}
	}
	return face
}

func (t *qmlfrontend) DefaultFg() color.RGBA {
	c := scheme.Spice(&render.ViewRegions{})
	c.Foreground.A = 0xff
	return color.RGBA(c.Foreground)
}

func (t *tbfe) DefaultBg() color.RGBA {
	c := scheme.Spice(&render.ViewRegions{})
	c.Background.A = 0xff
	return color.RGBA(c.Background)
}

func MakeBamFromGif(animation *gif.GIF, sequences []image.Point) (*BAM, error) {
	maxHeight, maxWidth := 0, 0

	for _, img := range animation.Image {
		if img.Bounds().Dy() > maxHeight {
			maxHeight = img.Bounds().Dy()
		}
		if img.Bounds().Dx() > maxWidth {
			maxWidth = img.Bounds().Dx()
		}
	}

	bam := &BAM{Width: maxWidth, Height: maxHeight}
	bam.Frames = make([]BamFrame, len(animation.Image))
	bam.Sequences = make([]BamSequence, len(sequences))
	bam.Image = make([]image.Paletted, len(animation.Image))

	bam.Palette = make([]color.Color, 256)
	currentPaletteEntry := 1
	bam.Palette[0] = color.RGBA{0, 255, 0, 255}

	for idx, img := range animation.Image {
		bam.Frames[idx].Width = uint16(img.Bounds().Dx())
		bam.Frames[idx].Height = uint16(img.Bounds().Dy())
		bam.Frames[idx].CenterX = int16(img.Bounds().Min.X)
		bam.Frames[idx].CenterY = int16(img.Bounds().Min.Y)
		for _, color := range img.Palette {
			if !ColorInPalette(color, bam.Palette) {
				_, _, _, a := color.RGBA()
				if currentPaletteEntry < 256 {
					if a == 0xffff {
						bam.Palette[currentPaletteEntry] = color
						currentPaletteEntry++
					}
				} else {
					log.Printf("WARNING: palette overflow, unable to place %v %d", color, currentPaletteEntry)
				}
			}
		}
	}
	for i := currentPaletteEntry; i < len(bam.Palette); i++ {
		bam.Palette[i] = color.RGBA{0, 0, 0, 0}
	}
	for idx, img := range animation.Image {
		b := img.Bounds()
		rect := image.Rectangle{b.Min, b.Max}
		bam.Image[idx] = *image.NewPaletted(rect, bam.Palette)
		for y := b.Min.Y; y < b.Max.Y; y++ {
			for x := b.Min.X; x < b.Max.X; x++ {
				col := img.At(x, y)
				_, _, _, a := col.RGBA()
				// convert transparent gif pixels to our transparent pixel
				if a == 0 {
					col = bam.Palette[0]
				}
				bam.Image[idx].Set(x, y, bam.Palette.Convert(col))
			}
		}

	}

	for idx, seq := range sequences {
		bam.Sequences[idx].Start = seq.X
		bam.Sequences[idx].Count = seq.Y
		startFrame := seq.X
		for i := seq.X; i < seq.X+seq.Y; i++ {
			bam.SequenceToImage = append(bam.SequenceToImage, int16(startFrame))
			startFrame++
		}
	}

	return bam, nil
}

func (t *tbfe) DefaultBg() color.RGBA {
	c := scheme.Spice(&render.ViewRegions{})
	log4go.Debug("##############################\nHERE! %s\n###################", c)
	c.Background.A = 0xff
	return color.RGBA(c.Background)
}

func (f *frontend) DefaultFg() color.RGBA {
	c := f.colorScheme().Spice(&render.ViewRegions{})
	c.Foreground.A = 0xff
	return color.RGBA(c.Foreground)
}

func newQLimeView(v *backend.View) *QLimeView {
	log4go.Debug("new_QLimeView entered")
	defer log4go.Debug("new_QLimeView exited")
	var ret QLimeView
	ret.Widget = qt5.NewWidget()
	ret.v = v
	ret.Widget.OnPaintEvent(func(ev *qt5.PaintEvent) {
		p := qt5.NewPainter()
		defer p.Close()
		p.Begin(ret)
		b := v.Buffer()
		ps := p.Font().PointSize()

		pen := qt5.NewPen()
		p.SetPen(pen)
		brush := qt5.NewBrush()
		brush.SetStyle(qt5.SolidPattern)
		def := scheme.Settings[0]
		p.SetBrush(brush)
		f := p.Font()
		f.SetFixedPitch(true)
		p.SetFont(f)

		brush.SetColor(color.RGBA(def.Settings["background"]))
		p.DrawRect(ev.Rect())
		is_widget, ok := v.Settings().Get("is_widget", false).(bool)
		is_widget = ok && is_widget
		pen.SetColor(color.RGBA(def.Settings["background"]))
		p.SetPen(pen)

		for y := 0; y < 20; y++ {
			pos := b.TextPoint(y, 0)
			line := b.Line(pos)

			if is_widget {
				p.DrawText(qt5.Point{0, (y + 1) * (ps + 2)}, b.Substr(line))
			} else {
				for line.Contains(pos) {
					scope := primitives.Region{pos, pos}
					sn := v.ScopeName(pos)
					for line.Contains(pos) {
						pos++
						if v.ScopeName(pos) != sn {
							scope.B = pos
							break
						}
					}
					is := line.Intersection(scope)
					c := color.RGBA(def.Settings["foreground"])
					s := scheme.ClosestMatchingSetting(sn)
					if v, ok := s.Settings["foreground"]; ok {
						c = color.RGBA(v)
					}
					pen.SetColor(c)
					p.SetPen(pen)
					_, col := b.RowCol(line.A)
					p.DrawText(qt5.Point{col * ps / 2, (y + 1) * (ps + 2)}, b.Substr(is))
					line.A = is.End()
				}
			}
		}
	})
	ret.Widget.OnResizeEvent(func(ev *qt5.ResizeEvent) {
		if w, ok := v.Settings().Get("is_widget", false).(bool); ok && !w {
			ret.Widget.SetMinimumSize(qt5.Size{600, 100})
		}
	})
	v.Settings().Set("lime.qt.widget", &ret)
	return &ret
}

func Histogram(img image.Image, rect image.Rectangle) ([]int, string) {
	var hist []int
	var pix []uint8
	var colormodel string
	var bounds image.Rectangle
	stride := 0
	n := 0
	switch img := img.(type) {
	case *image.RGBA:
		colormodel = "rgba"
		img = img.SubImage(rect).(*image.RGBA)
		pix = img.Pix
		n = 4
		stride = img.Stride
		bounds = img.Bounds()
	case *image.NRGBA:
		colormodel = "rgba"
		img = img.SubImage(rect).(*image.NRGBA)
		pix = img.Pix
		n = 4
		stride = img.Stride
		bounds = img.Bounds()
	// case *image.RGBA64: -- 16-bit values
	case *image.Gray:
		colormodel = "gray"
		img = img.SubImage(rect).(*image.Gray)
		pix = img.Pix
		n = 1
		stride = img.Stride
		bounds = img.Bounds()
	// case *image.Gray16: -- 16-bit values
	case *image.YCbCr:
		colormodel = "ycbcr"
		hist = HistogramYCbCr(img, rect, false)
		if hist != nil {
			return hist, colormodel
		}
	default:
		colormodel = "other"
	}
	if n > 0 {
		hist = make([]int, n*256)
		for y, o := bounds.Min.Y, 0; y < bounds.Max.Y; y, o = y+1, o+stride {
			for x := 0; x < n*bounds.Dx(); x += n {
				for i := 0; i < n; i++ {
					hist[int(pix[o+x+i])+i*256] += 1
				}
			}
		}
	} else {
		colormodel = "rgb"
		hist = make([]int, 3*256)
		for y := rect.Min.Y; y < rect.Max.Y; y += 1 {
			for x := rect.Min.X; x < rect.Max.X; x += 1 {
				color := img.At(x, y)
				r, g, b, _ := color.RGBA()
				hist[r>>8] += 1
				hist[(g>>8)+256] += 1
				hist[(b>>8)+512] += 1
			}
		}
	}
	return hist, colormodel
}