Example #1
0
func imageToDraw(i image.Image) (draw.Image, error) {
	switch i := i.(type) {
	case *image.Alpha:
		return draw.Image(i), nil
	case *image.Alpha16:
		return draw.Image(i), nil
	case *image.CMYK:
		return draw.Image(i), nil
	case *image.Gray:
		return draw.Image(i), nil
	case *image.Gray16:
		return draw.Image(i), nil
	case *image.NRGBA:
		return draw.Image(i), nil
	case *image.NRGBA64:
		return draw.Image(i), nil
	case *image.Paletted:
		return draw.Image(i), nil
	case *image.RGBA:
		return draw.Image(i), nil
	case *image.RGBA64:
		return draw.Image(i), nil
	default:
		return nil, fmt.Errorf("invalid image type %T", i)
	}
}
Example #2
0
File: image.go Project: Kimau/GoCam
// RotateImageLeft will rotate image 90 deg Counter Clockwise
func RotateImageLeft(src image.Image) image.Image {
	width := src.Bounds().Size().X
	height := src.Bounds().Size().Y

	m := draw.Image(image.NewRGBA(image.Rect(0, 0, height, width)))

	for x := 0; x < width; x++ {
		for y := 0; y < width; y++ {
			m.Set(y, width-x, src.At(x, y))
		}
	}

	return m
}
Example #3
0
// postHandler accepts POSTed revisit messages from a Revisit.link hub,
// transforms the message, and returns the transformed message to the hub.
// See: http://revisit.link/spec.html
func (rs *RevisitService) postHandler(w http.ResponseWriter, r *http.Request) {

	// make sure message isn't too large
	payloadReadCloser := http.MaxBytesReader(w, r.Body, payloadLimit)
	payloadBytes, err := ioutil.ReadAll(payloadReadCloser)
	if err != nil {
		log.Errorf("error reading payload: %d", http.StatusRequestEntityTooLarge)
		http.Error(w, "ROTFL", http.StatusRequestEntityTooLarge)
		return
	}

	// decode the payload into a RevisitMsg
	var msg *RevisitMsg
	decoder := json.NewDecoder(bytes.NewReader(payloadBytes))
	err = decoder.Decode(&msg)
	if err != nil {
		log.Errorf("error decoding json: %d", http.StatusUnsupportedMediaType)
		http.Error(w, "ROTFL", http.StatusUnsupportedMediaType)
		return
	}

	// construct a RevisitImage from the payload
	ri, err := NewRevisitImageFromMsg(msg)
	if err != nil {
		log.Errorf("error decoding json: %d", http.StatusUnsupportedMediaType)
		http.Error(w, "ROTFL", http.StatusUnsupportedMediaType)
		return
	}

	// for each image frame (only 1 if jpeg or png), call the glitcher
	for _, rgba := range ri.Rgbas {
		rs.glitcher(draw.Image(&rgba))
	}

	// create a new message from the modified image
	newMsg, err := ri.RevisitMsg()
	if err != nil {
		log.Errorf("error decoding json: %d", http.StatusInternalServerError)
		http.Error(w, "ROTFL", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	enc := json.NewEncoder(w)
	enc.Encode(newMsg)
}
Example #4
0
func (g *Gui) Run(tsEvent *chan touchscreen.TouchscreenEvent) {

	oldEvent := touchscreen.TouchscreenEvent{touchscreen.TSEVENT_NULL, 0, 0}

	for {
		select {
		case e := <-*tsEvent:
			if e.Type == touchscreen.TSEVENT_PUSH {
				if oldEvent != e {
					if g.timeout > DISPLAY_TIMEOUT {
						g.dirty <- true
					} else {
						g.processButtonsOfPage(e, g.mainPage)
						g.processButtonsOfPage(e, g.pages[g.activePageName])
					}
					g.timeout = 0
					oldEvent = e
				}
			} else {
				oldEvent = touchscreen.TouchscreenEvent{touchscreen.TSEVENT_NULL, 0, 0}
			}

		case <-g.dirty:

			if g.timeout > DISPLAY_TIMEOUT {
				draw.Draw(*g.target, g.Bounds, image.NewUniform(image.Black), image.ZP, draw.Src)
			} else {
				doubleBuffer := draw.Image(image.NewRGBA(g.Bounds))

				mainPage := g.mainPage
				if mainPage != nil {
					(*mainPage).Draw(&doubleBuffer)
				}

				currentPage := g.pages[g.activePageName]
				if currentPage != nil {
					(*currentPage).Draw(&doubleBuffer)
				}

				draw.Draw(*g.target, doubleBuffer.Bounds(), doubleBuffer, image.ZP, draw.Src)
			}
		}
	}
}
Example #5
0
func drawImage(sampleRate float64, spectraChan chan []float64) (img_ image.Image) {
	var spectra [][]float64
	max := 0.0
	os.Stdout.Sync()

	for spectrum := range spectraChan {
		//spectrum = spectrum[:MaxNumFreqs]
		for i, x := range spectrum {
			x = math.Log(x)
			spectrum[i] = x
			max = math.Max(max, x)
		}

		spectra = append(spectra, spectrum)

		if len(spectra)%20 == 0 {
			fmt.Printf("\rCalculating spectra... %d          ", len(spectra))
			os.Stdout.Sync()
		}
	}

	imageWidth := len(spectra)
	imageHeight := len(spectra[0])
	img := draw.Image(image.NewRGBA(image.Rect(0, 0, imageWidth, imageHeight)))

	for x := 0; x < imageWidth; x++ {
		if x%20 == 0 {
			fmt.Printf("\rDrawing image... %.1f%%           ", (float64(x)/float64(imageWidth))*100)
			os.Stdout.Sync()
		}

		for y := 0; y < imageHeight; y++ {
			value := spectra[x][y] / max
			red := uint8((1.0 - value) * 0xff)
			green := uint8(value * 0xff)
			c := color.RGBA{red, green, 0, 0xff}
			img.Set(x, y, c)
		}
	}

	return img
}
Example #6
0
File: vgimg.go Project: zzn01/plot
// NewWith returns a new image canvas created according to the specified
// options. The currently accepted options are UseWH,
// UseDPI, UseImage, and UseImageWithContext.
// Each of the options specifies the size of the canvas (UseWH, UseImage),
// the resolution of the canvas (UseDPI), or both (useImageWithContext).
// If size or resolution are not specified, defaults are used.
// It panics if size and resolution are overspecified (i.e., too many options are
// passed).
func NewWith(o ...option) *Canvas {
	c := new(Canvas)
	var g uint32
	for _, opt := range o {
		f := opt(c)
		if g&f != 0 {
			panic("incompatible options")
		}
		g |= f
	}
	if c.dpi == 0 {
		c.dpi = DefaultDPI
	}
	if c.w == 0 { // h should also == 0.
		if c.img == nil {
			c.w = DefaultWidth
			c.h = DefaultHeight
		} else {
			w := float64(c.img.Bounds().Max.X - c.img.Bounds().Min.X)
			h := float64(c.img.Bounds().Max.Y - c.img.Bounds().Min.Y)
			c.w = vg.Length(w/float64(c.dpi)) * vg.Inch
			c.h = vg.Length(h/float64(c.dpi)) * vg.Inch
		}
	}
	if c.img == nil {
		w := c.w / vg.Inch * vg.Length(c.dpi)
		h := c.h / vg.Inch * vg.Length(c.dpi)
		c.img = draw.Image(image.NewRGBA(image.Rect(0, 0, int(w+0.5), int(h+0.5))))
	}
	if c.gc == nil {
		h := float64(c.img.Bounds().Max.Y - c.img.Bounds().Min.Y)
		c.gc = draw2dimg.NewGraphicContext(c.img)
		c.gc.SetDPI(c.dpi)
		c.gc.Scale(1, -1)
		c.gc.Translate(0, -h)
	}
	draw.Draw(c.img, c.img.Bounds(), image.White, image.ZP, draw.Src)
	c.color = []color.Color{color.Black}
	vg.Initialize(c)
	return c
}
Example #7
0
// benchGlyph benchmarks rasterizing a TrueType glyph.
//
// Note that, compared to the github.com/google/font-go prototype, the height
// here is the height of the bounding box, not the pixels per em used to scale
// a glyph's vectors. A height of 64 corresponds to a ppem greater than 64.
func benchGlyph(b *testing.B, colorModel byte, loose bool, height int, op draw.Op) {
	width, data := scaledBenchmarkGlyphData(height)
	z := NewRasterizer(width, height)

	bounds := z.Bounds()
	if loose {
		bounds.Max.X++
	}
	dst, src := draw.Image(nil), image.Image(nil)
	switch colorModel {
	case 'A':
		dst = image.NewAlpha(bounds)
		src = image.Opaque
	case 'N':
		dst = image.NewNRGBA(bounds)
		src = image.NewUniform(color.NRGBA{0x40, 0x80, 0xc0, 0xff})
	case 'R':
		dst = image.NewRGBA(bounds)
		src = image.NewUniform(color.RGBA{0x40, 0x80, 0xc0, 0xff})
	default:
		b.Fatal("unsupported color model")
	}
	bounds = z.Bounds()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		z.Reset(width, height)
		z.DrawOp = op
		for _, d := range data {
			switch d.n {
			case 0:
				z.MoveTo(d.px, d.py)
			case 1:
				z.LineTo(d.px, d.py)
			case 2:
				z.QuadTo(d.px, d.py, d.qx, d.qy)
			}
		}
		z.Draw(dst, bounds, src, image.Point{})
	}
}
Example #8
0
func (ri *RevisitImage) Transform(t func(src draw.Image)) {
	for _, frame := range ri.Rgbas {
		t(draw.Image(&frame))
	}
}