component_test.go

package wardleyToGo

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

type dummyComponent struct {
	id       int64
	position image.Point
}

func (d *dummyComponent) GetPosition() image.Point { return d.position }

func (d *dummyComponent) ID() int64 { return d.id }

func (d *dummyComponent) Draw(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point) {

	coords := calcCoords(d.position, r)

	blue := color.RGBA{0, 0, 255, 255}
	draw.Draw(dst, image.Rect(coords.X, coords.Y, coords.X+2, coords.Y+2), &image.Uniform{blue}, image.Point{}, draw.Src)
}

func ExampleComponent_Draw() {
	const width = 130
	const height = 20

	im := image.NewGray(image.Rectangle{Max: image.Point{X: width, Y: height}})
	c0 := &dummyComponent{id: 0, position: image.Pt(25, 25)}
	c0.Draw(im, im.Bounds(), im, image.Point{})
	pi := image.NewPaletted(im.Bounds(), []color.Color{
		color.Gray{Y: 255},
		color.Gray{Y: 160},
		color.Gray{Y: 70},
		color.Gray{Y: 35},
		color.Gray{Y: 0},
	})
	draw.FloydSteinberg.Draw(pi, im.Bounds(), im, image.Point{})
	shade := []string{" ", "░", "▒", "▓", "█"}
	for i, p := range pi.Pix {
		fmt.Print(shade[p])
		if (i+1)%width == 0 {
			fmt.Print("\n")
		}
	}
	//Output:
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//████████████████████████████████▓▓████████████████████████████████████████████████████████████████████████████████████████████████
	//████████████████████████████████▓▓████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
	//██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████

}

func calcCoords(p image.Point, bounds image.Rectangle) image.Point {
	scale := bounds.Max.Sub(bounds.Min)
	scaleX := float64(scale.X) / 100
	scaleY := float64(scale.Y) / 100
	dest := image.Pt(int(float64(p.X)*scaleX), int(float64(p.Y)*scaleY))
	return dest.Add(bounds.Min)
}