예제 #1
0
// ColorConverter compares a color to another. IF it matches, return
// the new color.
func ColorConverter(c1 color.Color, c2 color.Color) color.Model {
	return color.ModelFunc(func(c color.Color) color.Color {
		cR, cG, cB, cA := c.RGBA()
		c1R, c1G, c1B, c1A := c1.RGBA()
		if cR == c1R && cG == c1G && cB == c1B && cA == c1A {
			return c2
		}
		return c
	})
}
예제 #2
0
파일: rgb.go 프로젝트: edvakf/go-libjpeg
// At implements image.Image.At
func (p *Image) At(x, y int) color.Color {
	return p.RGBAAt(x, y)
}

// RGBAAt returns the color of the pixel at (x, y) as RGBA.
func (p *Image) RGBAAt(x, y int) color.RGBA {
	if !(image.Point{x, y}.In(p.Rect)) {
		return color.RGBA{}
	}
	i := (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*3
	return color.RGBA{p.Pix[i+0], p.Pix[i+1], p.Pix[i+2], 0xFF}
}

// ColorModel is RGB color model instance
var ColorModel = color.ModelFunc(rgbModel)

func rgbModel(c color.Color) color.Color {
	if _, ok := c.(RGB); ok {
		return c
	}
	r, g, b, _ := c.RGBA()
	return RGB{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8)}
}

// RGB color
type RGB struct {
	R, G, B uint8
}

// RGBA implements Color.RGBA
예제 #3
0
파일: 60.go 프로젝트: rei-m/go-tour
func (m Image) ColorModel() color.Model {
	return color.ModelFunc(m.rgbaColor)
}
예제 #4
0
파일: color.go 프로젝트: pombredanne/rand
// 32-bit floating point RGBA color data type.
type Color struct {
	R, G, B, A float32
}

// Implements image/color.Color interface.
func (c Color) RGBA() (r, g, b, a uint32) {
	r = uint32(c.R * fMaxUint16)
	g = uint32(c.G * fMaxUint16)
	b = uint32(c.B * fMaxUint16)
	a = uint32(c.A * fMaxUint16)
	return
}

func colorModel(c color.Color) color.Color {
	if _, ok := c.(Color); ok {
		return c
	}
	r, g, b, a := c.RGBA()
	return Color{
		R: float32(r) / float32(fMaxUint16),
		G: float32(g) / float32(fMaxUint16),
		B: float32(b) / float32(fMaxUint16),
		A: float32(a) / float32(fMaxUint16),
	}
}

// ColorModel represents the graphics color model (i.e. normalized 32-bit
// floating point values RGBA color).
var ColorModel color.Model = color.ModelFunc(colorModel)
예제 #5
0
파일: color.go 프로젝트: spate/glimage
	r |= r >> 8
	g = uint32(c.BGRA) << 8 & 0xf000
	g |= g >> 4
	g |= g >> 8
	b = uint32(c.BGRA) << 12 & 0xf000
	b |= b >> 4
	b |= b >> 8
	a = uint32(c.BGRA) << 0 & 0xf000
	a |= a >> 4
	a |= a >> 8
	return r, g, b, a
}

// Model for RGB565 and BGRA used by Dxt and GL
var (
	BGRAModel     color.Model = color.ModelFunc(bgraModel)
	BGR565Model   color.Model = color.ModelFunc(bgr565Model)
	BGRA5551Model color.Model = color.ModelFunc(bgra5551Model)
	BGRA4444Model color.Model = color.ModelFunc(bgra4444Model)
)

func bgraModel(c color.Color) color.Color {
	if _, ok := c.(BGRA); ok {
		return c
	}
	r, g, b, a := c.RGBA()
	return BGRA{uint8(b >> 8), uint8(g >> 8), uint8(r >> 8), uint8(a >> 8)}
}

