Golang NRGBA.A方法代碼示例

func hexToColorNRGBA(hex string) color.NRGBA {
	c := color.NRGBA{}

	getIntensity := func(str string) uint8 {
		if u, err := hexToUint8(str); err == nil {
			return u
		}

		return 0
	}

	if len(hex) >= 6 {
		c.R = getIntensity(hex[0:2])
		c.G = getIntensity(hex[2:4])
		c.B = getIntensity(hex[4:6])
	}

	if len(hex) == 8 {
		c.A = getIntensity(hex[6:8])
	} else {
		c.A = 255
	}

	return c
}

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

// Palette returns Palette if any.
func (cfg *Config) Palette() color.Palette {
	if cfg.ColorMode != ColorModeIndexed {
		return nil
	}

	// http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577409_38034
	// 0x0417(1046) | (Photoshop 6.0) Transparency Index.
	//                2 bytes for the index of transparent color, if any.
	transparentColorIndex := -1
	if r, ok := cfg.Res[0x0417]; ok {
		transparentColorIndex = int(readUint16(r.Data, 0))
	}
	pal := make(color.Palette, len(cfg.ColorModeData)/3)
	for i := range pal {
		c := color.NRGBA{
			cfg.ColorModeData[i],
			cfg.ColorModeData[i+256],
			cfg.ColorModeData[i+512],
			0xFF,
		}
		if i == transparentColorIndex {
			c.A = 0
		}
		pal[i] = c
	}
	return pal
}

func Decode(r io.Reader) (outImage image.Image, err error) {
	b := make([]byte, 128)

	if _, err = io.ReadFull(r, b); err != nil {
		return
	} else if b[2] != 1 || b[3] != 8 {
		err = ErrFormat
		return
	}

	w := int(LittleEndian.Uint16(b[8:])) + 1
	h := int(LittleEndian.Uint16(b[10:])) + 1

	var p []byte
	if p, err = ioutil.ReadAll(r); len(p) < 769 || p[len(p)-769] != 12 {
		err = ErrFormat
		return
	}

	b = p
	p = p[len(p)-768:]

	palette := make(color.Palette, 0)
	for i := 0; i < 256; i++ {
		o := i * 3
		color := color.NRGBA{p[o+0], p[o+1], p[o+2], 0xff}
		if color.R == 0x9f && color.G == 0x5b && color.B == 0x53 {
			color.A = 0
		}
		palette = append(palette, color)
	}

	pix := make([]byte, w*h)
	i := 0
	for y := 0; y < h; y++ {
		for x := 0; x < w; {
			data := b[i]
			i++

			if data&0xc0 == 0xc0 {
				runLen := data & 0x3f
				data = b[i]
				i++
				for ; runLen > 0; runLen-- {
					pix[x+y*w] = data
					x++
				}
			} else {
				pix[x+y*w] = data
				x++
			}
		}
	}

	outImage = &image.Paletted{
		Pix:     pix,
		Stride:  w,
		Rect:    image.Rect(0, 0, w, h),
		Palette: palette,
	}

	return
}

// Decode decodes a Half-Life image.
func Decode(r io.Reader) (outImage image.Image, err error) {
	b := make([]byte, 40)

	if _, err = io.ReadFull(r, b); err != nil {
		return
	}

	name := string(bytes.ToLower(b[:bytes.IndexByte(b[:16], 0)]))
	width := int(LittleEndian.Uint32(b[16:]))
	height := int(LittleEndian.Uint32(b[20:]))
	dataOff := int(LittleEndian.Uint32(b[24:]))

	if dataOff == 0 {
		outImage = &HLTex{
			&image.Paletted{
				Pix:     nil,
				Stride:  width,
				Rect:    image.Rect(0, 0, width, height),
				Palette: nil,
			},
			name,
		}
		return
	} else if dataOff < len(b) {
		err = ErrFormat
		return
	}

	var palOff int

	if palOff = int(LittleEndian.Uint32(b[36:])); palOff != 0 {
		palOff += width * height / 64
	} else if palOff = int(LittleEndian.Uint32(b[32:])); palOff != 0 {
		palOff += width * height / 16
	} else if palOff = int(LittleEndian.Uint32(b[28:])); palOff != 0 {
		palOff += width * height / 4
	} else {
		palOff = dataOff + width*height
	}

	dataOff -= len(b)
	palOff -= len(b)

	var size int
	b = make([]byte, palOff+2+256*3)
	if size, err = r.Read(b); err != nil {
		return
	} else if size < palOff+2 {
		err = ErrFormat
		return
	}

	palSize := int(LittleEndian.Uint16(b[palOff:]))
	palOff += 2
	if palSize > 256 || size < palOff+palSize {
		err = ErrFormat
		return
	}

	palette := make(color.Palette, 0)
	for i := 0; i < palSize; i++ {
		o := i * 3
		color := color.NRGBA{b[palOff+o+0], b[palOff+o+1], b[palOff+o+2], 0xff}
		if color.R == color.G && color.G == 0 && color.B == 0xff {
			color.A = 0
		}
		palette = append(palette, color)
	}

	for i := palSize; i < 256; i++ {
		palette = append(palette, color.NRGBA{0, 0, 0, 0})
	}

	outImage = &HLTex{
		&image.Paletted{
			Pix:     b[dataOff : dataOff+width*height],
			Stride:  width,
			Rect:    image.Rect(0, 0, width, height),
			Palette: palette,
		},
		name,
	}

	return
}