more new ideas

cmd/playground/mask/circles.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"image"
+	"image/color"
+	"math/rand"
+
+	iu "git.nkpl.cc/twocookedfaggots/imageutils"
+)
+
+func square(side int) image.Rectangle { return image.Rect(0, 0, side, side) }
+
+func Circles(b image.Rectangle, radius int) chan iu.Circle {
+	ch := make(chan iu.Circle)
+	go func() {
+		defer close(ch)
+		for {
+			x, y := rand.Int()%b.Dx(), rand.Int()%b.Dy()
+			dxdy := b.Dx() * b.Dy()
+			r := rand.Int() % (dxdy / (dxdy / radius))
+			ch <- iu.Circle{image.Point{x, y}, r}
+		}
+	}()
+	return ch
+}
+
+var Opaque, Transparent = color.Alpha{0xff}, color.Alpha{0}
+
+type xor struct{ dst, src image.Image }
+
+func (t xor) ColorModel() color.Model { return t.dst.ColorModel() }
+func (t xor) Bounds() image.Rectangle { return t.src.Bounds() }
+func (t xor) At(x, y int) color.Color {
+	dstColor := t.ColorModel().Convert(t.dst.At(x, y))
+	srcColor := t.ColorModel().Convert(t.src.At(x, y))
+
+	// xor operation (a || b) && !(a && b)
+	if ((dstColor == color.Opaque) || (srcColor == color.Opaque)) &&
+		!((dstColor == color.Opaque) && (srcColor == color.Opaque)) {
+		return color.Opaque
+	}
+	return color.Transparent
+}
+
+var exchange = color.ModelFunc(
+	func(c color.Color) color.Color {
+		if color.Alpha16Model.Convert(c) == color.Transparent {
+			return color.Opaque
+		}
+		return color.Transparent
+	},
+)
+
+type Exchange struct{ image.Image }
+
+func (e Exchange) ColorModel() color.Model { return color.Alpha16Model }
+func (e Exchange) Bounds() image.Rectangle { return e.Image.Bounds() }
+func (e Exchange) At(x, y int) color.Color {
+	c := e.ColorModel().Convert(e.Image.At(x, y))
+	return exchange.Convert(c)
+}
+
+var blackAndWhite = color.ModelFunc(
+	func(c color.Color) color.Color {
+		if color.Alpha16Model.Convert(c) == color.Transparent {
+			return color.Black
+		}
+		return color.White
+	},
+)
+
+// Black and white's alpha image.
+type BlackAndWhite struct{ image.Image }
+
+func (b BlackAndWhite) ColorModel() color.Model { return color.Gray16Model }
+func (b BlackAndWhite) Bounds() image.Rectangle { return b.Image.Bounds() }
+func (b BlackAndWhite) At(x, y int) color.Color {
+	c := b.Image.At(x, y)
+	return blackAndWhite.Convert(c)
+}

cmd/playground/mask/mask.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"image"
+	"image/color"
+	"image/draw"
+	"image/png"
+	"os"
+)
+
+type XORMask struct {
+	dst, src image.Image
+}
+
+func (m XORMask) ColorModel() color.Model { return color.Gray16Model }
+func (m XORMask) Bounds() image.Rectangle { return m.dst.Bounds() }
+func (m XORMask) At(x, y int) color.Color {
+	srcColor := m.src.At(x, y)
+	dstColor := m.dst.At(x, y)
+
+	if ((dstColor == color.Black) || (srcColor == color.Black)) &&
+		!((dstColor == color.Black) && (srcColor == color.Black)) {
+		return color.Black
+	}
+	return color.White
+}
+
+func main() {
+	img, err := png.Decode(os.Stdin)
+	if err != nil {
+		panic(err)
+	}
+
+	grayImg := image.NewGray16(img.Bounds())
+	for y := img.Bounds().Min.Y; y < img.Bounds().Max.Y; y++ {
+		for x := img.Bounds().Min.X; x < img.Bounds().Max.X; x++ {
+			c := img.At(x, y)
+			grayImg.Set(x, y, color.Gray16Model.Convert(c))
+		}
+	}
+	canvas := image.NewRGBA(img.Bounds())
+	circle := Circles(canvas.Bounds(), canvas.Bounds().Dy()/6)
+	for i := 0; i < 24; i++ {
+		c := <-circle
+		draw.Draw(canvas, c.Bounds(), xor{c, canvas}, c.Bounds().Min, draw.Src)
+	}
+
+	err = png.Encode(
+		os.Stdout, XORMask{
+			grayImg,
+			BlackAndWhite{
+				Exchange{
+					canvas,
+				},
+			},
+		},
+	)
+	if err != nil {
+		panic(err)
+	}
+
+}