func bgr565Model(c color.Color) color.Color {
	if _, ok := c.(BGR565); ok {
예제 #6
0
func ColorModel(channels int, dataType reflect.Kind) color.Model {
	return color.ModelFunc(func(c color.Color) color.Color {
		return colorModelConvert(channels, dataType, c)
	})
}
예제 #7
0
파일: hsl.go 프로젝트: shawnps/kanjihub
// Copyright 2012 The Gorilla Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package color

import (
	"image/color"
	"math"
)

// HSLModel converts any Color to a HSL color.
var HSLModel = color.ModelFunc(hslModel)

// HSL represents a cylindrical coordinate of points in an RGB color model.
//
// Values are in the range 0 to 1.
type HSL struct {
	H, S, L float64
}

// RGBA returns the alpha-premultiplied red, green, blue and alpha values
// for the HSL.
func (c HSL) RGBA() (uint32, uint32, uint32, uint32) {
	r, g, b := HSLToRGB(c.H, c.S, c.L)
	return uint32(r) * 0x101, uint32(g) * 0x101, uint32(b) * 0x101, 0xffff
}

// hslModel converts a Color to HSL.
func hslModel(c color.Color) color.Color {
	if _, ok := c.(HSL); ok {
예제 #8
0
// Its contents can be found in the enclosed LICENSE file.

package framebuffer

import (
	"image"
	"image/color"
)

var RGB555Model = color.ModelFunc(
	func(c color.Color) color.Color {
		if _, ok := c.(RGBColor); ok {
			return c
		}

		r, g, b, _ := c.RGBA()
		return RGBColor{
			uint8(r>>8) & mask5,
			uint8(g>>8) & mask5,
			uint8(b>>8) & mask5,
		}
	})

type RGB555 struct {
	Pix    []byte
	Rect   image.Rectangle
	Stride int
}

func (i *RGB555) Bounds() image.Rectangle { return i.Rect }
func (i *RGB555) ColorModel() color.Model { return RGB555Model }
예제 #9
0
// Its contents can be found in the enclosed LICENSE file.

package framebuffer

import (
	"image"
	"image/color"
)

var RGB565Model = color.ModelFunc(
	func(c color.Color) color.Color {
		if _, ok := c.(RGBColor); ok {
			return c
		}

		r, g, b, _ := c.RGBA()
		return RGBColor{
			uint8(r >> (8 + (8 - 5))),
			uint8(g >> (8 + (8 - 6))),
			uint8(b >> (8 + (8 - 5))),
		}
	})

type RGB565 struct {
	Pix    []byte
	Rect   image.Rectangle
	Stride int
}

func (i *RGB565) Bounds() image.Rectangle { return i.Rect }
func (i *RGB565) ColorModel() color.Model { return RGB565Model }
예제 #10
0
func (s QuantizedColorSlice) Less(i, j int) bool { return uint16(s[i]) < uint16(s[j]) }
func (s QuantizedColorSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

// QuantizedColorGenerator creates a new QuantizedColor from a given red, green, and blue value.
var QuantizedColorGenerator = func(r, g, b uint8) QuantizedColor {
	quantizedRed := quantizeColorValue(r)
	quantizedGreen := quantizeColorValue(g)
	quantizedBlue := quantizeColorValue(b)
	return QuantizedColor((quantizedRed << (quantizeWordWidth + quantizeWordWidth)) | (quantizedGreen << quantizeWordWidth) | quantizedBlue)
}

// QuantizedColorModel is the color.Model for the QuantizedColor type.
var QuantizedColorModel = color.ModelFunc(func(c color.Color) color.Color {
	if _, ok := c.(QuantizedColor); ok {
		return c
	}
	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
	return QuantizedColorGenerator(nrgba.R, nrgba.G, nrgba.B)
})

// QuantizedColor represents a reduced RGB color space.
type QuantizedColor uint16

// RGBA implements the color.Color interface.
func (q QuantizedColor) RGBA() (uint32, uint32, uint32, uint32) {
	r := uint32(q.ApproximateRed())
	r |= r << 8
	g := uint32(q.ApproximateGreen())
	g |= g << 8
	b := uint32(q.ApproximateBlue())
	b |= b << 8
예제 #11
0
파일: color.go 프로젝트: RobCherry/vibrant
}

// PackedRGB is the packed int representing the RGB value (ignores the alpha channel).
func (c RGBAInt) PackedRGB() uint32 {
	return c.PackedRGBA() | (uint32(0xFF) << 24)
}

func (c RGBAInt) String() string {
	return fmt.Sprintf("0x%06s", strings.ToUpper(strconv.FormatUint(uint64(c.PackedRGBA()), 16)))
}

// RGBAIntModel is the color.Model for the RGBAInt type.
var RGBAIntModel = color.ModelFunc(func(c color.Color) color.Color {
	if _, ok := c.(RGBAInt); ok {
		return c
	}
	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
	return RGBAInt((uint32(nrgba.A) << 24) | (uint32(nrgba.R) << 16) | (uint32(nrgba.G) << 8) | uint32(nrgba.B))
})

// HSL represents the HSL value for an RGBA color.
type HSL struct {
	H, S, L float64
	A       uint8
}

// RGBA implements the color.Color interface.
func (c HSL) RGBA() (uint32, uint32, uint32, uint32) {
	r, g, b := hslToRGB(c.H, c.S, c.L)
	return color.NRGBA{r, g, b, c.A}.RGBA()
}
예제 #12
0
	if littleEndian {
		self.Pix[i+0] = c1.B
		self.Pix[i+1] = c1.G
		self.Pix[i+2] = c1.R
	} else {
		self.Pix[i+1] = c1.R
		self.Pix[i+2] = c1.G
		self.Pix[i+3] = c1.B
	}
}

var BGRNColorModel = color.ModelFunc(
	func(c color.Color) color.Color {
		if _, ok := c.(BGRNColor); ok {
			return c
		}
		r, g, b, _ := c.RGBA()
		return BGRNColor{R: uint8(r >> 8), G: uint8(g >> 8), B: uint8(b >> 8)}
	},
)

type BGRNColor struct {
	B, G, R uint8
}

func (c BGRNColor) RGBA() (r, g, b, a uint32) {
	r = uint32(c.R)
	r |= r << 8

	g = uint32(c.G)
	g |= g << 8
예제 #13
0
파일: color.go 프로젝트: zxpbenson/rog-go
func (c Color) ColorModel() color.Model { return color.ModelFunc(toColor) }
예제 #14
0
파일: ycbcr.go 프로젝트: Sunmonds/gcc
func (c YCbCrColor) RGBA() (uint32, uint32, uint32, uint32) {
	r, g, b := YCbCrToRGB(c.Y, c.Cb, c.Cr)
	return uint32(r) * 0x101, uint32(g) * 0x101, uint32(b) * 0x101, 0xffff
}

func toYCbCrColor(c color.Color) color.Color {
	if _, ok := c.(YCbCrColor); ok {
		return c
	}
	r, g, b, _ := c.RGBA()
	y, u, v := RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8))
	return YCbCrColor{y, u, v}
}

// YCbCrColorModel is the color model for YCbCrColor.
var YCbCrColorModel color.Model = color.ModelFunc(toYCbCrColor)

// SubsampleRatio is the chroma subsample ratio used in a YCbCr image.
type SubsampleRatio int

const (
	SubsampleRatio444 SubsampleRatio = iota
	SubsampleRatio422
	SubsampleRatio420
)

// YCbCr is an in-memory image of YCbCr colors. There is one Y sample per pixel,
// but each Cb and Cr sample can span one or more pixels.
// YStride is the Y slice index delta between vertically adjacent pixels.
// CStride is the Cb and Cr slice index delta between vertically adjacent pixels
// that map to separate chroma samples.
예제 #15
0
파일: color.go 프로젝트: jimmyfrasche/cairo
}

//Color returns a without the alpha channel.
func (a AlphaColor) Color() Color {
	return Color{a.R, a.G, a.B}
}

//These models can convert any color.Color to themselves.
//
//The conversion may be lossy.
var (
	ColorModel = color.ModelFunc(func(c color.Color) color.Color {
		if c, ok := c.(Color); ok {
			return c
		}
		if c, ok := c.(AlphaColor); ok {
			return Color{c.R, c.G, c.B}
		}
		r, g, b, _ := c.RGBA()
		return Color{cto01(r), cto01(g), cto01(b)}
	})
	AlphaColorModel = color.ModelFunc(func(c color.Color) color.Color {
		if c, ok := c.(AlphaColor); ok {
			return c
		}
		if c, ok := c.(Color); ok {
			return AlphaColor{c.R, c.G, c.B, 1}
		}
		r, g, b, a := c.RGBA()
		return AlphaColor{cto01(r), cto01(g), cto01(b), cto01(a)}
	})
)
예제 #16
0
파일: rgb.go 프로젝트: gitchander/gofra
	for _, c := range cs {
		r += c.R
		g += c.G
		b += c.B
	}

	k := 1 / float64(len(cs))

	r *= k
	g *= k
	b *= k

	return RGB{r, g, b}
}

var RGBModel = color.ModelFunc(rgbModel)

func rgbModel(c color.Color) color.Color {
	if _, ok := c.(RGB); ok {
		return c
	}
	r, g, b, _ := c.RGBA()
	const k = 1 / float64(math.MaxUint16)
	return RGB{
		R: float64(r) * k,
		G: float64(g) * k,
		B: float64(b) * k,
	}
}
예제 #17
0
파일: color.go 프로젝트: rjkroege/go
		// CIgnore, 8, CRed, 8, CGreen, 8, CBlue, 8
		return color.RGBA{buf[2], buf[1], buf[0], 0xFF}
	case XBGR32:
		// CIgnore, 8, CBlue, 8, CGreen, 8, CRed, 8
		return color.RGBA{buf[0], buf[1], buf[2], 0xFF}
	default:
		panic("unknown color")
	}
}

