initial approximation

pkg/generator/draw/draw.go

@@ -0,0 +1,148 @@
+package draw
+
+import (
+	"fmt"
+	"math"
+)
+
+const batchSize = 32
+
+type Plane struct {
+	Width  uint
+	Height uint
+	pixels []uint32
+}
+
+func (p *Plane) pixelsValue() []uint32 {
+	return p.pixels
+}
+
+func New(width uint, height uint) Plane {
+	elements := int(math.Ceil(float64(width*height) / batchSize))
+	return Plane{Width: width, Height: height, pixels: make([]uint32, elements)}
+}
+
+func (p Plane) Mark(x, y int) {
+	boundX := (p.Width + uint(x)) % p.Width
+	boundY := (p.Height + uint(y)) % p.Height
+	p.mark(boundX + boundY*p.Width)
+
+	// p.mark(x + y*p.Width)
+
+	// number := x + y*p.width
+	// index := number / batchSize
+	// bit := number % batchSize
+	// p.pixels[index] |= (0b1 << bit)
+}
+
+func (p Plane) mark(number uint) {
+	// index := number / batchSize
+	// bit := number % batchSize
+	p.pixels[number/batchSize] |= (0b1 << (number % batchSize))
+}
+
+func (p Plane) Marked(x, y uint) bool {
+	return p.marked(x + y*p.Width)
+	// number := x + y*p.width
+	// index := number / batchSize
+	// bit := number % batchSize
+	// return p.pixels[index]&(0b1<<bit) > 0
+}
+
+func (p Plane) marked(number uint) bool {
+	// index := number / batchSize
+	// bit := number % batchSize
+	return p.pixels[number/batchSize]&(0b1<<(number%batchSize)) > 0
+}
+
+func (p Plane) Circle(x, y int, r float64) {
+	plotX := 0
+	plotY := int(math.Ceil(r))
+	delta := 3 - 2*plotY
+	lastY := plotY
+	for plotX <= plotY {
+		p.octant(x, y, plotX, plotY)
+		if plotY < lastY {
+			for lineX := 0; lineX < plotX; lineX++ {
+				p.octant(x, y, lineX, plotY)
+			}
+			lastY = plotY
+		}
+		if delta < 0 {
+			delta += 4*plotX + 6
+		} else {
+			delta += 4*(plotX-plotY) + 10
+			plotY -= 1
+		}
+		plotX += 1
+	}
+	for fillX := 0; fillX < plotX; fillX++ {
+		for fillY := 0; fillY <= fillX; fillY++ {
+			p.octant(x, y, fillX, fillY)
+		}
+	}
+}
+
+func (p Plane) CircleAdjacent(x, y int, r float64) {
+	plotX := 0
+	plotY := int(math.Ceil(r))
+	delta := 1 - 2*plotY
+	err := 0
+	for plotX <= plotY {
+		p.octant(x, y, plotX, plotY)
+		err = 2*(delta+plotY) - 1
+		if delta < 0 && err <= 0 {
+			plotX += 1
+			delta += 2*plotX + 1
+			continue
+		}
+		if delta > 0 && err > 0 {
+			plotY -= 1
+			delta -= 2*plotY + 1
+			continue
+		}
+		plotX += 1
+		plotY -= 1
+		delta += 2 * (plotX - plotY)
+	}
+}
+
+func (p Plane) octant(x, y int, plotX, plotY int) {
+	p.Mark(x+plotX, y+plotY)
+	p.Mark(x+plotX, y-plotY)
+	p.Mark(x-plotX, y+plotY)
+	p.Mark(x-plotX, y-plotY)
+	p.Mark(x+plotY, y+plotX)
+	p.Mark(x+plotY, y-plotX)
+	p.Mark(x-plotY, y+plotX)
+	p.Mark(x-plotY, y-plotX)
+}
+
+func (p Plane) Clear() {
+	for i := range p.pixels {
+		p.pixels[i] &= 0
+	}
+}
+
+func (p Plane) String() string {
+	px := map[bool]string{true: "x", false: "_"}
+	var result string
+	// for y := 0; y < int(p.height); y++ {
+	// 	for x := 0; x < int(p.width); x++ {
+	// 		result += px[p.Marked(uint(x), uint(y))] + " "
+	// 	}
+	// 	result += "\n"
+	// }
+	// result += "\n"
+	cnt := 0
+	for i := 0; i < len(p.pixels); i++ {
+		for bit := 0; bit < batchSize && cnt < int(p.Width*p.Height); bit++ {
+			result += fmt.Sprintf("%s ", px[p.pixels[i]&(0b1<<bit) > 0])
+			cnt++
+			if cnt%int(p.Width) == 0 {
+				result += "\n"
+			}
+		}
+	}
+	return result
+}

