117 lines
2.1 KiB
Go
117 lines
2.1 KiB
Go
package dithering
|
|
|
|
import (
|
|
"image"
|
|
"image/color"
|
|
"image/png"
|
|
"math/rand"
|
|
"os"
|
|
"os/exec"
|
|
"testing"
|
|
"time"
|
|
"reflect"
|
|
|
|
"git.nkpl.cc/twocookedfaggots/imageutils"
|
|
)
|
|
|
|
func init() {
|
|
rand.Seed(time.Now().UnixNano())
|
|
}
|
|
|
|
const factor = 0.75
|
|
|
|
func callImage(img image.Image) {
|
|
for y := 0; y < img.Bounds().Dy(); y++ {
|
|
for x := 0; x < img.Bounds().Dx(); x++ {
|
|
_ = img.At(x, y)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGrid(t *testing.T) {
|
|
command := exec.Command("imv", "-")
|
|
w, err := command.StdinPipe()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = command.Start()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
n := uint8(rand.Int() % 256)
|
|
t.Log(n)
|
|
img := imageutils.Scale(grid{color.Gray{n}, factor}, 1<<6)
|
|
err = png.Encode(w, img)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
callImage(grid{color.Gray{4}, factor})
|
|
callImage(grid{color.Gray{0}, factor})
|
|
}
|
|
|
|
func TestDithering(t *testing.T) {
|
|
r, err := os.Open("/home/potassium/documents/wallpaper/8.png")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer r.Close()
|
|
|
|
w, err := os.Create("sample.png")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer w.Close()
|
|
|
|
img, err := png.Decode(r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = png.Encode(w, Dithering{img, factor})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestRangeStruct(t *testing.T){
|
|
s := Dithering{image.Rectangle{},0}
|
|
value := reflect.ValueOf(s)
|
|
if value.Kind() == reflect.Ptr {
|
|
value = value.Elem()
|
|
}
|
|
if value.Kind() != reflect.Struct {
|
|
t.Log("Provided value is not a struct")
|
|
}
|
|
tp := value.Type()
|
|
for i := 0; i < value.NumField(); i++ {
|
|
fieldName := tp.Field(i).Name
|
|
fieldValue := value.Field(i)
|
|
|
|
if !fieldValue.CanInterface() {
|
|
t.Logf("Field %s is unexported\n", fieldName)
|
|
continue
|
|
}
|
|
if fieldValue.Kind() == reflect.Ptr {
|
|
fieldValue = fieldValue.Elem()
|
|
}
|
|
/*
|
|
if fieldValue.Kind() == reflect.Interface {
|
|
fieldValue = fieldValue.Elem()
|
|
}
|
|
*/
|
|
|
|
|
|
actualValue := fieldValue.Interface()
|
|
switch v := actualValue.(type) {
|
|
case float64:
|
|
t.Logf("Field '%s' is a float64.\n", fieldName)
|
|
case image.Image:
|
|
t.Logf("Field '%s' is a image.Image. Value: %q\n", fieldName, v)
|
|
default:
|
|
t.Logf("Field '%s' has an unhandled type: %T\n", fieldName, v)
|
|
}
|
|
}
|
|
}
|