func (i *Image) Bounds() image.Rectangle {
	return i.Clipr
}

var (
	Gray1Model  color.Model = color.ModelFunc(gray1Model)
	Gray2Model  color.Model = color.ModelFunc(gray2Model)
	Gray4Model  color.Model = color.ModelFunc(gray4Model)
	CMap8Model  color.Model = color.ModelFunc(cmapModel)
	CRGB15Model color.Model = color.ModelFunc(crgb15Model)
	CRGB16Model color.Model = color.ModelFunc(crgb16Model)
)

// Gray1 represents a 1-bit black/white color.
type Gray1 struct {
	White bool
}

func (c Gray1) RGBA() (r, g, b, a uint32) {
	if c.White {
		return 0xffff, 0xffff, 0xffff, 0xffff
예제 #18
0
파일: rgba.go 프로젝트: gitchander/gofra
	b = uint32(math.Floor(c.B * k))
	a = uint32(math.Floor(c.A * k))
	return
}

// Alpha blending
// c = a over b
func (a RGBA) Over(b RGBA) (c RGBA) {
	c.A = lerp(b.A, 1.0, a.A)
	c.R = lerp(b.R*b.A, a.R, a.A) / c.A
	c.G = lerp(b.G*b.A, a.G, a.A) / c.A
	c.B = lerp(b.B*b.A, a.B, a.A) / c.A
	return
}

var RGBAModel = color.ModelFunc(rgbaModel)

func rgbaModel(c color.Color) color.Color {
	if _, ok := c.(RGBA); ok {
		return c
	}
	r, g, b, a := c.RGBA()
	const k = 1 / float64(math.MaxUint16)
	return RGBA{
		R: float64(r) * k,
		G: float64(g) * k,
		B: float64(b) * k,
		A: float64(a) * k,
	}
}
예제 #19
0
파일: hsla.go 프로젝트: surma-dump/img
		r = c
		g = 0
		b = x
	}

	m := l - 0.5*c

	red = uint32(utils.Truncatef((r+m)*a*255)) << 8
	green = uint32(utils.Truncatef((g+m)*a*255)) << 8
	blue = uint32(utils.Truncatef((b+m)*a*255)) << 8
	alpha = uint32(a*255) << 8

	return
}

