...

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

View as plain text