revised

Author: Ronna Steinberg

gopher.go

@@ -22,9 +22,10 @@ import (
 
 func ColorGopherFunc(img image.Image) renderer.ColorFunc {
 	// to get the original image height uncomment this:
-	//imgHeight := img.Bounds().Max.Y - img.Bounds().Min.Y
+	imgHeight := img.Bounds().Max.Y - img.Bounds().Min.Y
 	return func(x, xOffset, y, yOffset, height int) color.Color {
-		return color.Black
+		ratio := float64(imgHeight) / float64(height)
+		return img.At(int(float64(x-xOffset)*ratio), int(float64(y-yOffset)*ratio))
 	}
 }
 

gopher_test.go

@@ -30,8 +30,8 @@ func (m mockImage) At(x, y int) color.Color {
 func TestColorGopherFunc(t *testing.T) {
 	rand.Seed(time.Now().UnixNano())
 
-	dim := rand.Intn(100)
-	newDim := rand.Intn(dim)
+	dim := rand.Intn(100) + 1
+	newDim := rand.Intn(dim) + 1
 
 	recX, recY := math.MinInt64, math.MinInt64
 	res := color.Gray{Y: uint8(rand.Intn(255))}

renderer/color.go

@@ -3,7 +3,7 @@ package renderer
 import "image/color"
 
 type (
-	ColorFunc func(int, int, int, int, int) color.Color
+	ColorFunc func(x, xOffset, y, yOffset, height int) color.Color
 
 	Colorer struct {
 		Fn ColorFunc

renderer/project.go

@@ -23,5 +23,10 @@ func max(points []int) int {
 // therefore the result slice will be [3,6,18]
 
 func Project(in []int, newMax int) []int {
-	return nil
+	out := make([]int, len(in))
+	m := max(in)
+	for i, p := range in {
+		out[i] = p * newMax / m
+	}
+	return out
 }

renderer/rectangle.go

@@ -16,4 +16,9 @@ type Img interface {
 // paint each pixel To color a pixel use img.Set
 
 func DrawRectangle(img Img, x1, y1, x2, y2 int, height int, colorFunc ColorFunc) {
+	for x := x1; x < x2; x++ {
+		for y := y1; y < y2; y++ {
+			img.Set(x, y, colorFunc(x, x1, y, y1, height))
+		}
+	}
 }

sampler/abs_avg.go

@@ -1,6 +1,12 @@
 package sampler
 
+import "math"
+
 // AbsAvg calculates the average of the absolute values in the given slice
 func AbsAvg(in []int) int {
-	return 0
+	sum := 0
+	for _, i := range in {
+		sum += int(math.Abs(float64(i)))
+	}
+	return sum / len(in)
 }

sampler/avg_abs.go

@@ -1,7 +1,13 @@
 package sampler
 
+import "math"
+
 // AvgAbs calculates the absolute value of the average
 // of the values in the given slice
 func AvgAbs(in []int) int {
-	return 0
+	sum := 0
+	for _, i := range in {
+		sum += i
+	}
+	return int(math.Abs(float64(sum))) / len(in)
 }

sampler/compress.go

@@ -17,7 +17,25 @@ var errCountInvalid = errors.New("count must be <= length of the slice")
 // * hint: use windowSize
 
 func Compress(samples []int, count int, fn SamplerFunc) ([]int, error) {
-	return nil, nil
+	if count > len(samples) {
+		return nil, errCountInvalid
+	}
+	out := make([]int, count)
+	w := windowSize(len(samples), count)
+	for i := 0; i < count; i++ {
+		low := i * w
+		high := (i + 1) * w
+		if low > len(samples) {
+			out[i] = fn([]int{})
+		} else {
+			if high > len(samples) {
+				out[i] = fn(samples[low:])
+			} else {
+				out[i] = fn(samples[low:high])
+			}
+		}
+	}
+	return out, nil
 }
 
 func windowSize(l, c int) int {

sampler/compress_test.go

@@ -1,6 +1,7 @@
 package sampler
 
 import (
+	"math"
 	"reflect"
 	"testing"
 )
@@ -17,7 +18,6 @@ func TestTransform(t *testing.T) {
 		return v[0]
 	}
 
-	//Test basic transform
 	in = []int{1, 2, 3}
 	s, err := Compress(in, 2, fn)
 	if err != nil {
@@ -29,15 +29,80 @@ func TestTransform(t *testing.T) {
 	if !reflect.DeepEqual(in, acc) {
 		t.Fatalf("Compress was not called with all the integers in the given slice expected: %v, got: %v", in, acc)
 	}
-	acc = acc[:0]
+}
+
+func TestTransformBounds(t *testing.T) {
+	var acc []int
+	var in []int
+
+	fn := func(v []int) int {
+		acc = append(acc, v...)
+		sum := 0
+		for _, i := range v {
+			sum += i
+		}
+		return sum
+	}
+
+	in = []int{1, 2, 3, 4}
+	s, err := Compress(in, 2, fn)
+	if err != nil {
+		t.Fatal("Compress was expected to succeed")
+	}
+	expected := []int{3, 7}
+	if !reflect.DeepEqual(expected, s) {
+		t.Fatalf("Compress was expected to return %v but returned %v", expected, s)
+	}
+	if !reflect.DeepEqual(in, acc) {
+		t.Fatalf("Compress was not called with all the integers in the given slice expected: %v, got: %v", in, acc)
+	}
+}
+
+func TestTransformBounds2(t *testing.T) {
+	var acc []int
+	var in []int
+
+	fn := func(v []int) int {
+		if len(v) == 0 {
+			return math.MaxUint8
+		}
+		acc = append(acc, v...)
+		sum := 0
+		for _, i := range v {
+			sum += i
+		}
+		return sum
+	}
+
+	in = []int{1, 2, 3, 4, 5, 6, 7, 8}
+	s, err := Compress(in, 6, fn)
+	if err != nil {
+		t.Fatal("Compress was expected to succeed")
+	}
+	expected := []int{3, 7, 11, 15, 255, 255}
+	if !reflect.DeepEqual(expected, s) {
+		t.Fatalf("Compress was expected to return %v but returned %v", expected, s)
+	}
+	if !reflect.DeepEqual(in, acc) {
+		t.Fatalf("Compress was not called with all the integers in the given slice expected: %v, got: %v", in, acc)
+	}
+}
+
+func TestTransformError(t *testing.T) {
+	var in []int
+
+	fn := func(v []int) int {
+		t.Fatal("sampler was expected te be called")
+		return 0
+	}
 
 	//Test transform with count larger than number of elements
-	s, err = Compress(in, len(in)+1, fn)
+	_, err := Compress(in, len(in)+1, fn)
 	if err == nil {
 		t.Fatal("Compress was expected to fail")
 	}
-}
 
+}
 func TestWindowSize(t *testing.T) {
 	if windowSize(1, 3) != 1 {
 		t.Error("window size was expected to return 1")