Black Lives Matter. Support the Equal Justice Initiative.

Source file src/image/geom.go

Documentation: image

```     1  // Copyright 2010 The Go Authors. All rights reserved.
2  // Use of this source code is governed by a BSD-style
4
5  package image
6
7  import (
8  	"image/color"
9  	"math/bits"
10  	"strconv"
11  )
12
13  // A Point is an X, Y coordinate pair. The axes increase right and down.
14  type Point struct {
15  	X, Y int
16  }
17
18  // String returns a string representation of p like "(3,4)".
19  func (p Point) String() string {
20  	return "(" + strconv.Itoa(p.X) + "," + strconv.Itoa(p.Y) + ")"
21  }
22
23  // Add returns the vector p+q.
24  func (p Point) Add(q Point) Point {
25  	return Point{p.X + q.X, p.Y + q.Y}
26  }
27
28  // Sub returns the vector p-q.
29  func (p Point) Sub(q Point) Point {
30  	return Point{p.X - q.X, p.Y - q.Y}
31  }
32
33  // Mul returns the vector p*k.
34  func (p Point) Mul(k int) Point {
35  	return Point{p.X * k, p.Y * k}
36  }
37
38  // Div returns the vector p/k.
39  func (p Point) Div(k int) Point {
40  	return Point{p.X / k, p.Y / k}
41  }
42
43  // In reports whether p is in r.
44  func (p Point) In(r Rectangle) bool {
45  	return r.Min.X <= p.X && p.X < r.Max.X &&
46  		r.Min.Y <= p.Y && p.Y < r.Max.Y
47  }
48
49  // Mod returns the point q in r such that p.X-q.X is a multiple of r's width
50  // and p.Y-q.Y is a multiple of r's height.
51  func (p Point) Mod(r Rectangle) Point {
52  	w, h := r.Dx(), r.Dy()
53  	p = p.Sub(r.Min)
54  	p.X = p.X % w
55  	if p.X < 0 {
56  		p.X += w
57  	}
58  	p.Y = p.Y % h
59  	if p.Y < 0 {
60  		p.Y += h
61  	}
63  }
64
65  // Eq reports whether p and q are equal.
66  func (p Point) Eq(q Point) bool {
67  	return p == q
68  }
69
70  // ZP is the zero Point.
71  //
72  // Deprecated: Use a literal image.Point{} instead.
73  var ZP Point
74
75  // Pt is shorthand for Point{X, Y}.
76  func Pt(X, Y int) Point {
77  	return Point{X, Y}
78  }
79
80  // A Rectangle contains the points with Min.X <= X < Max.X, Min.Y <= Y < Max.Y.
81  // It is well-formed if Min.X <= Max.X and likewise for Y. Points are always
82  // well-formed. A rectangle's methods always return well-formed outputs for
83  // well-formed inputs.
84  //
85  // A Rectangle is also an Image whose bounds are the rectangle itself. At
86  // returns color.Opaque for points in the rectangle and color.Transparent
87  // otherwise.
88  type Rectangle struct {
89  	Min, Max Point
90  }
91
92  // String returns a string representation of r like "(3,4)-(6,5)".
93  func (r Rectangle) String() string {
94  	return r.Min.String() + "-" + r.Max.String()
95  }
96
97  // Dx returns r's width.
98  func (r Rectangle) Dx() int {
99  	return r.Max.X - r.Min.X
100  }
101
102  // Dy returns r's height.
103  func (r Rectangle) Dy() int {
104  	return r.Max.Y - r.Min.Y
105  }
106
107  // Size returns r's width and height.
108  func (r Rectangle) Size() Point {
109  	return Point{
110  		r.Max.X - r.Min.X,
111  		r.Max.Y - r.Min.Y,
112  	}
113  }
114
115  // Add returns the rectangle r translated by p.
116  func (r Rectangle) Add(p Point) Rectangle {
117  	return Rectangle{
118  		Point{r.Min.X + p.X, r.Min.Y + p.Y},
119  		Point{r.Max.X + p.X, r.Max.Y + p.Y},
120  	}
121  }
122
123  // Sub returns the rectangle r translated by -p.
124  func (r Rectangle) Sub(p Point) Rectangle {
125  	return Rectangle{
126  		Point{r.Min.X - p.X, r.Min.Y - p.Y},
127  		Point{r.Max.X - p.X, r.Max.Y - p.Y},
128  	}
129  }
130
131  // Inset returns the rectangle r inset by n, which may be negative. If either
132  // of r's dimensions is less than 2*n then an empty rectangle near the center
133  // of r will be returned.
134  func (r Rectangle) Inset(n int) Rectangle {
135  	if r.Dx() < 2*n {
136  		r.Min.X = (r.Min.X + r.Max.X) / 2
137  		r.Max.X = r.Min.X
138  	} else {
139  		r.Min.X += n
140  		r.Max.X -= n
141  	}
142  	if r.Dy() < 2*n {
143  		r.Min.Y = (r.Min.Y + r.Max.Y) / 2
144  		r.Max.Y = r.Min.Y
145  	} else {
146  		r.Min.Y += n
147  		r.Max.Y -= n
148  	}
149  	return r
150  }
151
152  // Intersect returns the largest rectangle contained by both r and s. If the
153  // two rectangles do not overlap then the zero rectangle will be returned.
154  func (r Rectangle) Intersect(s Rectangle) Rectangle {
155  	if r.Min.X < s.Min.X {
156  		r.Min.X = s.Min.X
157  	}
158  	if r.Min.Y < s.Min.Y {
159  		r.Min.Y = s.Min.Y
160  	}
161  	if r.Max.X > s.Max.X {
162  		r.Max.X = s.Max.X
163  	}
164  	if r.Max.Y > s.Max.Y {
165  		r.Max.Y = s.Max.Y
166  	}
167  	// Letting r0 and s0 be the values of r and s at the time that the method
168  	// is called, this next line is equivalent to:
169  	//
170  	// if max(r0.Min.X, s0.Min.X) >= min(r0.Max.X, s0.Max.X) || likewiseForY { etc }
171  	if r.Empty() {
172  		return ZR
173  	}
174  	return r
175  }
176
177  // Union returns the smallest rectangle that contains both r and s.
178  func (r Rectangle) Union(s Rectangle) Rectangle {
179  	if r.Empty() {
180  		return s
181  	}
182  	if s.Empty() {
183  		return r
184  	}
185  	if r.Min.X > s.Min.X {
186  		r.Min.X = s.Min.X
187  	}
188  	if r.Min.Y > s.Min.Y {
189  		r.Min.Y = s.Min.Y
190  	}
191  	if r.Max.X < s.Max.X {
192  		r.Max.X = s.Max.X
193  	}
194  	if r.Max.Y < s.Max.Y {
195  		r.Max.Y = s.Max.Y
196  	}
197  	return r
198  }
199
200  // Empty reports whether the rectangle contains no points.
201  func (r Rectangle) Empty() bool {
202  	return r.Min.X >= r.Max.X || r.Min.Y >= r.Max.Y
203  }
204
205  // Eq reports whether r and s contain the same set of points. All empty
206  // rectangles are considered equal.
207  func (r Rectangle) Eq(s Rectangle) bool {
208  	return r == s || r.Empty() && s.Empty()
209  }
210
211  // Overlaps reports whether r and s have a non-empty intersection.
212  func (r Rectangle) Overlaps(s Rectangle) bool {
213  	return !r.Empty() && !s.Empty() &&
214  		r.Min.X < s.Max.X && s.Min.X < r.Max.X &&
215  		r.Min.Y < s.Max.Y && s.Min.Y < r.Max.Y
216  }
217
218  // In reports whether every point in r is in s.
219  func (r Rectangle) In(s Rectangle) bool {
220  	if r.Empty() {
221  		return true
222  	}
223  	// Note that r.Max is an exclusive bound for r, so that r.In(s)
224  	// does not require that r.Max.In(s).
225  	return s.Min.X <= r.Min.X && r.Max.X <= s.Max.X &&
226  		s.Min.Y <= r.Min.Y && r.Max.Y <= s.Max.Y
227  }
228
229  // Canon returns the canonical version of r. The returned rectangle has minimum
230  // and maximum coordinates swapped if necessary so that it is well-formed.
231  func (r Rectangle) Canon() Rectangle {
232  	if r.Max.X < r.Min.X {
233  		r.Min.X, r.Max.X = r.Max.X, r.Min.X
234  	}
235  	if r.Max.Y < r.Min.Y {
236  		r.Min.Y, r.Max.Y = r.Max.Y, r.Min.Y
237  	}
238  	return r
239  }
240
241  // At implements the Image interface.
242  func (r Rectangle) At(x, y int) color.Color {
243  	if (Point{x, y}).In(r) {
244  		return color.Opaque
245  	}
246  	return color.Transparent
247  }
248
249  // RGBA64At implements the RGBA64Image interface.
250  func (r Rectangle) RGBA64At(x, y int) color.RGBA64 {
251  	if (Point{x, y}).In(r) {
252  		return color.RGBA64{0xffff, 0xffff, 0xffff, 0xffff}
253  	}
254  	return color.RGBA64{}
255  }
256
257  // Bounds implements the Image interface.
258  func (r Rectangle) Bounds() Rectangle {
259  	return r
260  }
261
262  // ColorModel implements the Image interface.
263  func (r Rectangle) ColorModel() color.Model {
264  	return color.Alpha16Model
265  }
266
267  // ZR is the zero Rectangle.
268  //
269  // Deprecated: Use a literal image.Rectangle{} instead.
270  var ZR Rectangle
271
272  // Rect is shorthand for Rectangle{Pt(x0, y0), Pt(x1, y1)}. The returned
273  // rectangle has minimum and maximum coordinates swapped if necessary so that
274  // it is well-formed.
275  func Rect(x0, y0, x1, y1 int) Rectangle {
276  	if x0 > x1 {
277  		x0, x1 = x1, x0
278  	}
279  	if y0 > y1 {
280  		y0, y1 = y1, y0
281  	}
282  	return Rectangle{Point{x0, y0}, Point{x1, y1}}
283  }
284
285  // mul3NonNeg returns (x * y * z), unless at least one argument is negative or
286  // if the computation overflows the int type, in which case it returns -1.
287  func mul3NonNeg(x int, y int, z int) int {
288  	if (x < 0) || (y < 0) || (z < 0) {
289  		return -1
290  	}
291  	hi, lo := bits.Mul64(uint64(x), uint64(y))
292  	if hi != 0 {
293  		return -1
294  	}
295  	hi, lo = bits.Mul64(lo, uint64(z))
296  	if hi != 0 {
297  		return -1
298  	}
299  	a := int(lo)
300  	if (a < 0) || (uint64(a) != lo) {
301  		return -1
302  	}
303  	return a
304  }
305
306  // add2NonNeg returns (x + y), unless at least one argument is negative or if
307  // the computation overflows the int type, in which case it returns -1.
308  func add2NonNeg(x int, y int) int {
309  	if (x < 0) || (y < 0) {
310  		return -1
311  	}
312  	a := x + y
313  	if a < 0 {
314  		return -1
315  	}
316  	return a
317  }
318
```

View as plain text