var HSLAModel color.Model = color.ModelFunc(hslaModel)

func hslaModel(c color.Color) color.Color {
	if _, ok := c.(HSLA); ok {
		return c
	}

	r, g, b, a := utils.RatioRGBA(c)

	maxi := utils.Maxf(r, g, b)
	mini := utils.Minf(r, g, b)
	chroma := maxi - mini

	// Work out hue
	hdash := 0.0
	if chroma == 0 {
예제 #20
0
파일: nycbcra.go 프로젝트: 2722/lantern
type Color struct {
	color.YCbCr
	A uint8
}

func (c Color) RGBA() (r, g, b, a uint32) {
	r8, g8, b8 := color.YCbCrToRGB(c.Y, c.Cb, c.Cr)
	a = uint32(c.A) * 0x101
	r = uint32(r8) * 0x101 * a / 0xffff
	g = uint32(g8) * 0x101 * a / 0xffff
	b = uint32(b8) * 0x101 * a / 0xffff
	return
}

// ColorModel is the Model for non-alpha-premultiplied Y'CbCr-with-alpha colors.
var ColorModel color.Model = color.ModelFunc(nYCbCrAModel)

func nYCbCrAModel(c color.Color) color.Color {
	switch c := c.(type) {
	case Color:
		return c
	case color.YCbCr:
		return Color{c, 0xff}
	}
	r, g, b, a := c.RGBA()

	// Convert from alpha-premultiplied to non-alpha-premultiplied.
	if a != 0 {
		r = (r * 0xffff) / a
		g = (g * 0xffff) / a
		b = (b * 0xffff) / a
예제 #21
0
파일: gray.go 프로젝트: kodabb/image2
	return
}

func graynaModel(c color.Color) color.Color {
	if _, ok := c.(GrayNA); ok {
		return c
	}
	r, g, b, a := c.RGBA()
	r = (r * 0xffff) / a
	g = (g * 0xffff) / a
	b = (b * 0xffff) / a
	y := (299*r + 587*g + 114*b + 500) / 1000
	return GrayNA{uint8(y >> 8), uint8(a >> 8)}
}

var GrayNAModel color.Model = color.ModelFunc(graynaModel)

/*****************************************************************************/

type GrayA struct {
	Y uint8
	A uint8
}

func (c GrayA) RGBA() (r, g, b, a uint32) {
	y := uint32(c.Y)
	y |= y << 8
	a = uint32(c.A)
	a |= a << 8
	r = y
	g = y
예제 #22
0
파일: hsia.go 프로젝트: hawx/img
		b = z
	} else {
		g = x
		b = y
		r = z
	}

	red = uint32(utils.Truncatef(r*a*255)) << 8
	green = uint32(utils.Truncatef(g*a*255)) << 8
	blue = uint32(utils.Truncatef(b*a*255)) << 8
	alpha = uint32(a*255) << 8

	return
}

var HSIAModel color.Model = color.ModelFunc(hsiaModel)

func hsiaModel(c color.Color) color.Color {
	if _, ok := c.(HSIA); ok {
		return c
	}

	r, g, b, a := utils.RatioRGBA(c)

	maxi := utils.Maxf(r, g, b)
	mini := utils.Minf(r, g, b)
	chroma := maxi - mini

	// Work out hue
	hdash := 0.0
	if chroma == 0 {
예제 #23
0
파일: hsv.go 프로젝트: Bobberino/musings
// Copyright 2012 The Gorilla Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package color

import (
	"image/color"
	"math"
)

// HSVModel converts any Color to a HSV color.
var HSVModel = color.ModelFunc(hsvModel)

// HSV represents a cylindrical coordinate of points in an RGB color model.
//
// Values are in the range 0 to 1.
type HSV struct {
	H, S, V float64
}

// RGBA returns the alpha-premultiplied red, green, blue and alpha values
// for the HSV.
func (c HSV) RGBA() (uint32, uint32, uint32, uint32) {
	r, g, b := HSVToRGB(c.H, c.S, c.V)
	return uint32(r) * 0x101, uint32(g) * 0x101, uint32(b) * 0x101, 0xffff
}

// hsvModel converts a Color to HSV.
func hsvModel(c color.Color) color.Color {
	if _, ok := c.(HSV); ok {
예제 #24
0
파일: color.go 프로젝트: knieriem/g
package image

import (
	"image/color"
)

// A BinaryColor represents either black or white.
type BinaryColor struct {
	Black bool
}

func (c BinaryColor) RGBA() (r, g, b, a uint32) {
	a = 0xffff
	if c.Black {
		return
	}
	return a, a, a, a
}

func toBinaryColor(c color.Color) color.Color {
	if _, ok := c.(BinaryColor); ok {
		return c
	}
	// should be some dithering
	r, g, b, _ := c.RGBA()
	return BinaryColor{(299*r+587*g+114*b+500)/1000 < 0x8000}
}

// The ColorModel associated with BinaryColor.
var BinaryColorModel color.Model = color.ModelFunc(toBinaryColor)
예제 #25
0
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

import (
	"image/color"
	"math"
)

const maxChannelValue = float64(0xFFFF)

// HSVAModel converts any color.Color to an HSVA color.
var HSVAModel color.Model = color.ModelFunc(hsvaModel)

func hsvaModel(c color.Color) color.Color {
	if _, ok := c.(HSVA); ok {
		return c
	}
	return RGBAtoHSVA(c.RGBA())
}

// HSVAColor represents a Hue/Saturation/Value/Alpha color.
// H is valid within [0°, 360°]. S, V and A are valid within [0, 1].
type HSVA struct {
	H, S, V, A float64
}

// Convert r, g, b, a to HSVA
예제 #26
0
파일: colorhex.go 프로젝트: drewp/homeauto
// From https://github.com/zond/wildlife/blob/master/code.google.com/p/gorilla/color/hex.go

// Copyright 2012 The Gorilla Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package hex

import (
	"fmt"
	"image/color"
	"strconv"
)

// HexModel converts any Color to an Hex color.
var HexModel = color.ModelFunc(hexModel)

// Hex represents an RGB color in hexadecimal format.
//
// The length must be 3 or 6 characters, preceded or not by a '#'.
type Hex string

// RGBA returns the alpha-premultiplied red, green, blue and alpha values
// for the Hex.
func (c Hex) RGBA() (uint32, uint32, uint32, uint32) {
	r, g, b := HexToRGB(c)
	return uint32(r) * 0x101, uint32(g) * 0x101, uint32(b) * 0x101, 0xffff
}

// hexModel converts a Color to Hex.
func hexModel(c color.Color) color.Color {
예제 #27
0
import (
	"image"
	"image/color"
	"image/png"
	"io"
	"os"

	"github.com/BurntSushi/graphics-go/graphics"
	"github.com/BurntSushi/xgb/xproto"

	"github.com/BurntSushi/xgbutil"
	"github.com/BurntSushi/xgbutil/xwindow"
)

// Model for the BGRA color type.
var BGRAModel color.Model = color.ModelFunc(bgraModel)

type Image struct {
	// X images must be tied to an X connection.
	X *xgbutil.XUtil

	// X images must also be tied to a pixmap (its drawing surface).
	// Calls to 'XDraw' will draw data to this pixmap.
	// Calls to 'XPaint' will tell X to show the pixmap on some window.
	Pixmap xproto.Pixmap

	// Pix holds the image's pixels in BGRA order, so that they don't need
	// to be swapped for every PutImage request.
	Pix []uint8

	// Stride corresponds to the number of elements in Pix between two pixels
예제 #28
0
파일: color.go 프로젝트: oov/psd
		w = b
	}
	if w == 0 {
		return NCMYKA80{0xffff, 0xffff, 0xffff, 0xffff, uint16(a)}
	}
	cc := (w - r) * 0xffff / w
	mm := (w - g) * 0xffff / w
	yy := (w - b) * 0xffff / w
	kk := 0xffff - w
	if a == 0xffff {
		return NCMYKA80{uint16(0xffff - cc), uint16(0xffff - mm), uint16(0xffff - yy), uint16(0xffff - kk), 0xffff}
	}
	cc = (cc * 0xffff) / a
	mm = (mm * 0xffff) / a
	yy = (yy * 0xffff) / a
	kk = (kk * 0xffff) / a
	return NCMYKA80{uint16(0xffff - cc), uint16(0xffff - mm), uint16(0xffff - yy), uint16(0xffff - kk), uint16(a)}
}

// These are color model.
var (
	Gray1Model    = color.ModelFunc(gray1Model)
	NGrayAModel   = color.ModelFunc(nGrayAModel)
	Gray32Model   = color.ModelFunc(gray32Model)
	NGrayA32Model = color.ModelFunc(nGrayA32Model)
	NGrayA64Model = color.ModelFunc(nGrayA64Model)
	NRGBA128Model = color.ModelFunc(nRGBA128Model)
	NCMYKAModel   = color.ModelFunc(nCMYKAModel)
	NCMYKA80Model = color.ModelFunc(nCMYKA80Model)
)
예제 #29
0
파일: argbimage.go 프로젝트: Joker/go-cairo
	if !(image.Point{x, y}.In(self.Rect)) {
		return
	}
	i := self.PixOffset(x, y)
	c1 := ARGBColorModel.Convert(c).(ARGBColor)
	self.Pix[i+0] = c1.A
	self.Pix[i+1] = c1.R
	self.Pix[i+2] = c1.G
	self.Pix[i+3] = c1.B
}

var ARGBColorModel = color.ModelFunc(
	func(c color.Color) color.Color {
		if _, ok := c.(ARGBColor); ok {
			return c
		}
		r, g, b, a := c.RGBA()
		return ARGBColor{uint8(a >> 8), uint8(r >> 8), uint8(g >> 8), uint8(b >> 8)}
	},
)

// RGBA represents a traditional 32-bit alpha-premultiplied color,
// having 8 bits for each of alpha, red, green and blue.
type ARGBColor struct {
	A, R, G, B uint8
}

func (c ARGBColor) RGBA() (r, g, b, a uint32) {
	r = uint32(c.R)
	r |= r << 8
	g = uint32(c.G)
예제 #30
0
파일: lab.go 프로젝트: kurige/SLIC
type Color struct {
	L, A, B float64
}

func (p Color) RGBA() (uint32, uint32, uint32, uint32) {
	R, G, B := Lab2rgb(p.L, p.A, p.B)
	r := uint32(R)
	r |= r << 8
	g := uint32(G)
	g |= g << 8
	b := uint32(B)
	b |= b << 8
	return r, g, b, 0xffff
}

var ColorModel color.Model = color.ModelFunc(labModel)

func labModel(c color.Color) color.Color {
	if _, ok := c.(Color); ok {
		return c
	}
	var (
		r, g, b, _ = c.RGBA()
		L, A, B    = Rgb2lab(uint8(r>>8), uint8(g>>8), uint8(b>>8))
	)
	return Color{L, A, B}
}

type Image struct {
	Pix    []float64
	Stride int