At a Loss with Images Exercise in Tour of Go

[Kevin Simonson]

Now I'm on page "127.0.0.1:3999/methods/25" with title "Exercise: Images" that says:

Remember the picture generator you wrote earlier? Let's write another one, but this time it will return an implementation of image.Image instead of a slice of data.

Define your own Image type, implement the necessary methods, and call pic.ShowImage.

Bounds should return a image.Rectangle, like image.Rect(0, 0, w, h).

ColorModel should return color.RGBAModel.

At should return a color; the value v in the last picture generator corresponds to color.RGBA{v, v, 255, 255} in this one.

with example code (labeled "exercise-images.go"):

package main

import "golang.org/x/tour/pic"

type Image struct{}

func main() {
	m := Image{}
	pic.ShowImage(m)
}

The prior page defined the Image interface:

package image

type Image interface {
    ColorModel() color.Model
    Bounds() Rectangle
    At(x, y int) color.Color
}

How in the world do I implement an interface for a type with methods that return a {color.Model} or a {color.Color}? I don't even know what those types are. I'm at a loss with this exercise. Can anyone give me any pointers here?

[Junilu Lacar]

The image and color prefixes refer to standard Go packages: https://golang.org/pkg

I think they just put those prefixes in that text to provide some context. You can also have the following import to avoid having to use the prefixes explicitly in your code.

import (
  "image"
  "image/color"
)

The documentation for image.Image is here: https://golang.org/pkg/image/#Image

You'll need to familiarize yourself with the package documentation to get the most out of the tour. Fortunately, the documentation is quite comprehensive and what's more, many of the code examples are executable right from the documentation pages.

[Junilu Lacar]

See also https://godoc.org/golang.org/x/tour/pic

When you're instructed to write your own Image type and implement the necessary methods, that means you have to write something like this:

package main

import (
  "image"
  ...
)

// your implementation of the image.Image interface
type Image struct {
  ..
}

// implementation methods. The Image referred to 
// here is the type you defined on line 9

func (i *Image) ColorModel() color.Model {
  ...
}

func (i *Image) Bounds() Rectangle {
  ...
}

func (i *Image) At(x, y int) color.Color {
  ...
}

Unlike Java, Go does not require to explicitly declare that your type implements an interface. As long as all the necessary methods are present, the type is assumed to be an implementation.

[Kevin Simonson]

Junilu Lacar wrote:Unlike Java, Go does not require to explicitly declare that your type implements an interface. As long as all the necessary methods are present, the type is assumed to be an implementation.

Okay, I tried:

package main

import (
  "golang.org/x/tour/pic"
  "image"
  "color"
)

type Image struct{}

func ( im *image.Image) ColorModel() color.Model {
  return image.color.RGBAModel;
}

func ( im *image.Image) Bounds() Rectangle {
  return image.Rect( 0, 0, 16, 16);
}

func ( im *image.Image) At ( x, y int) color.Color {
  return image.color.RGBA{ (x + y) / 2, x * y, x ^ y, 255};
}

func main() {
	m := Image{}
	pic.ShowImage(m)
}

which looked to me like it should work, but that generated error message:

compile4.go:6:3: cannot find package "color" in any of:
	C:\Go\src\color (from $GOROOT)
	C:\Go\misc\tour\src\color (from $GOPATH)

Program exited: exit status 1

So it looks like the Go compiler can't locate package "color"; my import of simply "color" didn't do any good. Can anybody tell me what I should import so that I can see "color"?

[Junilu Lacar]

Again, it is important to become familiar with the documentation of Go's standard packages. Go packages are hierarchical and the color package is actually under image so your import would be "image/color" not just "color".

See the import example on the package documentation page https://golang.org/pkg/image/color/

When you do that, your reference would be color.RGBA as indicated in the Tour example instead of image.color.RGBA

[Kevin Simonson]

Junilu Lacar wrote:Again, it is important to become familiar with the documentation of Go's standard packages. Go packages are hierarchical and the color package is actually under image so your import would be "image/color" not just "color".

See the import example on the package documentation page https://golang.org/pkg/image/color/

When you do that, your reference would be color.RGBA as indicated in the Tour example instead of image.color.RGBA

Now my code is:
package main import (  "golang.org/x/tour/pic"  "image"  "image/color" ) type Image struct{} func ( im *Image) ColorModel() color.Model {  return color.RGBAModel; } func ( im *Image) Bounds() image.Rectangle {  return image.Rect( 0, 0, 16, 16); } func ( im *Image) At ( x, y int) color.Color {  return color.RGBA{ uint8( (x + y) / 2), uint8( x * y), uint8( x ^ y), 255}; } func main() { m := Image{} pic.ShowImage(m) }
and the error message is:

# command-line-arguments
.\compile10.go:25: cannot use m (type Image) as type image.Image in argument to pic.ShowImage:
	Image does not implement image.Image (At method has pointer receiver)

Is there a documentation page that lists the details for the Image interface?

[Kevin Simonson]

I found and read the documentation at "https://golang.org/pkg/image/#Image". I still don't see what's wrong with my function:
func ( im *Image) At ( x, y int) color.Color {  return color.RGBA{ uint8( (x + y) / 2), uint8( x * y), uint8( x ^ y), 255}; }
Is there some reason I can't have a pointer receiver for my function? Should I just write it as:
func At ( x, y int) color.Color {  return color.RGBA{ uint8( (x + y) / 2), uint8( x * y), uint8( x ^ y), 255}; }
I'm a little confused here.

[Kevin Simonson]

Junilu Lacar wrote:See also https://godoc.org/golang.org/x/tour/pic

When you're instructed to write your own Image type and implement the necessary methods, that means you have to write something like this:

package main

import (
  "image"
  ...
)

// your implementation of the image.Image interface
type Image struct {
  ..
}

// implementation methods. The Image referred to 
// here is the type you defined on line 9

func (i *Image) ColorModel() color.Model {
  ...
}

func (i *Image) Bounds() Rectangle {
  ...
}

func (i *Image) At(x, y int) color.Color {
  ...
}

Unlike Java, Go does not require to explicitly declare that your type implements an interface. As long as all the necessary methods are present, the type is assumed to be an implementation.

Never mind. I got some pretty cool results with code:
package main import (  "golang.org/x/tour/pic"  "image"  "image/color" ) type Image struct{} func ( im Image) ColorModel() color.Model {  return color.RGBAModel; } func ( im Image) Bounds() image.Rectangle {  return image.Rect( 0, 0, 256, 256); } func ( im Image) At ( x, y int) color.Color {  return color.RGBA{ uint8( x + y), uint8( x * y), uint8( x ^ y), 255}; } func main() { m := Image{} pic.ShowImage(m) }
Looks like I've completed this exercise.