| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package draw provides basic graphics and drawing primitives, |
| // in the style of the Plan 9 graphics library |
| // (see http://plan9.bell-labs.com/magic/man2html/2/draw) |
| // and the X Render extension. |
| package draw |
| |
| // BUG(rsc): This is a toy library and not ready for production use. |
| |
| import "image" |
| |
| // A draw.Image is an image.Image with a Set method to change a single pixel. |
| type Image interface { |
| image.Image; |
| Set(x, y int, c image.Color); |
| } |
| |
| // Draw aligns r.Min in dst with pt in src and mask |
| // and then replaces the rectangle r in dst with the |
| // result of the Porter-Duff compositing operation |
| // ``(src in mask) over dst.'' If mask is nil, the operation |
| // simplifies to ``src over dst.'' |
| // The implementation is simple and slow. |
| func Draw(dst Image, r Rectangle, src, mask image.Image, pt Point) { |
| // Plenty of room for optimizations here. |
| |
| dx, dy := src.Width(), src.Height(); |
| if mask != nil { |
| if dx > mask.Width() { |
| dx = mask.Width() |
| } |
| if dy > mask.Width() { |
| dy = mask.Width() |
| } |
| } |
| dx -= pt.X; |
| dy -= pt.Y; |
| if r.Dx() > dx { |
| r.Max.X = r.Min.X + dx |
| } |
| if r.Dy() > dy { |
| r.Max.Y = r.Min.Y + dy |
| } |
| |
| x0, x1, dx := r.Min.X, r.Max.X, 1; |
| y0, y1, dy := r.Min.Y, r.Max.Y, 1; |
| if image.Image(dst) == src && r.Overlaps(r.Add(pt.Sub(r.Min))) { |
| // Rectangles overlap: process backward? |
| if pt.Y < r.Min.Y || pt.Y == r.Min.Y && pt.X < r.Min.X { |
| x0, x1, dx = x1-1, x0-1, -1; |
| y0, y1, dy = y1-1, y0-1, -1; |
| } |
| } |
| |
| var out *image.RGBA64Color; |
| for y := y0; y != y1; y += dy { |
| for x := x0; x != x1; x += dx { |
| sx := pt.X + x - r.Min.X; |
| sy := pt.Y + y - r.Min.Y; |
| if mask == nil { |
| dst.Set(x, y, src.At(sx, sy)); |
| continue; |
| } |
| _, _, _, ma := mask.At(sx, sy).RGBA(); |
| switch ma { |
| case 0: |
| continue |
| case 0xFFFFFFFF: |
| dst.Set(x, y, src.At(sx, sy)) |
| default: |
| dr, dg, db, da := dst.At(x, y).RGBA(); |
| dr >>= 16; |
| dg >>= 16; |
| db >>= 16; |
| da >>= 16; |
| sr, sg, sb, sa := src.At(sx, sy).RGBA(); |
| sr >>= 16; |
| sg >>= 16; |
| sb >>= 16; |
| sa >>= 16; |
| ma >>= 16; |
| const M = 1<<16 - 1; |
| a := sa * ma / M; |
| dr = (dr*(M-a) + sr*ma) / M; |
| dg = (dg*(M-a) + sg*ma) / M; |
| db = (db*(M-a) + sb*ma) / M; |
| da = (da*(M-a) + sa*ma) / M; |
| if out == nil { |
| out = new(image.RGBA64Color) |
| } |
| out.R = uint16(dr); |
| out.G = uint16(dg); |
| out.B = uint16(db); |
| out.A = uint16(da); |
| dst.Set(x, y, out); |
| } |
| } |
| } |
| } |
| |
| // Border aligns r.Min in dst with sp in src and then replaces pixels |
| // in a w-pixel border around r in dst with the result of the Porter-Duff compositing |
| // operation ``src over dst.'' If w is positive, the border extends w pixels inside r. |
| // If w is negative, the border extends w pixels outside r. |
| func Border(dst Image, r Rectangle, w int, src image.Image, sp Point) { |
| i := w; |
| if i > 0 { |
| // inside r |
| Draw(dst, Rect(r.Min.X, r.Min.Y, r.Max.X, r.Min.Y+i), src, nil, sp); // top |
| Draw(dst, Rect(r.Min.X, r.Min.Y+i, r.Min.X+i, r.Max.Y-i), src, nil, sp.Add(Pt(0, i))); // left |
| Draw(dst, Rect(r.Max.X-i, r.Min.Y+i, r.Max.X, r.Max.Y-i), src, nil, sp.Add(Pt(r.Dx()-i, i))); // right |
| Draw(dst, Rect(r.Min.X, r.Max.Y-i, r.Max.X, r.Max.Y), src, nil, sp.Add(Pt(0, r.Dy()-i))); // bottom |
| return; |
| } |
| |
| // outside r; |
| i = -i; |
| Draw(dst, Rect(r.Min.X-i, r.Min.Y-i, r.Max.X+i, r.Min.Y), src, nil, sp.Add(Pt(-i, -i))); // top |
| Draw(dst, Rect(r.Min.X-i, r.Min.Y, r.Min.X, r.Max.Y), src, nil, sp.Add(Pt(-i, 0))); // left |
| Draw(dst, Rect(r.Max.X, r.Min.Y, r.Max.X+i, r.Max.Y), src, nil, sp.Add(Pt(r.Dx(), 0))); // right |
| Draw(dst, Rect(r.Min.X-i, r.Max.Y, r.Max.X+i, r.Max.Y+i), src, nil, sp.Add(Pt(-i, 0))); // bottom |
| } |