pkg/generator/draw/draw_test.go

@@ -0,0 +1,82 @@
+package draw_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/iliadenisov/galaxy/pkg/generator/draw"
+)
+
+func Test_CreatePlot(t *testing.T) {
+	var pane = draw.New(10, 10)
+	if len(draw.PixelsHolder(&pane)) != 4 {
+		t.Errorf("wrong Pane data size, expected: %d given: %d", 4, len(draw.PixelsHolder(&pane)))
+	}
+
+	pane = draw.New(1, 1)
+	if len(draw.PixelsHolder(&pane)) != 1 {
+		t.Errorf("wrong Pane data size, expected: %d given: %d", 4, len(draw.PixelsHolder(&pane)))
+	}
+
+	pane = draw.New(32, 32)
+	if len(draw.PixelsHolder(&pane)) != 32 {
+		t.Errorf("wrong Pane data size, expected: %d given: %d", 4, len(draw.PixelsHolder(&pane)))
+	}
+}
+
+func Test_Mark(t *testing.T) {
+	var size int = 7
+	var pane = draw.New(uint(size), uint(size))
+	for i := 0; i < int(size); i++ {
+		pane.Mark(0, i)
+		pane.Mark(i, 0)
+		pane.Mark(size-1, i)
+		pane.Mark(i, size-1)
+		pane.Mark(i, i)
+		pane.Mark(size-1-i, i)
+	}
+
+	pixelsHolder := draw.PixelsHolder(&pane)
+
+	if len(pixelsHolder) != 2 {
+		t.Errorf("expected len: %d given: %d", 2, len(pixelsHolder))
+	}
+
+	// if !pane.Marked(0, 0) {
+	// 	t.Errorf("should be marked at x=%d y=%d", 0, 0)
+	// }
+
+	fmt.Println(pane)
+}
+
+func Test_Cleat(t *testing.T) {
+	var pane = draw.New(10, 10)
+	pane.Mark(5, 5)
+	pane.Mark(0, 0)
+	pane.Mark(9, 9)
+	if !pane.Marked(0, 0) {
+		t.Errorf("should be marked at x=%d y=%d", 0, 0)
+	}
+	if !pane.Marked(5, 5) {
+		t.Errorf("should be marked at x=%d y=%d", 5, 5)
+	}
+	if !pane.Marked(9, 9) {
+		t.Errorf("should be marked at x=%d y=%d", 9, 9)
+	}
+	pane.Clear()
+	for _, holder := range draw.PixelsHolder(&pane) {
+		if holder != 0 {
+			t.Errorf("should be all bits clear")
+		}
+	}
+}
+
+func Test_Circle(t *testing.T) {
+	var size int = 40
+	var pane1 = draw.New(uint(size), uint(size))
+	pane1.Circle(size/2+5, size/2-5, float64(size/2)-3)
+	fmt.Println(pane1)
+	var pane2 = draw.New(uint(size), uint(size))
+	pane2.CircleAdjacent(size/2+20, size/2, float64(size/2)-5)
+	// fmt.Println(pane2)
+}

pkg/generator/draw/export_test.go

@@ -0,0 +1,3 @@
+package draw
+
+var PixelsHolder = (*Plane).pixelsValue