diff options
Diffstat (limited to 'vendor/github.com/golang/geo')
66 files changed, 0 insertions, 21547 deletions
diff --git a/vendor/github.com/golang/geo/LICENSE b/vendor/github.com/golang/geo/LICENSE deleted file mode 100644 index d64569567..000000000 --- a/vendor/github.com/golang/geo/LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/vendor/github.com/golang/geo/r1/doc.go b/vendor/github.com/golang/geo/r1/doc.go deleted file mode 100644 index c6b65c0e0..000000000 --- a/vendor/github.com/golang/geo/r1/doc.go +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/* -Package r1 implements types and functions for working with geometry in ℝ¹. - -See ../s2 for a more detailed overview. -*/ -package r1 diff --git a/vendor/github.com/golang/geo/r1/interval.go b/vendor/github.com/golang/geo/r1/interval.go deleted file mode 100644 index 48ea51982..000000000 --- a/vendor/github.com/golang/geo/r1/interval.go +++ /dev/null @@ -1,177 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package r1 - -import ( - "fmt" - "math" -) - -// Interval represents a closed interval on ℝ. -// Zero-length intervals (where Lo == Hi) represent single points. -// If Lo > Hi then the interval is empty. -type Interval struct { - Lo, Hi float64 -} - -// EmptyInterval returns an empty interval. -func EmptyInterval() Interval { return Interval{1, 0} } - -// IntervalFromPoint returns an interval representing a single point. -func IntervalFromPoint(p float64) Interval { return Interval{p, p} } - -// IsEmpty reports whether the interval is empty. -func (i Interval) IsEmpty() bool { return i.Lo > i.Hi } - -// Equal returns true iff the interval contains the same points as oi. -func (i Interval) Equal(oi Interval) bool { - return i == oi || i.IsEmpty() && oi.IsEmpty() -} - -// Center returns the midpoint of the interval. -// It is undefined for empty intervals. -func (i Interval) Center() float64 { return 0.5 * (i.Lo + i.Hi) } - -// Length returns the length of the interval. -// The length of an empty interval is negative. -func (i Interval) Length() float64 { return i.Hi - i.Lo } - -// Contains returns true iff the interval contains p. -func (i Interval) Contains(p float64) bool { return i.Lo <= p && p <= i.Hi } - -// ContainsInterval returns true iff the interval contains oi. -func (i Interval) ContainsInterval(oi Interval) bool { - if oi.IsEmpty() { - return true - } - return i.Lo <= oi.Lo && oi.Hi <= i.Hi -} - -// InteriorContains returns true iff the interval strictly contains p. -func (i Interval) InteriorContains(p float64) bool { - return i.Lo < p && p < i.Hi -} - -// InteriorContainsInterval returns true iff the interval strictly contains oi. -func (i Interval) InteriorContainsInterval(oi Interval) bool { - if oi.IsEmpty() { - return true - } - return i.Lo < oi.Lo && oi.Hi < i.Hi -} - -// Intersects returns true iff the interval contains any points in common with oi. -func (i Interval) Intersects(oi Interval) bool { - if i.Lo <= oi.Lo { - return oi.Lo <= i.Hi && oi.Lo <= oi.Hi // oi.Lo ∈ i and oi is not empty - } - return i.Lo <= oi.Hi && i.Lo <= i.Hi // i.Lo ∈ oi and i is not empty -} - -// InteriorIntersects returns true iff the interior of the interval contains any points in common with oi, including the latter's boundary. -func (i Interval) InteriorIntersects(oi Interval) bool { - return oi.Lo < i.Hi && i.Lo < oi.Hi && i.Lo < i.Hi && oi.Lo <= oi.Hi -} - -// Intersection returns the interval containing all points common to i and j. -func (i Interval) Intersection(j Interval) Interval { - // Empty intervals do not need to be special-cased. - return Interval{ - Lo: math.Max(i.Lo, j.Lo), - Hi: math.Min(i.Hi, j.Hi), - } -} - -// AddPoint returns the interval expanded so that it contains the given point. -func (i Interval) AddPoint(p float64) Interval { - if i.IsEmpty() { - return Interval{p, p} - } - if p < i.Lo { - return Interval{p, i.Hi} - } - if p > i.Hi { - return Interval{i.Lo, p} - } - return i -} - -// ClampPoint returns the closest point in the interval to the given point "p". -// The interval must be non-empty. -func (i Interval) ClampPoint(p float64) float64 { - return math.Max(i.Lo, math.Min(i.Hi, p)) -} - -// Expanded returns an interval that has been expanded on each side by margin. -// If margin is negative, then the function shrinks the interval on -// each side by margin instead. The resulting interval may be empty. Any -// expansion of an empty interval remains empty. -func (i Interval) Expanded(margin float64) Interval { - if i.IsEmpty() { - return i - } - return Interval{i.Lo - margin, i.Hi + margin} -} - -// Union returns the smallest interval that contains this interval and the given interval. -func (i Interval) Union(other Interval) Interval { - if i.IsEmpty() { - return other - } - if other.IsEmpty() { - return i - } - return Interval{math.Min(i.Lo, other.Lo), math.Max(i.Hi, other.Hi)} -} - -func (i Interval) String() string { return fmt.Sprintf("[%.7f, %.7f]", i.Lo, i.Hi) } - -const ( - // epsilon is a small number that represents a reasonable level of noise between two - // values that can be considered to be equal. - epsilon = 1e-15 - // dblEpsilon is a smaller number for values that require more precision. - // This is the C++ DBL_EPSILON equivalent. - dblEpsilon = 2.220446049250313e-16 -) - -// ApproxEqual reports whether the interval can be transformed into the -// given interval by moving each endpoint a small distance. -// The empty interval is considered to be positioned arbitrarily on the -// real line, so any interval with a small enough length will match -// the empty interval. -func (i Interval) ApproxEqual(other Interval) bool { - if i.IsEmpty() { - return other.Length() <= 2*epsilon - } - if other.IsEmpty() { - return i.Length() <= 2*epsilon - } - return math.Abs(other.Lo-i.Lo) <= epsilon && - math.Abs(other.Hi-i.Hi) <= epsilon -} - -// DirectedHausdorffDistance returns the Hausdorff distance to the given interval. For two -// intervals x and y, this distance is defined as -// h(x, y) = max_{p in x} min_{q in y} d(p, q). -func (i Interval) DirectedHausdorffDistance(other Interval) float64 { - if i.IsEmpty() { - return 0 - } - if other.IsEmpty() { - return math.Inf(1) - } - return math.Max(0, math.Max(i.Hi-other.Hi, other.Lo-i.Lo)) -} diff --git a/vendor/github.com/golang/geo/r2/doc.go b/vendor/github.com/golang/geo/r2/doc.go deleted file mode 100644 index 05b155543..000000000 --- a/vendor/github.com/golang/geo/r2/doc.go +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/* -Package r2 implements types and functions for working with geometry in ℝ². - -See package s2 for a more detailed overview. -*/ -package r2 diff --git a/vendor/github.com/golang/geo/r2/rect.go b/vendor/github.com/golang/geo/r2/rect.go deleted file mode 100644 index 495545bba..000000000 --- a/vendor/github.com/golang/geo/r2/rect.go +++ /dev/null @@ -1,255 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package r2 - -import ( - "fmt" - "math" - - "github.com/golang/geo/r1" -) - -// Point represents a point in ℝ². -type Point struct { - X, Y float64 -} - -// Add returns the sum of p and op. -func (p Point) Add(op Point) Point { return Point{p.X + op.X, p.Y + op.Y} } - -// Sub returns the difference of p and op. -func (p Point) Sub(op Point) Point { return Point{p.X - op.X, p.Y - op.Y} } - -// Mul returns the scalar product of p and m. -func (p Point) Mul(m float64) Point { return Point{m * p.X, m * p.Y} } - -// Ortho returns a counterclockwise orthogonal point with the same norm. -func (p Point) Ortho() Point { return Point{-p.Y, p.X} } - -// Dot returns the dot product between p and op. -func (p Point) Dot(op Point) float64 { return p.X*op.X + p.Y*op.Y } - -// Cross returns the cross product of p and op. -func (p Point) Cross(op Point) float64 { return p.X*op.Y - p.Y*op.X } - -// Norm returns the vector's norm. -func (p Point) Norm() float64 { return math.Hypot(p.X, p.Y) } - -// Normalize returns a unit point in the same direction as p. -func (p Point) Normalize() Point { - if p.X == 0 && p.Y == 0 { - return p - } - return p.Mul(1 / p.Norm()) -} - -func (p Point) String() string { return fmt.Sprintf("(%.12f, %.12f)", p.X, p.Y) } - -// Rect represents a closed axis-aligned rectangle in the (x,y) plane. -type Rect struct { - X, Y r1.Interval -} - -// RectFromPoints constructs a rect that contains the given points. -func RectFromPoints(pts ...Point) Rect { - // Because the default value on interval is 0,0, we need to manually - // define the interval from the first point passed in as our starting - // interval, otherwise we end up with the case of passing in - // Point{0.2, 0.3} and getting the starting Rect of {0, 0.2}, {0, 0.3} - // instead of the Rect {0.2, 0.2}, {0.3, 0.3} which is not correct. - if len(pts) == 0 { - return Rect{} - } - - r := Rect{ - X: r1.Interval{Lo: pts[0].X, Hi: pts[0].X}, - Y: r1.Interval{Lo: pts[0].Y, Hi: pts[0].Y}, - } - - for _, p := range pts[1:] { - r = r.AddPoint(p) - } - return r -} - -// RectFromCenterSize constructs a rectangle with the given center and size. -// Both dimensions of size must be non-negative. -func RectFromCenterSize(center, size Point) Rect { - return Rect{ - r1.Interval{Lo: center.X - size.X/2, Hi: center.X + size.X/2}, - r1.Interval{Lo: center.Y - size.Y/2, Hi: center.Y + size.Y/2}, - } -} - -// EmptyRect constructs the canonical empty rectangle. Use IsEmpty() to test -// for empty rectangles, since they have more than one representation. A Rect{} -// is not the same as the EmptyRect. -func EmptyRect() Rect { - return Rect{r1.EmptyInterval(), r1.EmptyInterval()} -} - -// IsValid reports whether the rectangle is valid. -// This requires the width to be empty iff the height is empty. -func (r Rect) IsValid() bool { - return r.X.IsEmpty() == r.Y.IsEmpty() -} - -// IsEmpty reports whether the rectangle is empty. -func (r Rect) IsEmpty() bool { - return r.X.IsEmpty() -} - -// Vertices returns all four vertices of the rectangle. Vertices are returned in -// CCW direction starting with the lower left corner. -func (r Rect) Vertices() [4]Point { - return [4]Point{ - {r.X.Lo, r.Y.Lo}, - {r.X.Hi, r.Y.Lo}, - {r.X.Hi, r.Y.Hi}, - {r.X.Lo, r.Y.Hi}, - } -} - -// VertexIJ returns the vertex in direction i along the X-axis (0=left, 1=right) and -// direction j along the Y-axis (0=down, 1=up). -func (r Rect) VertexIJ(i, j int) Point { - x := r.X.Lo - if i == 1 { - x = r.X.Hi - } - y := r.Y.Lo - if j == 1 { - y = r.Y.Hi - } - return Point{x, y} -} - -// Lo returns the low corner of the rect. -func (r Rect) Lo() Point { - return Point{r.X.Lo, r.Y.Lo} -} - -// Hi returns the high corner of the rect. -func (r Rect) Hi() Point { - return Point{r.X.Hi, r.Y.Hi} -} - -// Center returns the center of the rectangle in (x,y)-space -func (r Rect) Center() Point { - return Point{r.X.Center(), r.Y.Center()} -} - -// Size returns the width and height of this rectangle in (x,y)-space. Empty -// rectangles have a negative width and height. -func (r Rect) Size() Point { - return Point{r.X.Length(), r.Y.Length()} -} - -// ContainsPoint reports whether the rectangle contains the given point. -// Rectangles are closed regions, i.e. they contain their boundary. -func (r Rect) ContainsPoint(p Point) bool { - return r.X.Contains(p.X) && r.Y.Contains(p.Y) -} - -// InteriorContainsPoint returns true iff the given point is contained in the interior -// of the region (i.e. the region excluding its boundary). -func (r Rect) InteriorContainsPoint(p Point) bool { - return r.X.InteriorContains(p.X) && r.Y.InteriorContains(p.Y) -} - -// Contains reports whether the rectangle contains the given rectangle. -func (r Rect) Contains(other Rect) bool { - return r.X.ContainsInterval(other.X) && r.Y.ContainsInterval(other.Y) -} - -// InteriorContains reports whether the interior of this rectangle contains all of the -// points of the given other rectangle (including its boundary). -func (r Rect) InteriorContains(other Rect) bool { - return r.X.InteriorContainsInterval(other.X) && r.Y.InteriorContainsInterval(other.Y) -} - -// Intersects reports whether this rectangle and the other rectangle have any points in common. -func (r Rect) Intersects(other Rect) bool { - return r.X.Intersects(other.X) && r.Y.Intersects(other.Y) -} - -// InteriorIntersects reports whether the interior of this rectangle intersects -// any point (including the boundary) of the given other rectangle. -func (r Rect) InteriorIntersects(other Rect) bool { - return r.X.InteriorIntersects(other.X) && r.Y.InteriorIntersects(other.Y) -} - -// AddPoint expands the rectangle to include the given point. The rectangle is -// expanded by the minimum amount possible. -func (r Rect) AddPoint(p Point) Rect { - return Rect{r.X.AddPoint(p.X), r.Y.AddPoint(p.Y)} -} - -// AddRect expands the rectangle to include the given rectangle. This is the -// same as replacing the rectangle by the union of the two rectangles, but -// is more efficient. -func (r Rect) AddRect(other Rect) Rect { - return Rect{r.X.Union(other.X), r.Y.Union(other.Y)} -} - -// ClampPoint returns the closest point in the rectangle to the given point. -// The rectangle must be non-empty. -func (r Rect) ClampPoint(p Point) Point { - return Point{r.X.ClampPoint(p.X), r.Y.ClampPoint(p.Y)} -} - -// Expanded returns a rectangle that has been expanded in the x-direction -// by margin.X, and in y-direction by margin.Y. If either margin is empty, -// then shrink the interval on the corresponding sides instead. The resulting -// rectangle may be empty. Any expansion of an empty rectangle remains empty. -func (r Rect) Expanded(margin Point) Rect { - xx := r.X.Expanded(margin.X) - yy := r.Y.Expanded(margin.Y) - if xx.IsEmpty() || yy.IsEmpty() { - return EmptyRect() - } - return Rect{xx, yy} -} - -// ExpandedByMargin returns a Rect that has been expanded by the amount on all sides. -func (r Rect) ExpandedByMargin(margin float64) Rect { - return r.Expanded(Point{margin, margin}) -} - -// Union returns the smallest rectangle containing the union of this rectangle and -// the given rectangle. -func (r Rect) Union(other Rect) Rect { - return Rect{r.X.Union(other.X), r.Y.Union(other.Y)} -} - -// Intersection returns the smallest rectangle containing the intersection of this -// rectangle and the given rectangle. -func (r Rect) Intersection(other Rect) Rect { - xx := r.X.Intersection(other.X) - yy := r.Y.Intersection(other.Y) - if xx.IsEmpty() || yy.IsEmpty() { - return EmptyRect() - } - - return Rect{xx, yy} -} - -// ApproxEqual returns true if the x- and y-intervals of the two rectangles are -// the same up to the given tolerance. -func (r Rect) ApproxEqual(r2 Rect) bool { - return r.X.ApproxEqual(r2.X) && r.Y.ApproxEqual(r2.Y) -} - -func (r Rect) String() string { return fmt.Sprintf("[Lo%s, Hi%s]", r.Lo(), r.Hi()) } diff --git a/vendor/github.com/golang/geo/r3/doc.go b/vendor/github.com/golang/geo/r3/doc.go deleted file mode 100644 index 1eb4710c8..000000000 --- a/vendor/github.com/golang/geo/r3/doc.go +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/* -Package r3 implements types and functions for working with geometry in ℝ³. - -See ../s2 for a more detailed overview. -*/ -package r3 diff --git a/vendor/github.com/golang/geo/r3/precisevector.go b/vendor/github.com/golang/geo/r3/precisevector.go deleted file mode 100644 index b13393dbc..000000000 --- a/vendor/github.com/golang/geo/r3/precisevector.go +++ /dev/null @@ -1,198 +0,0 @@ -// Copyright 2016 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package r3 - -import ( - "fmt" - "math/big" -) - -const ( - // prec is the number of bits of precision to use for the Float values. - // To keep things simple, we use the maximum allowable precision on big - // values. This allows us to handle all values we expect in the s2 library. - prec = big.MaxPrec -) - -// define some commonly referenced values. -var ( - precise0 = precInt(0) - precise1 = precInt(1) -) - -// precStr wraps the conversion from a string into a big.Float. For results that -// actually can be represented exactly, this should only be used on values that -// are integer multiples of integer powers of 2. -func precStr(s string) *big.Float { - // Explicitly ignoring the bool return for this usage. - f, _ := new(big.Float).SetPrec(prec).SetString(s) - return f -} - -func precInt(i int64) *big.Float { - return new(big.Float).SetPrec(prec).SetInt64(i) -} - -func precFloat(f float64) *big.Float { - return new(big.Float).SetPrec(prec).SetFloat64(f) -} - -func precAdd(a, b *big.Float) *big.Float { - return new(big.Float).SetPrec(prec).Add(a, b) -} - -func precSub(a, b *big.Float) *big.Float { - return new(big.Float).SetPrec(prec).Sub(a, b) -} - -func precMul(a, b *big.Float) *big.Float { - return new(big.Float).SetPrec(prec).Mul(a, b) -} - -// PreciseVector represents a point in ℝ³ using high-precision values. -// Note that this is NOT a complete implementation because there are some -// operations that Vector supports that are not feasible with arbitrary precision -// math. (e.g., methods that need division like Normalize, or methods needing a -// square root operation such as Norm) -type PreciseVector struct { - X, Y, Z *big.Float -} - -// PreciseVectorFromVector creates a high precision vector from the given Vector. -func PreciseVectorFromVector(v Vector) PreciseVector { - return NewPreciseVector(v.X, v.Y, v.Z) -} - -// NewPreciseVector creates a high precision vector from the given floating point values. -func NewPreciseVector(x, y, z float64) PreciseVector { - return PreciseVector{ - X: precFloat(x), - Y: precFloat(y), - Z: precFloat(z), - } -} - -// Vector returns this precise vector converted to a Vector. -func (v PreciseVector) Vector() Vector { - // The accuracy flag is ignored on these conversions back to float64. - x, _ := v.X.Float64() - y, _ := v.Y.Float64() - z, _ := v.Z.Float64() - return Vector{x, y, z}.Normalize() -} - -// Equal reports whether v and ov are equal. -func (v PreciseVector) Equal(ov PreciseVector) bool { - return v.X.Cmp(ov.X) == 0 && v.Y.Cmp(ov.Y) == 0 && v.Z.Cmp(ov.Z) == 0 -} - -func (v PreciseVector) String() string { - return fmt.Sprintf("(%10g, %10g, %10g)", v.X, v.Y, v.Z) -} - -// Norm2 returns the square of the norm. -func (v PreciseVector) Norm2() *big.Float { return v.Dot(v) } - -// IsUnit reports whether this vector is of unit length. -func (v PreciseVector) IsUnit() bool { - return v.Norm2().Cmp(precise1) == 0 -} - -// Abs returns the vector with nonnegative components. -func (v PreciseVector) Abs() PreciseVector { - return PreciseVector{ - X: new(big.Float).Abs(v.X), - Y: new(big.Float).Abs(v.Y), - Z: new(big.Float).Abs(v.Z), - } -} - -// Add returns the standard vector sum of v and ov. -func (v PreciseVector) Add(ov PreciseVector) PreciseVector { - return PreciseVector{ - X: precAdd(v.X, ov.X), - Y: precAdd(v.Y, ov.Y), - Z: precAdd(v.Z, ov.Z), - } -} - -// Sub returns the standard vector difference of v and ov. -func (v PreciseVector) Sub(ov PreciseVector) PreciseVector { - return PreciseVector{ - X: precSub(v.X, ov.X), - Y: precSub(v.Y, ov.Y), - Z: precSub(v.Z, ov.Z), - } -} - -// Mul returns the standard scalar product of v and f. -func (v PreciseVector) Mul(f *big.Float) PreciseVector { - return PreciseVector{ - X: precMul(v.X, f), - Y: precMul(v.Y, f), - Z: precMul(v.Z, f), - } -} - -// MulByFloat64 returns the standard scalar product of v and f. -func (v PreciseVector) MulByFloat64(f float64) PreciseVector { - return v.Mul(precFloat(f)) -} - -// Dot returns the standard dot product of v and ov. -func (v PreciseVector) Dot(ov PreciseVector) *big.Float { - return precAdd(precMul(v.X, ov.X), precAdd(precMul(v.Y, ov.Y), precMul(v.Z, ov.Z))) -} - -// Cross returns the standard cross product of v and ov. -func (v PreciseVector) Cross(ov PreciseVector) PreciseVector { - return PreciseVector{ - X: precSub(precMul(v.Y, ov.Z), precMul(v.Z, ov.Y)), - Y: precSub(precMul(v.Z, ov.X), precMul(v.X, ov.Z)), - Z: precSub(precMul(v.X, ov.Y), precMul(v.Y, ov.X)), - } -} - -// LargestComponent returns the axis that represents the largest component in this vector. -func (v PreciseVector) LargestComponent() Axis { - t := v.Abs() - - if t.X.Cmp(t.Y) > 0 { - if t.X.Cmp(t.Z) > 0 { - return XAxis - } - return ZAxis - } - if t.Y.Cmp(t.Z) > 0 { - return YAxis - } - return ZAxis -} - -// SmallestComponent returns the axis that represents the smallest component in this vector. -func (v PreciseVector) SmallestComponent() Axis { - t := v.Abs() - - if t.X.Cmp(t.Y) < 0 { - if t.X.Cmp(t.Z) < 0 { - return XAxis - } - return ZAxis - } - if t.Y.Cmp(t.Z) < 0 { - return YAxis - } - return ZAxis -} diff --git a/vendor/github.com/golang/geo/r3/vector.go b/vendor/github.com/golang/geo/r3/vector.go deleted file mode 100644 index ccda622f4..000000000 --- a/vendor/github.com/golang/geo/r3/vector.go +++ /dev/null @@ -1,183 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package r3 - -import ( - "fmt" - "math" - - "github.com/golang/geo/s1" -) - -// Vector represents a point in ℝ³. -type Vector struct { - X, Y, Z float64 -} - -// ApproxEqual reports whether v and ov are equal within a small epsilon. -func (v Vector) ApproxEqual(ov Vector) bool { - const epsilon = 1e-16 - return math.Abs(v.X-ov.X) < epsilon && math.Abs(v.Y-ov.Y) < epsilon && math.Abs(v.Z-ov.Z) < epsilon -} - -func (v Vector) String() string { return fmt.Sprintf("(%0.24f, %0.24f, %0.24f)", v.X, v.Y, v.Z) } - -// Norm returns the vector's norm. -func (v Vector) Norm() float64 { return math.Sqrt(v.Dot(v)) } - -// Norm2 returns the square of the norm. -func (v Vector) Norm2() float64 { return v.Dot(v) } - -// Normalize returns a unit vector in the same direction as v. -func (v Vector) Normalize() Vector { - n2 := v.Norm2() - if n2 == 0 { - return Vector{0, 0, 0} - } - return v.Mul(1 / math.Sqrt(n2)) -} - -// IsUnit returns whether this vector is of approximately unit length. -func (v Vector) IsUnit() bool { - const epsilon = 5e-14 - return math.Abs(v.Norm2()-1) <= epsilon -} - -// Abs returns the vector with nonnegative components. -func (v Vector) Abs() Vector { return Vector{math.Abs(v.X), math.Abs(v.Y), math.Abs(v.Z)} } - -// Add returns the standard vector sum of v and ov. -func (v Vector) Add(ov Vector) Vector { return Vector{v.X + ov.X, v.Y + ov.Y, v.Z + ov.Z} } - -// Sub returns the standard vector difference of v and ov. -func (v Vector) Sub(ov Vector) Vector { return Vector{v.X - ov.X, v.Y - ov.Y, v.Z - ov.Z} } - -// Mul returns the standard scalar product of v and m. -func (v Vector) Mul(m float64) Vector { return Vector{m * v.X, m * v.Y, m * v.Z} } - -// Dot returns the standard dot product of v and ov. -func (v Vector) Dot(ov Vector) float64 { return v.X*ov.X + v.Y*ov.Y + v.Z*ov.Z } - -// Cross returns the standard cross product of v and ov. -func (v Vector) Cross(ov Vector) Vector { - return Vector{ - v.Y*ov.Z - v.Z*ov.Y, - v.Z*ov.X - v.X*ov.Z, - v.X*ov.Y - v.Y*ov.X, - } -} - -// Distance returns the Euclidean distance between v and ov. -func (v Vector) Distance(ov Vector) float64 { return v.Sub(ov).Norm() } - -// Angle returns the angle between v and ov. -func (v Vector) Angle(ov Vector) s1.Angle { - return s1.Angle(math.Atan2(v.Cross(ov).Norm(), v.Dot(ov))) * s1.Radian -} - -// Axis enumerates the 3 axes of ℝ³. -type Axis int - -// The three axes of ℝ³. -const ( - XAxis Axis = iota - YAxis - ZAxis -) - -// Ortho returns a unit vector that is orthogonal to v. -// Ortho(-v) = -Ortho(v) for all v. -func (v Vector) Ortho() Vector { - ov := Vector{0.012, 0.0053, 0.00457} - switch v.LargestComponent() { - case XAxis: - ov.Z = 1 - case YAxis: - ov.X = 1 - default: - ov.Y = 1 - } - return v.Cross(ov).Normalize() -} - -// LargestComponent returns the axis that represents the largest component in this vector. -func (v Vector) LargestComponent() Axis { - t := v.Abs() - - if t.X > t.Y { - if t.X > t.Z { - return XAxis - } - return ZAxis - } - if t.Y > t.Z { - return YAxis - } - return ZAxis -} - -// SmallestComponent returns the axis that represents the smallest component in this vector. -func (v Vector) SmallestComponent() Axis { - t := v.Abs() - - if t.X < t.Y { - if t.X < t.Z { - return XAxis - } - return ZAxis - } - if t.Y < t.Z { - return YAxis - } - return ZAxis -} - -// Cmp compares v and ov lexicographically and returns: -// -// -1 if v < ov -// 0 if v == ov -// +1 if v > ov -// -// This method is based on C++'s std::lexicographical_compare. Two entities -// are compared element by element with the given operator. The first mismatch -// defines which is less (or greater) than the other. If both have equivalent -// values they are lexicographically equal. -func (v Vector) Cmp(ov Vector) int { - if v.X < ov.X { - return -1 - } - if v.X > ov.X { - return 1 - } - - // First elements were the same, try the next. - if v.Y < ov.Y { - return -1 - } - if v.Y > ov.Y { - return 1 - } - - // Second elements were the same return the final compare. - if v.Z < ov.Z { - return -1 - } - if v.Z > ov.Z { - return 1 - } - - // Both are equal - return 0 -} diff --git a/vendor/github.com/golang/geo/s1/angle.go b/vendor/github.com/golang/geo/s1/angle.go deleted file mode 100644 index 747b23dea..000000000 --- a/vendor/github.com/golang/geo/s1/angle.go +++ /dev/null @@ -1,120 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s1 - -import ( - "math" - "strconv" -) - -// Angle represents a 1D angle. The internal representation is a double precision -// value in radians, so conversion to and from radians is exact. -// Conversions between E5, E6, E7, and Degrees are not always -// exact. For example, Degrees(3.1) is different from E6(3100000) or E7(31000000). -// -// The following conversions between degrees and radians are exact: -// -// Degree*180 == Radian*math.Pi -// Degree*(180/n) == Radian*(math.Pi/n) for n == 0..8 -// -// These identities hold when the arguments are scaled up or down by any power -// of 2. Some similar identities are also true, for example, -// -// Degree*60 == Radian*(math.Pi/3) -// -// But be aware that this type of identity does not hold in general. For example, -// -// Degree*3 != Radian*(math.Pi/60) -// -// Similarly, the conversion to radians means that (Angle(x)*Degree).Degrees() -// does not always equal x. For example, -// -// (Angle(45*n)*Degree).Degrees() == 45*n for n == 0..8 -// -// but -// -// (60*Degree).Degrees() != 60 -// -// When testing for equality, you should allow for numerical errors (ApproxEqual) -// or convert to discrete E5/E6/E7 values first. -type Angle float64 - -// Angle units. -const ( - Radian Angle = 1 - Degree = (math.Pi / 180) * Radian - - E5 = 1e-5 * Degree - E6 = 1e-6 * Degree - E7 = 1e-7 * Degree -) - -// Radians returns the angle in radians. -func (a Angle) Radians() float64 { return float64(a) } - -// Degrees returns the angle in degrees. -func (a Angle) Degrees() float64 { return float64(a / Degree) } - -// round returns the value rounded to nearest as an int32. -// This does not match C++ exactly for the case of x.5. -func round(val float64) int32 { - if val < 0 { - return int32(val - 0.5) - } - return int32(val + 0.5) -} - -// InfAngle returns an angle larger than any finite angle. -func InfAngle() Angle { - return Angle(math.Inf(1)) -} - -// isInf reports whether this Angle is infinite. -func (a Angle) isInf() bool { - return math.IsInf(float64(a), 0) -} - -// E5 returns the angle in hundred thousandths of degrees. -func (a Angle) E5() int32 { return round(a.Degrees() * 1e5) } - -// E6 returns the angle in millionths of degrees. -func (a Angle) E6() int32 { return round(a.Degrees() * 1e6) } - -// E7 returns the angle in ten millionths of degrees. -func (a Angle) E7() int32 { return round(a.Degrees() * 1e7) } - -// Abs returns the absolute value of the angle. -func (a Angle) Abs() Angle { return Angle(math.Abs(float64(a))) } - -// Normalized returns an equivalent angle in (-π, π]. -func (a Angle) Normalized() Angle { - rad := math.Remainder(float64(a), 2*math.Pi) - if rad <= -math.Pi { - rad = math.Pi - } - return Angle(rad) -} - -func (a Angle) String() string { - return strconv.FormatFloat(a.Degrees(), 'f', 7, 64) // like "%.7f" -} - -// ApproxEqual reports whether the two angles are the same up to a small tolerance. -func (a Angle) ApproxEqual(other Angle) bool { - return math.Abs(float64(a)-float64(other)) <= epsilon -} - -// BUG(dsymonds): The major differences from the C++ version are: -// - no unsigned E5/E6/E7 methods diff --git a/vendor/github.com/golang/geo/s1/chordangle.go b/vendor/github.com/golang/geo/s1/chordangle.go deleted file mode 100644 index 77d71648f..000000000 --- a/vendor/github.com/golang/geo/s1/chordangle.go +++ /dev/null @@ -1,320 +0,0 @@ -// Copyright 2015 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s1 - -import ( - "math" -) - -// ChordAngle represents the angle subtended by a chord (i.e., the straight -// line segment connecting two points on the sphere). Its representation -// makes it very efficient for computing and comparing distances, but unlike -// Angle it is only capable of representing angles between 0 and π radians. -// Generally, ChordAngle should only be used in loops where many angles need -// to be calculated and compared. Otherwise it is simpler to use Angle. -// -// ChordAngle loses some accuracy as the angle approaches π radians. -// There are several different ways to measure this error, including the -// representational error (i.e., how accurately ChordAngle can represent -// angles near π radians), the conversion error (i.e., how much precision is -// lost when an Angle is converted to an ChordAngle), and the measurement -// error (i.e., how accurate the ChordAngle(a, b) constructor is when the -// points A and B are separated by angles close to π radians). All of these -// errors differ by a small constant factor. -// -// For the measurement error (which is the largest of these errors and also -// the most important in practice), let the angle between A and B be (π - x) -// radians, i.e. A and B are within "x" radians of being antipodal. The -// corresponding chord length is -// -// r = 2 * sin((π - x) / 2) = 2 * cos(x / 2) -// -// For values of x not close to π the relative error in the squared chord -// length is at most 4.5 * dblEpsilon (see MaxPointError below). -// The relative error in "r" is thus at most 2.25 * dblEpsilon ~= 5e-16. To -// convert this error into an equivalent angle, we have -// -// |dr / dx| = sin(x / 2) -// -// and therefore -// -// |dx| = dr / sin(x / 2) -// = 5e-16 * (2 * cos(x / 2)) / sin(x / 2) -// = 1e-15 / tan(x / 2) -// -// The maximum error is attained when -// -// x = |dx| -// = 1e-15 / tan(x / 2) -// ~= 1e-15 / (x / 2) -// ~= sqrt(2e-15) -// -// In summary, the measurement error for an angle (π - x) is at most -// -// dx = min(1e-15 / tan(x / 2), sqrt(2e-15)) -// (~= min(2e-15 / x, sqrt(2e-15)) when x is small) -// -// On the Earth's surface (assuming a radius of 6371km), this corresponds to -// the following worst-case measurement errors: -// -// Accuracy: Unless antipodal to within: -// --------- --------------------------- -// 6.4 nanometers 10,000 km (90 degrees) -// 1 micrometer 81.2 kilometers -// 1 millimeter 81.2 meters -// 1 centimeter 8.12 meters -// 28.5 centimeters 28.5 centimeters -// -// The representational and conversion errors referred to earlier are somewhat -// smaller than this. For example, maximum distance between adjacent -// representable ChordAngle values is only 13.5 cm rather than 28.5 cm. To -// see this, observe that the closest representable value to r^2 = 4 is -// r^2 = 4 * (1 - dblEpsilon / 2). Thus r = 2 * (1 - dblEpsilon / 4) and -// the angle between these two representable values is -// -// x = 2 * acos(r / 2) -// = 2 * acos(1 - dblEpsilon / 4) -// ~= 2 * asin(sqrt(dblEpsilon / 2) -// ~= sqrt(2 * dblEpsilon) -// ~= 2.1e-8 -// -// which is 13.5 cm on the Earth's surface. -// -// The worst case rounding error occurs when the value halfway between these -// two representable values is rounded up to 4. This halfway value is -// r^2 = (4 * (1 - dblEpsilon / 4)), thus r = 2 * (1 - dblEpsilon / 8) and -// the worst case rounding error is -// -// x = 2 * acos(r / 2) -// = 2 * acos(1 - dblEpsilon / 8) -// ~= 2 * asin(sqrt(dblEpsilon / 4) -// ~= sqrt(dblEpsilon) -// ~= 1.5e-8 -// -// which is 9.5 cm on the Earth's surface. -type ChordAngle float64 - -const ( - // NegativeChordAngle represents a chord angle smaller than the zero angle. - // The only valid operations on a NegativeChordAngle are comparisons, - // Angle conversions, and Successor/Predecessor. - NegativeChordAngle = ChordAngle(-1) - - // RightChordAngle represents a chord angle of 90 degrees (a "right angle"). - RightChordAngle = ChordAngle(2) - - // StraightChordAngle represents a chord angle of 180 degrees (a "straight angle"). - // This is the maximum finite chord angle. - StraightChordAngle = ChordAngle(4) - - // maxLength2 is the square of the maximum length allowed in a ChordAngle. - maxLength2 = 4.0 -) - -// ChordAngleFromAngle returns a ChordAngle from the given Angle. -func ChordAngleFromAngle(a Angle) ChordAngle { - if a < 0 { - return NegativeChordAngle - } - if a.isInf() { - return InfChordAngle() - } - l := 2 * math.Sin(0.5*math.Min(math.Pi, a.Radians())) - return ChordAngle(l * l) -} - -// ChordAngleFromSquaredLength returns a ChordAngle from the squared chord length. -// Note that the argument is automatically clamped to a maximum of 4 to -// handle possible roundoff errors. The argument must be non-negative. -func ChordAngleFromSquaredLength(length2 float64) ChordAngle { - if length2 > maxLength2 { - return StraightChordAngle - } - return ChordAngle(length2) -} - -// Expanded returns a new ChordAngle that has been adjusted by the given error -// bound (which can be positive or negative). Error should be the value -// returned by either MaxPointError or MaxAngleError. For example: -// a := ChordAngleFromPoints(x, y) -// a1 := a.Expanded(a.MaxPointError()) -func (c ChordAngle) Expanded(e float64) ChordAngle { - // If the angle is special, don't change it. Otherwise clamp it to the valid range. - if c.isSpecial() { - return c - } - return ChordAngle(math.Max(0.0, math.Min(maxLength2, float64(c)+e))) -} - -// Angle converts this ChordAngle to an Angle. -func (c ChordAngle) Angle() Angle { - if c < 0 { - return -1 * Radian - } - if c.isInf() { - return InfAngle() - } - return Angle(2 * math.Asin(0.5*math.Sqrt(float64(c)))) -} - -// InfChordAngle returns a chord angle larger than any finite chord angle. -// The only valid operations on an InfChordAngle are comparisons, Angle -// conversions, and Successor/Predecessor. -func InfChordAngle() ChordAngle { - return ChordAngle(math.Inf(1)) -} - -// isInf reports whether this ChordAngle is infinite. -func (c ChordAngle) isInf() bool { - return math.IsInf(float64(c), 1) -} - -// isSpecial reports whether this ChordAngle is one of the special cases. -func (c ChordAngle) isSpecial() bool { - return c < 0 || c.isInf() -} - -// isValid reports whether this ChordAngle is valid or not. -func (c ChordAngle) isValid() bool { - return (c >= 0 && c <= maxLength2) || c.isSpecial() -} - -// Successor returns the smallest representable ChordAngle larger than this one. -// This can be used to convert a "<" comparison to a "<=" comparison. -// -// Note the following special cases: -// NegativeChordAngle.Successor == 0 -// StraightChordAngle.Successor == InfChordAngle -// InfChordAngle.Successor == InfChordAngle -func (c ChordAngle) Successor() ChordAngle { - if c >= maxLength2 { - return InfChordAngle() - } - if c < 0 { - return 0 - } - return ChordAngle(math.Nextafter(float64(c), 10.0)) -} - -// Predecessor returns the largest representable ChordAngle less than this one. -// -// Note the following special cases: -// InfChordAngle.Predecessor == StraightChordAngle -// ChordAngle(0).Predecessor == NegativeChordAngle -// NegativeChordAngle.Predecessor == NegativeChordAngle -func (c ChordAngle) Predecessor() ChordAngle { - if c <= 0 { - return NegativeChordAngle - } - if c > maxLength2 { - return StraightChordAngle - } - - return ChordAngle(math.Nextafter(float64(c), -10.0)) -} - -// MaxPointError returns the maximum error size for a ChordAngle constructed -// from 2 Points x and y, assuming that x and y are normalized to within the -// bounds guaranteed by s2.Point.Normalize. The error is defined with respect to -// the true distance after the points are projected to lie exactly on the sphere. -func (c ChordAngle) MaxPointError() float64 { - // There is a relative error of (2.5*dblEpsilon) when computing the squared - // distance, plus a relative error of 2 * dblEpsilon, plus an absolute error - // of (16 * dblEpsilon**2) because the lengths of the input points may differ - // from 1 by up to (2*dblEpsilon) each. (This is the maximum error in Normalize). - return 4.5*dblEpsilon*float64(c) + 16*dblEpsilon*dblEpsilon -} - -// MaxAngleError returns the maximum error for a ChordAngle constructed -// as an Angle distance. -func (c ChordAngle) MaxAngleError() float64 { - return dblEpsilon * float64(c) -} - -// Add adds the other ChordAngle to this one and returns the resulting value. -// This method assumes the ChordAngles are not special. -func (c ChordAngle) Add(other ChordAngle) ChordAngle { - // Note that this method (and Sub) is much more efficient than converting - // the ChordAngle to an Angle and adding those and converting back. It - // requires only one square root plus a few additions and multiplications. - - // Optimization for the common case where b is an error tolerance - // parameter that happens to be set to zero. - if other == 0 { - return c - } - - // Clamp the angle sum to at most 180 degrees. - if c+other >= maxLength2 { - return StraightChordAngle - } - - // Let a and b be the (non-squared) chord lengths, and let c = a+b. - // Let A, B, and C be the corresponding half-angles (a = 2*sin(A), etc). - // Then the formula below can be derived from c = 2 * sin(A+B) and the - // relationships sin(A+B) = sin(A)*cos(B) + sin(B)*cos(A) - // cos(X) = sqrt(1 - sin^2(X)) - x := float64(c * (1 - 0.25*other)) - y := float64(other * (1 - 0.25*c)) - return ChordAngle(math.Min(maxLength2, x+y+2*math.Sqrt(x*y))) -} - -// Sub subtracts the other ChordAngle from this one and returns the resulting -// value. This method assumes the ChordAngles are not special. -func (c ChordAngle) Sub(other ChordAngle) ChordAngle { - if other == 0 { - return c - } - if c <= other { - return 0 - } - x := float64(c * (1 - 0.25*other)) - y := float64(other * (1 - 0.25*c)) - return ChordAngle(math.Max(0.0, x+y-2*math.Sqrt(x*y))) -} - -// Sin returns the sine of this chord angle. This method is more efficient -// than converting to Angle and performing the computation. -func (c ChordAngle) Sin() float64 { - return math.Sqrt(c.Sin2()) -} - -// Sin2 returns the square of the sine of this chord angle. -// It is more efficient than Sin. -func (c ChordAngle) Sin2() float64 { - // Let a be the (non-squared) chord length, and let A be the corresponding - // half-angle (a = 2*sin(A)). The formula below can be derived from: - // sin(2*A) = 2 * sin(A) * cos(A) - // cos^2(A) = 1 - sin^2(A) - // This is much faster than converting to an angle and computing its sine. - return float64(c * (1 - 0.25*c)) -} - -// Cos returns the cosine of this chord angle. This method is more efficient -// than converting to Angle and performing the computation. -func (c ChordAngle) Cos() float64 { - // cos(2*A) = cos^2(A) - sin^2(A) = 1 - 2*sin^2(A) - return float64(1 - 0.5*c) -} - -// Tan returns the tangent of this chord angle. -func (c ChordAngle) Tan() float64 { - return c.Sin() / c.Cos() -} - -// TODO(roberts): Differences from C++: -// Helpers to/from E5/E6/E7 -// Helpers to/from degrees and radians directly. -// FastUpperBoundFrom(angle Angle) diff --git a/vendor/github.com/golang/geo/s1/doc.go b/vendor/github.com/golang/geo/s1/doc.go deleted file mode 100644 index 52a2c526d..000000000 --- a/vendor/github.com/golang/geo/s1/doc.go +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/* -Package s1 implements types and functions for working with geometry in S¹ (circular geometry). - -See ../s2 for a more detailed overview. -*/ -package s1 diff --git a/vendor/github.com/golang/geo/s1/interval.go b/vendor/github.com/golang/geo/s1/interval.go deleted file mode 100644 index 6fea5221f..000000000 --- a/vendor/github.com/golang/geo/s1/interval.go +++ /dev/null @@ -1,462 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s1 - -import ( - "math" - "strconv" -) - -// An Interval represents a closed interval on a unit circle (also known -// as a 1-dimensional sphere). It is capable of representing the empty -// interval (containing no points), the full interval (containing all -// points), and zero-length intervals (containing a single point). -// -// Points are represented by the angle they make with the positive x-axis in -// the range [-π, π]. An interval is represented by its lower and upper -// bounds (both inclusive, since the interval is closed). The lower bound may -// be greater than the upper bound, in which case the interval is "inverted" -// (i.e. it passes through the point (-1, 0)). -// -// The point (-1, 0) has two valid representations, π and -π. The -// normalized representation of this point is π, so that endpoints -// of normal intervals are in the range (-π, π]. We normalize the latter to -// the former in IntervalFromEndpoints. However, we take advantage of the point -// -π to construct two special intervals: -// The full interval is [-π, π] -// The empty interval is [π, -π]. -// -// Treat the exported fields as read-only. -type Interval struct { - Lo, Hi float64 -} - -// IntervalFromEndpoints constructs a new interval from endpoints. -// Both arguments must be in the range [-π,π]. This function allows inverted intervals -// to be created. -func IntervalFromEndpoints(lo, hi float64) Interval { - i := Interval{lo, hi} - if lo == -math.Pi && hi != math.Pi { - i.Lo = math.Pi - } - if hi == -math.Pi && lo != math.Pi { - i.Hi = math.Pi - } - return i -} - -// IntervalFromPointPair returns the minimal interval containing the two given points. -// Both arguments must be in [-π,π]. -func IntervalFromPointPair(a, b float64) Interval { - if a == -math.Pi { - a = math.Pi - } - if b == -math.Pi { - b = math.Pi - } - if positiveDistance(a, b) <= math.Pi { - return Interval{a, b} - } - return Interval{b, a} -} - -// EmptyInterval returns an empty interval. -func EmptyInterval() Interval { return Interval{math.Pi, -math.Pi} } - -// FullInterval returns a full interval. -func FullInterval() Interval { return Interval{-math.Pi, math.Pi} } - -// IsValid reports whether the interval is valid. -func (i Interval) IsValid() bool { - return (math.Abs(i.Lo) <= math.Pi && math.Abs(i.Hi) <= math.Pi && - !(i.Lo == -math.Pi && i.Hi != math.Pi) && - !(i.Hi == -math.Pi && i.Lo != math.Pi)) -} - -// IsFull reports whether the interval is full. -func (i Interval) IsFull() bool { return i.Lo == -math.Pi && i.Hi == math.Pi } - -// IsEmpty reports whether the interval is empty. -func (i Interval) IsEmpty() bool { return i.Lo == math.Pi && i.Hi == -math.Pi } - -// IsInverted reports whether the interval is inverted; that is, whether Lo > Hi. -func (i Interval) IsInverted() bool { return i.Lo > i.Hi } - -// Invert returns the interval with endpoints swapped. -func (i Interval) Invert() Interval { - return Interval{i.Hi, i.Lo} -} - -// Center returns the midpoint of the interval. -// It is undefined for full and empty intervals. -func (i Interval) Center() float64 { - c := 0.5 * (i.Lo + i.Hi) - if !i.IsInverted() { - return c - } - if c <= 0 { - return c + math.Pi - } - return c - math.Pi -} - -// Length returns the length of the interval. -// The length of an empty interval is negative. -func (i Interval) Length() float64 { - l := i.Hi - i.Lo - if l >= 0 { - return l - } - l += 2 * math.Pi - if l > 0 { - return l - } - return -1 -} - -// Assumes p ∈ (-π,π]. -func (i Interval) fastContains(p float64) bool { - if i.IsInverted() { - return (p >= i.Lo || p <= i.Hi) && !i.IsEmpty() - } - return p >= i.Lo && p <= i.Hi -} - -// Contains returns true iff the interval contains p. -// Assumes p ∈ [-π,π]. -func (i Interval) Contains(p float64) bool { - if p == -math.Pi { - p = math.Pi - } - return i.fastContains(p) -} - -// ContainsInterval returns true iff the interval contains oi. -func (i Interval) ContainsInterval(oi Interval) bool { - if i.IsInverted() { - if oi.IsInverted() { - return oi.Lo >= i.Lo && oi.Hi <= i.Hi - } - return (oi.Lo >= i.Lo || oi.Hi <= i.Hi) && !i.IsEmpty() - } - if oi.IsInverted() { - return i.IsFull() || oi.IsEmpty() - } - return oi.Lo >= i.Lo && oi.Hi <= i.Hi -} - -// InteriorContains returns true iff the interior of the interval contains p. -// Assumes p ∈ [-π,π]. -func (i Interval) InteriorContains(p float64) bool { - if p == -math.Pi { - p = math.Pi - } - if i.IsInverted() { - return p > i.Lo || p < i.Hi - } - return (p > i.Lo && p < i.Hi) || i.IsFull() -} - -// InteriorContainsInterval returns true iff the interior of the interval contains oi. -func (i Interval) InteriorContainsInterval(oi Interval) bool { - if i.IsInverted() { - if oi.IsInverted() { - return (oi.Lo > i.Lo && oi.Hi < i.Hi) || oi.IsEmpty() - } - return oi.Lo > i.Lo || oi.Hi < i.Hi - } - if oi.IsInverted() { - return i.IsFull() || oi.IsEmpty() - } - return (oi.Lo > i.Lo && oi.Hi < i.Hi) || i.IsFull() -} - -// Intersects returns true iff the interval contains any points in common with oi. -func (i Interval) Intersects(oi Interval) bool { - if i.IsEmpty() || oi.IsEmpty() { - return false - } - if i.IsInverted() { - return oi.IsInverted() || oi.Lo <= i.Hi || oi.Hi >= i.Lo - } - if oi.IsInverted() { - return oi.Lo <= i.Hi || oi.Hi >= i.Lo - } - return oi.Lo <= i.Hi && oi.Hi >= i.Lo -} - -// InteriorIntersects returns true iff the interior of the interval contains any points in common with oi, including the latter's boundary. -func (i Interval) InteriorIntersects(oi Interval) bool { - if i.IsEmpty() || oi.IsEmpty() || i.Lo == i.Hi { - return false - } - if i.IsInverted() { - return oi.IsInverted() || oi.Lo < i.Hi || oi.Hi > i.Lo - } - if oi.IsInverted() { - return oi.Lo < i.Hi || oi.Hi > i.Lo - } - return (oi.Lo < i.Hi && oi.Hi > i.Lo) || i.IsFull() -} - -// Compute distance from a to b in [0,2π], in a numerically stable way. -func positiveDistance(a, b float64) float64 { - d := b - a - if d >= 0 { - return d - } - return (b + math.Pi) - (a - math.Pi) -} - -// Union returns the smallest interval that contains both the interval and oi. -func (i Interval) Union(oi Interval) Interval { - if oi.IsEmpty() { - return i - } - if i.fastContains(oi.Lo) { - if i.fastContains(oi.Hi) { - // Either oi ⊂ i, or i ∪ oi is the full interval. - if i.ContainsInterval(oi) { - return i - } - return FullInterval() - } - return Interval{i.Lo, oi.Hi} - } - if i.fastContains(oi.Hi) { - return Interval{oi.Lo, i.Hi} - } - - // Neither endpoint of oi is in i. Either i ⊂ oi, or i and oi are disjoint. - if i.IsEmpty() || oi.fastContains(i.Lo) { - return oi - } - - // This is the only hard case where we need to find the closest pair of endpoints. - if positiveDistance(oi.Hi, i.Lo) < positiveDistance(i.Hi, oi.Lo) { - return Interval{oi.Lo, i.Hi} - } - return Interval{i.Lo, oi.Hi} -} - -// Intersection returns the smallest interval that contains the intersection of the interval and oi. -func (i Interval) Intersection(oi Interval) Interval { - if oi.IsEmpty() { - return EmptyInterval() - } - if i.fastContains(oi.Lo) { - if i.fastContains(oi.Hi) { - // Either oi ⊂ i, or i and oi intersect twice. Neither are empty. - // In the first case we want to return i (which is shorter than oi). - // In the second case one of them is inverted, and the smallest interval - // that covers the two disjoint pieces is the shorter of i and oi. - // We thus want to pick the shorter of i and oi in both cases. - if oi.Length() < i.Length() { - return oi - } - return i - } - return Interval{oi.Lo, i.Hi} - } - if i.fastContains(oi.Hi) { - return Interval{i.Lo, oi.Hi} - } - - // Neither endpoint of oi is in i. Either i ⊂ oi, or i and oi are disjoint. - if oi.fastContains(i.Lo) { - return i - } - return EmptyInterval() -} - -// AddPoint returns the interval expanded by the minimum amount necessary such -// that it contains the given point "p" (an angle in the range [-π, π]). -func (i Interval) AddPoint(p float64) Interval { - if math.Abs(p) > math.Pi { - return i - } - if p == -math.Pi { - p = math.Pi - } - if i.fastContains(p) { - return i - } - if i.IsEmpty() { - return Interval{p, p} - } - if positiveDistance(p, i.Lo) < positiveDistance(i.Hi, p) { - return Interval{p, i.Hi} - } - return Interval{i.Lo, p} -} - -// Define the maximum rounding error for arithmetic operations. Depending on the -// platform the mantissa precision may be different than others, so we choose to -// use specific values to be consistent across all. -// The values come from the C++ implementation. -var ( - // epsilon is a small number that represents a reasonable level of noise between two - // values that can be considered to be equal. - epsilon = 1e-15 - // dblEpsilon is a smaller number for values that require more precision. - dblEpsilon = 2.220446049e-16 -) - -// Expanded returns an interval that has been expanded on each side by margin. -// If margin is negative, then the function shrinks the interval on -// each side by margin instead. The resulting interval may be empty or -// full. Any expansion (positive or negative) of a full interval remains -// full, and any expansion of an empty interval remains empty. -func (i Interval) Expanded(margin float64) Interval { - if margin >= 0 { - if i.IsEmpty() { - return i - } - // Check whether this interval will be full after expansion, allowing - // for a rounding error when computing each endpoint. - if i.Length()+2*margin+2*dblEpsilon >= 2*math.Pi { - return FullInterval() - } - } else { - if i.IsFull() { - return i - } - // Check whether this interval will be empty after expansion, allowing - // for a rounding error when computing each endpoint. - if i.Length()+2*margin-2*dblEpsilon <= 0 { - return EmptyInterval() - } - } - result := IntervalFromEndpoints( - math.Remainder(i.Lo-margin, 2*math.Pi), - math.Remainder(i.Hi+margin, 2*math.Pi), - ) - if result.Lo <= -math.Pi { - result.Lo = math.Pi - } - return result -} - -// ApproxEqual reports whether this interval can be transformed into the given -// interval by moving each endpoint by at most ε, without the -// endpoints crossing (which would invert the interval). Empty and full -// intervals are considered to start at an arbitrary point on the unit circle, -// so any interval with (length <= 2*ε) matches the empty interval, and -// any interval with (length >= 2*π - 2*ε) matches the full interval. -func (i Interval) ApproxEqual(other Interval) bool { - // Full and empty intervals require special cases because the endpoints - // are considered to be positioned arbitrarily. - if i.IsEmpty() { - return other.Length() <= 2*epsilon - } - if other.IsEmpty() { - return i.Length() <= 2*epsilon - } - if i.IsFull() { - return other.Length() >= 2*(math.Pi-epsilon) - } - if other.IsFull() { - return i.Length() >= 2*(math.Pi-epsilon) - } - - // The purpose of the last test below is to verify that moving the endpoints - // does not invert the interval, e.g. [-1e20, 1e20] vs. [1e20, -1e20]. - return (math.Abs(math.Remainder(other.Lo-i.Lo, 2*math.Pi)) <= epsilon && - math.Abs(math.Remainder(other.Hi-i.Hi, 2*math.Pi)) <= epsilon && - math.Abs(i.Length()-other.Length()) <= 2*epsilon) - -} - -func (i Interval) String() string { - // like "[%.7f, %.7f]" - return "[" + strconv.FormatFloat(i.Lo, 'f', 7, 64) + ", " + strconv.FormatFloat(i.Hi, 'f', 7, 64) + "]" -} - -// Complement returns the complement of the interior of the interval. An interval and -// its complement have the same boundary but do not share any interior -// values. The complement operator is not a bijection, since the complement -// of a singleton interval (containing a single value) is the same as the -// complement of an empty interval. -func (i Interval) Complement() Interval { - if i.Lo == i.Hi { - // Singleton. The interval just contains a single point. - return FullInterval() - } - // Handles empty and full. - return Interval{i.Hi, i.Lo} -} - -// ComplementCenter returns the midpoint of the complement of the interval. For full and empty -// intervals, the result is arbitrary. For a singleton interval (containing a -// single point), the result is its antipodal point on S1. -func (i Interval) ComplementCenter() float64 { - if i.Lo != i.Hi { - return i.Complement().Center() - } - // Singleton. The interval just contains a single point. - if i.Hi <= 0 { - return i.Hi + math.Pi - } - return i.Hi - math.Pi -} - -// DirectedHausdorffDistance returns the Hausdorff distance to the given interval. -// For two intervals i and y, this distance is defined by -// h(i, y) = max_{p in i} min_{q in y} d(p, q), -// where d(.,.) is measured along S1. -func (i Interval) DirectedHausdorffDistance(y Interval) Angle { - if y.ContainsInterval(i) { - return 0 // This includes the case i is empty. - } - if y.IsEmpty() { - return Angle(math.Pi) // maximum possible distance on s1. - } - yComplementCenter := y.ComplementCenter() - if i.Contains(yComplementCenter) { - return Angle(positiveDistance(y.Hi, yComplementCenter)) - } - - // The Hausdorff distance is realized by either two i.Hi endpoints or two - // i.Lo endpoints, whichever is farther apart. - hiHi := 0.0 - if IntervalFromEndpoints(y.Hi, yComplementCenter).Contains(i.Hi) { - hiHi = positiveDistance(y.Hi, i.Hi) - } - - loLo := 0.0 - if IntervalFromEndpoints(yComplementCenter, y.Lo).Contains(i.Lo) { - loLo = positiveDistance(i.Lo, y.Lo) - } - - return Angle(math.Max(hiHi, loLo)) -} - -// Project returns the closest point in the interval to the given point p. -// The interval must be non-empty. -func (i Interval) Project(p float64) float64 { - if p == -math.Pi { - p = math.Pi - } - if i.fastContains(p) { - return p - } - // Compute distance from p to each endpoint. - dlo := positiveDistance(p, i.Lo) - dhi := positiveDistance(i.Hi, p) - if dlo < dhi { - return i.Lo - } - return i.Hi -} diff --git a/vendor/github.com/golang/geo/s2/bits_go18.go b/vendor/github.com/golang/geo/s2/bits_go18.go deleted file mode 100644 index 10a674da5..000000000 --- a/vendor/github.com/golang/geo/s2/bits_go18.go +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// +build !go1.9 - -package s2 - -// This file is for the bit manipulation code pre-Go 1.9. - -// findMSBSetNonZero64 returns the index (between 0 and 63) of the most -// significant set bit. Passing zero to this function returns zero. -func findMSBSetNonZero64(x uint64) int { - val := []uint64{0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000, 0xFFFFFFFF00000000} - shift := []uint64{1, 2, 4, 8, 16, 32} - var msbPos uint64 - for i := 5; i >= 0; i-- { - if x&val[i] != 0 { - x >>= shift[i] - msbPos |= shift[i] - } - } - return int(msbPos) -} - -const deBruijn64 = 0x03f79d71b4ca8b09 -const digitMask = uint64(1<<64 - 1) - -var deBruijn64Lookup = []byte{ - 0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4, - 62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5, - 63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11, - 54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6, -} - -// findLSBSetNonZero64 returns the index (between 0 and 63) of the least -// significant set bit. Passing zero to this function returns zero. -// -// This code comes from trailingZeroBits in https://golang.org/src/math/big/nat.go -// which references (Knuth, volume 4, section 7.3.1). -func findLSBSetNonZero64(x uint64) int { - return int(deBruijn64Lookup[((x&-x)*(deBruijn64&digitMask))>>58]) -} diff --git a/vendor/github.com/golang/geo/s2/bits_go19.go b/vendor/github.com/golang/geo/s2/bits_go19.go deleted file mode 100644 index 9532b377d..000000000 --- a/vendor/github.com/golang/geo/s2/bits_go19.go +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// +build go1.9 - -package s2 - -// This file is for the bit manipulation code post-Go 1.9. - -import "math/bits" - -// findMSBSetNonZero64 returns the index (between 0 and 63) of the most -// significant set bit. Passing zero to this function return zero. -func findMSBSetNonZero64(x uint64) int { - if x == 0 { - return 0 - } - return 63 - bits.LeadingZeros64(x) -} - -// findLSBSetNonZero64 returns the index (between 0 and 63) of the least -// significant set bit. Passing zero to this function return zero. -func findLSBSetNonZero64(x uint64) int { - if x == 0 { - return 0 - } - return bits.TrailingZeros64(x) -} diff --git a/vendor/github.com/golang/geo/s2/cap.go b/vendor/github.com/golang/geo/s2/cap.go deleted file mode 100644 index c4fb2e1e0..000000000 --- a/vendor/github.com/golang/geo/s2/cap.go +++ /dev/null @@ -1,519 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "math" - - "github.com/golang/geo/r1" - "github.com/golang/geo/s1" -) - -var ( - // centerPoint is the default center for Caps - centerPoint = PointFromCoords(1.0, 0, 0) -) - -// Cap represents a disc-shaped region defined by a center and radius. -// Technically this shape is called a "spherical cap" (rather than disc) -// because it is not planar; the cap represents a portion of the sphere that -// has been cut off by a plane. The boundary of the cap is the circle defined -// by the intersection of the sphere and the plane. For containment purposes, -// the cap is a closed set, i.e. it contains its boundary. -// -// For the most part, you can use a spherical cap wherever you would use a -// disc in planar geometry. The radius of the cap is measured along the -// surface of the sphere (rather than the straight-line distance through the -// interior). Thus a cap of radius π/2 is a hemisphere, and a cap of radius -// π covers the entire sphere. -// -// The center is a point on the surface of the unit sphere. (Hence the need for -// it to be of unit length.) -// -// A cap can also be defined by its center point and height. The height is the -// distance from the center point to the cutoff plane. There is also support for -// "empty" and "full" caps, which contain no points and all points respectively. -// -// Here are some useful relationships between the cap height (h), the cap -// radius (r), the maximum chord length from the cap's center (d), and the -// radius of cap's base (a). -// -// h = 1 - cos(r) -// = 2 * sin^2(r/2) -// d^2 = 2 * h -// = a^2 + h^2 -// -// The zero value of Cap is an invalid cap. Use EmptyCap to get a valid empty cap. -type Cap struct { - center Point - radius s1.ChordAngle -} - -// CapFromPoint constructs a cap containing a single point. -func CapFromPoint(p Point) Cap { - return CapFromCenterChordAngle(p, 0) -} - -// CapFromCenterAngle constructs a cap with the given center and angle. -func CapFromCenterAngle(center Point, angle s1.Angle) Cap { - return CapFromCenterChordAngle(center, s1.ChordAngleFromAngle(angle)) -} - -// CapFromCenterChordAngle constructs a cap where the angle is expressed as an -// s1.ChordAngle. This constructor is more efficient than using an s1.Angle. -func CapFromCenterChordAngle(center Point, radius s1.ChordAngle) Cap { - return Cap{ - center: center, - radius: radius, - } -} - -// CapFromCenterHeight constructs a cap with the given center and height. A -// negative height yields an empty cap; a height of 2 or more yields a full cap. -// The center should be unit length. -func CapFromCenterHeight(center Point, height float64) Cap { - return CapFromCenterChordAngle(center, s1.ChordAngleFromSquaredLength(2*height)) -} - -// CapFromCenterArea constructs a cap with the given center and surface area. -// Note that the area can also be interpreted as the solid angle subtended by the -// cap (because the sphere has unit radius). A negative area yields an empty cap; -// an area of 4*π or more yields a full cap. -func CapFromCenterArea(center Point, area float64) Cap { - return CapFromCenterChordAngle(center, s1.ChordAngleFromSquaredLength(area/math.Pi)) -} - -// EmptyCap returns a cap that contains no points. -func EmptyCap() Cap { - return CapFromCenterChordAngle(centerPoint, s1.NegativeChordAngle) -} - -// FullCap returns a cap that contains all points. -func FullCap() Cap { - return CapFromCenterChordAngle(centerPoint, s1.StraightChordAngle) -} - -// IsValid reports whether the Cap is considered valid. -func (c Cap) IsValid() bool { - return c.center.Vector.IsUnit() && c.radius <= s1.StraightChordAngle -} - -// IsEmpty reports whether the cap is empty, i.e. it contains no points. -func (c Cap) IsEmpty() bool { - return c.radius < 0 -} - -// IsFull reports whether the cap is full, i.e. it contains all points. -func (c Cap) IsFull() bool { - return c.radius == s1.StraightChordAngle -} - -// Center returns the cap's center point. -func (c Cap) Center() Point { - return c.center -} - -// Height returns the height of the cap. This is the distance from the center -// point to the cutoff plane. -func (c Cap) Height() float64 { - return float64(0.5 * c.radius) -} - -// Radius returns the cap radius as an s1.Angle. (Note that the cap angle -// is stored internally as a ChordAngle, so this method requires a trigonometric -// operation and may yield a slightly different result than the value passed -// to CapFromCenterAngle). -func (c Cap) Radius() s1.Angle { - return c.radius.Angle() -} - -// Area returns the surface area of the Cap on the unit sphere. -func (c Cap) Area() float64 { - return 2.0 * math.Pi * math.Max(0, c.Height()) -} - -// Contains reports whether this cap contains the other. -func (c Cap) Contains(other Cap) bool { - // In a set containment sense, every cap contains the empty cap. - if c.IsFull() || other.IsEmpty() { - return true - } - return c.radius >= ChordAngleBetweenPoints(c.center, other.center).Add(other.radius) -} - -// Intersects reports whether this cap intersects the other cap. -// i.e. whether they have any points in common. -func (c Cap) Intersects(other Cap) bool { - if c.IsEmpty() || other.IsEmpty() { - return false - } - - return c.radius.Add(other.radius) >= ChordAngleBetweenPoints(c.center, other.center) -} - -// InteriorIntersects reports whether this caps interior intersects the other cap. -func (c Cap) InteriorIntersects(other Cap) bool { - // Make sure this cap has an interior and the other cap is non-empty. - if c.radius <= 0 || other.IsEmpty() { - return false - } - - return c.radius.Add(other.radius) > ChordAngleBetweenPoints(c.center, other.center) -} - -// ContainsPoint reports whether this cap contains the point. -func (c Cap) ContainsPoint(p Point) bool { - return ChordAngleBetweenPoints(c.center, p) <= c.radius -} - -// InteriorContainsPoint reports whether the point is within the interior of this cap. -func (c Cap) InteriorContainsPoint(p Point) bool { - return c.IsFull() || ChordAngleBetweenPoints(c.center, p) < c.radius -} - -// Complement returns the complement of the interior of the cap. A cap and its -// complement have the same boundary but do not share any interior points. -// The complement operator is not a bijection because the complement of a -// singleton cap (containing a single point) is the same as the complement -// of an empty cap. -func (c Cap) Complement() Cap { - if c.IsFull() { - return EmptyCap() - } - if c.IsEmpty() { - return FullCap() - } - - return CapFromCenterChordAngle(Point{c.center.Mul(-1)}, s1.StraightChordAngle.Sub(c.radius)) -} - -// CapBound returns a bounding spherical cap. This is not guaranteed to be exact. -func (c Cap) CapBound() Cap { - return c -} - -// RectBound returns a bounding latitude-longitude rectangle. -// The bounds are not guaranteed to be tight. -func (c Cap) RectBound() Rect { - if c.IsEmpty() { - return EmptyRect() - } - - capAngle := c.Radius().Radians() - allLongitudes := false - lat := r1.Interval{ - Lo: latitude(c.center).Radians() - capAngle, - Hi: latitude(c.center).Radians() + capAngle, - } - lng := s1.FullInterval() - - // Check whether cap includes the south pole. - if lat.Lo <= -math.Pi/2 { - lat.Lo = -math.Pi / 2 - allLongitudes = true - } - - // Check whether cap includes the north pole. - if lat.Hi >= math.Pi/2 { - lat.Hi = math.Pi / 2 - allLongitudes = true - } - - if !allLongitudes { - // Compute the range of longitudes covered by the cap. We use the law - // of sines for spherical triangles. Consider the triangle ABC where - // A is the north pole, B is the center of the cap, and C is the point - // of tangency between the cap boundary and a line of longitude. Then - // C is a right angle, and letting a,b,c denote the sides opposite A,B,C, - // we have sin(a)/sin(A) = sin(c)/sin(C), or sin(A) = sin(a)/sin(c). - // Here "a" is the cap angle, and "c" is the colatitude (90 degrees - // minus the latitude). This formula also works for negative latitudes. - // - // The formula for sin(a) follows from the relationship h = 1 - cos(a). - sinA := c.radius.Sin() - sinC := math.Cos(latitude(c.center).Radians()) - if sinA <= sinC { - angleA := math.Asin(sinA / sinC) - lng.Lo = math.Remainder(longitude(c.center).Radians()-angleA, math.Pi*2) - lng.Hi = math.Remainder(longitude(c.center).Radians()+angleA, math.Pi*2) - } - } - return Rect{lat, lng} -} - -// Equal reports whether this cap is equal to the other cap. -func (c Cap) Equal(other Cap) bool { - return (c.radius == other.radius && c.center == other.center) || - (c.IsEmpty() && other.IsEmpty()) || - (c.IsFull() && other.IsFull()) -} - -// ApproxEqual reports whether this cap is equal to the other cap within the given tolerance. -func (c Cap) ApproxEqual(other Cap) bool { - const epsilon = 1e-14 - r2 := float64(c.radius) - otherR2 := float64(other.radius) - return c.center.ApproxEqual(other.center) && - math.Abs(r2-otherR2) <= epsilon || - c.IsEmpty() && otherR2 <= epsilon || - other.IsEmpty() && r2 <= epsilon || - c.IsFull() && otherR2 >= 2-epsilon || - other.IsFull() && r2 >= 2-epsilon -} - -// AddPoint increases the cap if necessary to include the given point. If this cap is empty, -// then the center is set to the point with a zero height. p must be unit-length. -func (c Cap) AddPoint(p Point) Cap { - if c.IsEmpty() { - c.center = p - c.radius = 0 - return c - } - - // After calling cap.AddPoint(p), cap.Contains(p) must be true. However - // we don't need to do anything special to achieve this because Contains() - // does exactly the same distance calculation that we do here. - if newRad := ChordAngleBetweenPoints(c.center, p); newRad > c.radius { - c.radius = newRad - } - return c -} - -// AddCap increases the cap height if necessary to include the other cap. If this cap is empty, -// it is set to the other cap. -func (c Cap) AddCap(other Cap) Cap { - if c.IsEmpty() { - return other - } - if other.IsEmpty() { - return c - } - - // We round up the distance to ensure that the cap is actually contained. - // TODO(roberts): Do some error analysis in order to guarantee this. - dist := ChordAngleBetweenPoints(c.center, other.center).Add(other.radius) - if newRad := dist.Expanded(dblEpsilon * float64(dist)); newRad > c.radius { - c.radius = newRad - } - return c -} - -// Expanded returns a new cap expanded by the given angle. If the cap is empty, -// it returns an empty cap. -func (c Cap) Expanded(distance s1.Angle) Cap { - if c.IsEmpty() { - return EmptyCap() - } - return CapFromCenterChordAngle(c.center, c.radius.Add(s1.ChordAngleFromAngle(distance))) -} - -func (c Cap) String() string { - return fmt.Sprintf("[Center=%v, Radius=%f]", c.center.Vector, c.Radius().Degrees()) -} - -// radiusToHeight converts an s1.Angle into the height of the cap. -func radiusToHeight(r s1.Angle) float64 { - if r.Radians() < 0 { - return float64(s1.NegativeChordAngle) - } - if r.Radians() >= math.Pi { - return float64(s1.RightChordAngle) - } - return float64(0.5 * s1.ChordAngleFromAngle(r)) - -} - -// ContainsCell reports whether the cap contains the given cell. -func (c Cap) ContainsCell(cell Cell) bool { - // If the cap does not contain all cell vertices, return false. - var vertices [4]Point - for k := 0; k < 4; k++ { - vertices[k] = cell.Vertex(k) - if !c.ContainsPoint(vertices[k]) { - return false - } - } - // Otherwise, return true if the complement of the cap does not intersect the cell. - return !c.Complement().intersects(cell, vertices) -} - -// IntersectsCell reports whether the cap intersects the cell. -func (c Cap) IntersectsCell(cell Cell) bool { - // If the cap contains any cell vertex, return true. - var vertices [4]Point - for k := 0; k < 4; k++ { - vertices[k] = cell.Vertex(k) - if c.ContainsPoint(vertices[k]) { - return true - } - } - return c.intersects(cell, vertices) -} - -// intersects reports whether the cap intersects any point of the cell excluding -// its vertices (which are assumed to already have been checked). -func (c Cap) intersects(cell Cell, vertices [4]Point) bool { - // If the cap is a hemisphere or larger, the cell and the complement of the cap - // are both convex. Therefore since no vertex of the cell is contained, no other - // interior point of the cell is contained either. - if c.radius >= s1.RightChordAngle { - return false - } - - // We need to check for empty caps due to the center check just below. - if c.IsEmpty() { - return false - } - - // Optimization: return true if the cell contains the cap center. This allows half - // of the edge checks below to be skipped. - if cell.ContainsPoint(c.center) { - return true - } - - // At this point we know that the cell does not contain the cap center, and the cap - // does not contain any cell vertex. The only way that they can intersect is if the - // cap intersects the interior of some edge. - sin2Angle := c.radius.Sin2() - for k := 0; k < 4; k++ { - edge := cell.Edge(k).Vector - dot := c.center.Vector.Dot(edge) - if dot > 0 { - // The center is in the interior half-space defined by the edge. We do not need - // to consider these edges, since if the cap intersects this edge then it also - // intersects the edge on the opposite side of the cell, because the center is - // not contained with the cell. - continue - } - - // The Norm2() factor is necessary because "edge" is not normalized. - if dot*dot > sin2Angle*edge.Norm2() { - return false - } - - // Otherwise, the great circle containing this edge intersects the interior of the cap. We just - // need to check whether the point of closest approach occurs between the two edge endpoints. - dir := edge.Cross(c.center.Vector) - if dir.Dot(vertices[k].Vector) < 0 && dir.Dot(vertices[(k+1)&3].Vector) > 0 { - return true - } - } - return false -} - -// CellUnionBound computes a covering of the Cap. In general the covering -// consists of at most 4 cells except for very large caps, which may need -// up to 6 cells. The output is not sorted. -func (c Cap) CellUnionBound() []CellID { - // TODO(roberts): The covering could be made quite a bit tighter by mapping - // the cap to a rectangle in (i,j)-space and finding a covering for that. - - // Find the maximum level such that the cap contains at most one cell vertex - // and such that CellID.AppendVertexNeighbors() can be called. - level := MinWidthMetric.MaxLevel(c.Radius().Radians()) - 1 - - // If level < 0, more than three face cells are required. - if level < 0 { - cellIDs := make([]CellID, 6) - for face := 0; face < 6; face++ { - cellIDs[face] = CellIDFromFace(face) - } - return cellIDs - } - // The covering consists of the 4 cells at the given level that share the - // cell vertex that is closest to the cap center. - return cellIDFromPoint(c.center).VertexNeighbors(level) -} - -// Centroid returns the true centroid of the cap multiplied by its surface area -// The result lies on the ray from the origin through the cap's center, but it -// is not unit length. Note that if you just want the "surface centroid", i.e. -// the normalized result, then it is simpler to call Center. -// -// The reason for multiplying the result by the cap area is to make it -// easier to compute the centroid of more complicated shapes. The centroid -// of a union of disjoint regions can be computed simply by adding their -// Centroid() results. Caveat: for caps that contain a single point -// (i.e., zero radius), this method always returns the origin (0, 0, 0). -// This is because shapes with no area don't affect the centroid of a -// union whose total area is positive. -func (c Cap) Centroid() Point { - // From symmetry, the centroid of the cap must be somewhere on the line - // from the origin to the center of the cap on the surface of the sphere. - // When a sphere is divided into slices of constant thickness by a set of - // parallel planes, all slices have the same surface area. This implies - // that the radial component of the centroid is simply the midpoint of the - // range of radial distances spanned by the cap. That is easily computed - // from the cap height. - if c.IsEmpty() { - return Point{} - } - r := 1 - 0.5*c.Height() - return Point{c.center.Mul(r * c.Area())} -} - -// Union returns the smallest cap which encloses this cap and other. -func (c Cap) Union(other Cap) Cap { - // If the other cap is larger, swap c and other for the rest of the computations. - if c.radius < other.radius { - c, other = other, c - } - - if c.IsFull() || other.IsEmpty() { - return c - } - - // TODO: This calculation would be more efficient using s1.ChordAngles. - cRadius := c.Radius() - otherRadius := other.Radius() - distance := c.center.Distance(other.center) - if cRadius >= distance+otherRadius { - return c - } - - resRadius := 0.5 * (distance + cRadius + otherRadius) - resCenter := InterpolateAtDistance(0.5*(distance-cRadius+otherRadius), c.center, other.center) - return CapFromCenterAngle(resCenter, resRadius) -} - -// Encode encodes the Cap. -func (c Cap) Encode(w io.Writer) error { - e := &encoder{w: w} - c.encode(e) - return e.err -} - -func (c Cap) encode(e *encoder) { - e.writeFloat64(c.center.X) - e.writeFloat64(c.center.Y) - e.writeFloat64(c.center.Z) - e.writeFloat64(float64(c.radius)) -} - -// Decode decodes the Cap. -func (c *Cap) Decode(r io.Reader) error { - d := &decoder{r: asByteReader(r)} - c.decode(d) - return d.err -} - -func (c *Cap) decode(d *decoder) { - c.center.X = d.readFloat64() - c.center.Y = d.readFloat64() - c.center.Z = d.readFloat64() - c.radius = s1.ChordAngle(d.readFloat64()) -} diff --git a/vendor/github.com/golang/geo/s2/cell.go b/vendor/github.com/golang/geo/s2/cell.go deleted file mode 100644 index 0a01a4f1f..000000000 --- a/vendor/github.com/golang/geo/s2/cell.go +++ /dev/null @@ -1,698 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "io" - "math" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r2" - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// Cell is an S2 region object that represents a cell. Unlike CellIDs, -// it supports efficient containment and intersection tests. However, it is -// also a more expensive representation. -type Cell struct { - face int8 - level int8 - orientation int8 - id CellID - uv r2.Rect -} - -// CellFromCellID constructs a Cell corresponding to the given CellID. -func CellFromCellID(id CellID) Cell { - c := Cell{} - c.id = id - f, i, j, o := c.id.faceIJOrientation() - c.face = int8(f) - c.level = int8(c.id.Level()) - c.orientation = int8(o) - c.uv = ijLevelToBoundUV(i, j, int(c.level)) - return c -} - -// CellFromPoint constructs a cell for the given Point. -func CellFromPoint(p Point) Cell { - return CellFromCellID(cellIDFromPoint(p)) -} - -// CellFromLatLng constructs a cell for the given LatLng. -func CellFromLatLng(ll LatLng) Cell { - return CellFromCellID(CellIDFromLatLng(ll)) -} - -// Face returns the face this cell is on. -func (c Cell) Face() int { - return int(c.face) -} - -// oppositeFace returns the face opposite the given face. -func oppositeFace(face int) int { - return (face + 3) % 6 -} - -// Level returns the level of this cell. -func (c Cell) Level() int { - return int(c.level) -} - -// ID returns the CellID this cell represents. -func (c Cell) ID() CellID { - return c.id -} - -// IsLeaf returns whether this Cell is a leaf or not. -func (c Cell) IsLeaf() bool { - return c.level == maxLevel -} - -// SizeIJ returns the edge length of this cell in (i,j)-space. -func (c Cell) SizeIJ() int { - return sizeIJ(int(c.level)) -} - -// SizeST returns the edge length of this cell in (s,t)-space. -func (c Cell) SizeST() float64 { - return c.id.sizeST(int(c.level)) -} - -// Vertex returns the k-th vertex of the cell (k = 0,1,2,3) in CCW order -// (lower left, lower right, upper right, upper left in the UV plane). -func (c Cell) Vertex(k int) Point { - return Point{faceUVToXYZ(int(c.face), c.uv.Vertices()[k].X, c.uv.Vertices()[k].Y).Normalize()} -} - -// Edge returns the inward-facing normal of the great circle passing through -// the CCW ordered edge from vertex k to vertex k+1 (mod 4) (for k = 0,1,2,3). -func (c Cell) Edge(k int) Point { - switch k { - case 0: - return Point{vNorm(int(c.face), c.uv.Y.Lo).Normalize()} // Bottom - case 1: - return Point{uNorm(int(c.face), c.uv.X.Hi).Normalize()} // Right - case 2: - return Point{vNorm(int(c.face), c.uv.Y.Hi).Mul(-1.0).Normalize()} // Top - default: - return Point{uNorm(int(c.face), c.uv.X.Lo).Mul(-1.0).Normalize()} // Left - } -} - -// BoundUV returns the bounds of this cell in (u,v)-space. -func (c Cell) BoundUV() r2.Rect { - return c.uv -} - -// Center returns the direction vector corresponding to the center in -// (s,t)-space of the given cell. This is the point at which the cell is -// divided into four subcells; it is not necessarily the centroid of the -// cell in (u,v)-space or (x,y,z)-space -func (c Cell) Center() Point { - return Point{c.id.rawPoint().Normalize()} -} - -// Children returns the four direct children of this cell in traversal order -// and returns true. If this is a leaf cell, or the children could not be created, -// false is returned. -// The C++ method is called Subdivide. -func (c Cell) Children() ([4]Cell, bool) { - var children [4]Cell - - if c.id.IsLeaf() { - return children, false - } - - // Compute the cell midpoint in uv-space. - uvMid := c.id.centerUV() - - // Create four children with the appropriate bounds. - cid := c.id.ChildBegin() - for pos := 0; pos < 4; pos++ { - children[pos] = Cell{ - face: c.face, - level: c.level + 1, - orientation: c.orientation ^ int8(posToOrientation[pos]), - id: cid, - } - - // We want to split the cell in half in u and v. To decide which - // side to set equal to the midpoint value, we look at cell's (i,j) - // position within its parent. The index for i is in bit 1 of ij. - ij := posToIJ[c.orientation][pos] - i := ij >> 1 - j := ij & 1 - if i == 1 { - children[pos].uv.X.Hi = c.uv.X.Hi - children[pos].uv.X.Lo = uvMid.X - } else { - children[pos].uv.X.Lo = c.uv.X.Lo - children[pos].uv.X.Hi = uvMid.X - } - if j == 1 { - children[pos].uv.Y.Hi = c.uv.Y.Hi - children[pos].uv.Y.Lo = uvMid.Y - } else { - children[pos].uv.Y.Lo = c.uv.Y.Lo - children[pos].uv.Y.Hi = uvMid.Y - } - cid = cid.Next() - } - return children, true -} - -// ExactArea returns the area of this cell as accurately as possible. -func (c Cell) ExactArea() float64 { - v0, v1, v2, v3 := c.Vertex(0), c.Vertex(1), c.Vertex(2), c.Vertex(3) - return PointArea(v0, v1, v2) + PointArea(v0, v2, v3) -} - -// ApproxArea returns the approximate area of this cell. This method is accurate -// to within 3% percent for all cell sizes and accurate to within 0.1% for cells -// at level 5 or higher (i.e. squares 350km to a side or smaller on the Earth's -// surface). It is moderately cheap to compute. -func (c Cell) ApproxArea() float64 { - // All cells at the first two levels have the same area. - if c.level < 2 { - return c.AverageArea() - } - - // First, compute the approximate area of the cell when projected - // perpendicular to its normal. The cross product of its diagonals gives - // the normal, and the length of the normal is twice the projected area. - flatArea := 0.5 * (c.Vertex(2).Sub(c.Vertex(0).Vector). - Cross(c.Vertex(3).Sub(c.Vertex(1).Vector)).Norm()) - - // Now, compensate for the curvature of the cell surface by pretending - // that the cell is shaped like a spherical cap. The ratio of the - // area of a spherical cap to the area of its projected disc turns out - // to be 2 / (1 + sqrt(1 - r*r)) where r is the radius of the disc. - // For example, when r=0 the ratio is 1, and when r=1 the ratio is 2. - // Here we set Pi*r*r == flatArea to find the equivalent disc. - return flatArea * 2 / (1 + math.Sqrt(1-math.Min(1/math.Pi*flatArea, 1))) -} - -// AverageArea returns the average area of cells at the level of this cell. -// This is accurate to within a factor of 1.7. -func (c Cell) AverageArea() float64 { - return AvgAreaMetric.Value(int(c.level)) -} - -// IntersectsCell reports whether the intersection of this cell and the other cell is not nil. -func (c Cell) IntersectsCell(oc Cell) bool { - return c.id.Intersects(oc.id) -} - -// ContainsCell reports whether this cell contains the other cell. -func (c Cell) ContainsCell(oc Cell) bool { - return c.id.Contains(oc.id) -} - -// CellUnionBound computes a covering of the Cell. -func (c Cell) CellUnionBound() []CellID { - return c.CapBound().CellUnionBound() -} - -// latitude returns the latitude of the cell vertex in radians given by (i,j), -// where i and j indicate the Hi (1) or Lo (0) corner. -func (c Cell) latitude(i, j int) float64 { - var u, v float64 - switch { - case i == 0 && j == 0: - u = c.uv.X.Lo - v = c.uv.Y.Lo - case i == 0 && j == 1: - u = c.uv.X.Lo - v = c.uv.Y.Hi - case i == 1 && j == 0: - u = c.uv.X.Hi - v = c.uv.Y.Lo - case i == 1 && j == 1: - u = c.uv.X.Hi - v = c.uv.Y.Hi - default: - panic("i and/or j is out of bounds") - } - return latitude(Point{faceUVToXYZ(int(c.face), u, v)}).Radians() -} - -// longitude returns the longitude of the cell vertex in radians given by (i,j), -// where i and j indicate the Hi (1) or Lo (0) corner. -func (c Cell) longitude(i, j int) float64 { - var u, v float64 - switch { - case i == 0 && j == 0: - u = c.uv.X.Lo - v = c.uv.Y.Lo - case i == 0 && j == 1: - u = c.uv.X.Lo - v = c.uv.Y.Hi - case i == 1 && j == 0: - u = c.uv.X.Hi - v = c.uv.Y.Lo - case i == 1 && j == 1: - u = c.uv.X.Hi - v = c.uv.Y.Hi - default: - panic("i and/or j is out of bounds") - } - return longitude(Point{faceUVToXYZ(int(c.face), u, v)}).Radians() -} - -var ( - poleMinLat = math.Asin(math.Sqrt(1.0/3)) - 0.5*dblEpsilon -) - -// RectBound returns the bounding rectangle of this cell. -func (c Cell) RectBound() Rect { - if c.level > 0 { - // Except for cells at level 0, the latitude and longitude extremes are - // attained at the vertices. Furthermore, the latitude range is - // determined by one pair of diagonally opposite vertices and the - // longitude range is determined by the other pair. - // - // We first determine which corner (i,j) of the cell has the largest - // absolute latitude. To maximize latitude, we want to find the point in - // the cell that has the largest absolute z-coordinate and the smallest - // absolute x- and y-coordinates. To do this we look at each coordinate - // (u and v), and determine whether we want to minimize or maximize that - // coordinate based on the axis direction and the cell's (u,v) quadrant. - u := c.uv.X.Lo + c.uv.X.Hi - v := c.uv.Y.Lo + c.uv.Y.Hi - var i, j int - if uAxis(int(c.face)).Z == 0 { - if u < 0 { - i = 1 - } - } else if u > 0 { - i = 1 - } - if vAxis(int(c.face)).Z == 0 { - if v < 0 { - j = 1 - } - } else if v > 0 { - j = 1 - } - lat := r1.IntervalFromPoint(c.latitude(i, j)).AddPoint(c.latitude(1-i, 1-j)) - lng := s1.EmptyInterval().AddPoint(c.longitude(i, 1-j)).AddPoint(c.longitude(1-i, j)) - - // We grow the bounds slightly to make sure that the bounding rectangle - // contains LatLngFromPoint(P) for any point P inside the loop L defined by the - // four *normalized* vertices. Note that normalization of a vector can - // change its direction by up to 0.5 * dblEpsilon radians, and it is not - // enough just to add Normalize calls to the code above because the - // latitude/longitude ranges are not necessarily determined by diagonally - // opposite vertex pairs after normalization. - // - // We would like to bound the amount by which the latitude/longitude of a - // contained point P can exceed the bounds computed above. In the case of - // longitude, the normalization error can change the direction of rounding - // leading to a maximum difference in longitude of 2 * dblEpsilon. In - // the case of latitude, the normalization error can shift the latitude by - // up to 0.5 * dblEpsilon and the other sources of error can cause the - // two latitudes to differ by up to another 1.5 * dblEpsilon, which also - // leads to a maximum difference of 2 * dblEpsilon. - return Rect{lat, lng}.expanded(LatLng{s1.Angle(2 * dblEpsilon), s1.Angle(2 * dblEpsilon)}).PolarClosure() - } - - // The 4 cells around the equator extend to +/-45 degrees latitude at the - // midpoints of their top and bottom edges. The two cells covering the - // poles extend down to +/-35.26 degrees at their vertices. The maximum - // error in this calculation is 0.5 * dblEpsilon. - var bound Rect - switch c.face { - case 0: - bound = Rect{r1.Interval{-math.Pi / 4, math.Pi / 4}, s1.Interval{-math.Pi / 4, math.Pi / 4}} - case 1: - bound = Rect{r1.Interval{-math.Pi / 4, math.Pi / 4}, s1.Interval{math.Pi / 4, 3 * math.Pi / 4}} - case 2: - bound = Rect{r1.Interval{poleMinLat, math.Pi / 2}, s1.FullInterval()} - case 3: - bound = Rect{r1.Interval{-math.Pi / 4, math.Pi / 4}, s1.Interval{3 * math.Pi / 4, -3 * math.Pi / 4}} - case 4: - bound = Rect{r1.Interval{-math.Pi / 4, math.Pi / 4}, s1.Interval{-3 * math.Pi / 4, -math.Pi / 4}} - default: - bound = Rect{r1.Interval{-math.Pi / 2, -poleMinLat}, s1.FullInterval()} - } - - // Finally, we expand the bound to account for the error when a point P is - // converted to an LatLng to test for containment. (The bound should be - // large enough so that it contains the computed LatLng of any contained - // point, not just the infinite-precision version.) We don't need to expand - // longitude because longitude is calculated via a single call to math.Atan2, - // which is guaranteed to be semi-monotonic. - return bound.expanded(LatLng{s1.Angle(dblEpsilon), s1.Angle(0)}) -} - -// CapBound returns the bounding cap of this cell. -func (c Cell) CapBound() Cap { - // We use the cell center in (u,v)-space as the cap axis. This vector is very close - // to GetCenter() and faster to compute. Neither one of these vectors yields the - // bounding cap with minimal surface area, but they are both pretty close. - cap := CapFromPoint(Point{faceUVToXYZ(int(c.face), c.uv.Center().X, c.uv.Center().Y).Normalize()}) - for k := 0; k < 4; k++ { - cap = cap.AddPoint(c.Vertex(k)) - } - return cap -} - -// ContainsPoint reports whether this cell contains the given point. Note that -// unlike Loop/Polygon, a Cell is considered to be a closed set. This means -// that a point on a Cell's edge or vertex belong to the Cell and the relevant -// adjacent Cells too. -// -// If you want every point to be contained by exactly one Cell, -// you will need to convert the Cell to a Loop. -func (c Cell) ContainsPoint(p Point) bool { - var uv r2.Point - var ok bool - if uv.X, uv.Y, ok = faceXYZToUV(int(c.face), p); !ok { - return false - } - - // Expand the (u,v) bound to ensure that - // - // CellFromPoint(p).ContainsPoint(p) - // - // is always true. To do this, we need to account for the error when - // converting from (u,v) coordinates to (s,t) coordinates. In the - // normal case the total error is at most dblEpsilon. - return c.uv.ExpandedByMargin(dblEpsilon).ContainsPoint(uv) -} - -// Encode encodes the Cell. -func (c Cell) Encode(w io.Writer) error { - e := &encoder{w: w} - c.encode(e) - return e.err -} - -func (c Cell) encode(e *encoder) { - c.id.encode(e) -} - -// Decode decodes the Cell. -func (c *Cell) Decode(r io.Reader) error { - d := &decoder{r: asByteReader(r)} - c.decode(d) - return d.err -} - -func (c *Cell) decode(d *decoder) { - c.id.decode(d) - *c = CellFromCellID(c.id) -} - -// vertexChordDist2 returns the squared chord distance from point P to the -// given corner vertex specified by the Hi or Lo values of each. -func (c Cell) vertexChordDist2(p Point, xHi, yHi bool) s1.ChordAngle { - x := c.uv.X.Lo - y := c.uv.Y.Lo - if xHi { - x = c.uv.X.Hi - } - if yHi { - y = c.uv.Y.Hi - } - - return ChordAngleBetweenPoints(p, PointFromCoords(x, y, 1)) -} - -// uEdgeIsClosest reports whether a point P is closer to the interior of the specified -// Cell edge (either the lower or upper edge of the Cell) or to the endpoints. -func (c Cell) uEdgeIsClosest(p Point, vHi bool) bool { - u0 := c.uv.X.Lo - u1 := c.uv.X.Hi - v := c.uv.Y.Lo - if vHi { - v = c.uv.Y.Hi - } - // These are the normals to the planes that are perpendicular to the edge - // and pass through one of its two endpoints. - dir0 := r3.Vector{v*v + 1, -u0 * v, -u0} - dir1 := r3.Vector{v*v + 1, -u1 * v, -u1} - return p.Dot(dir0) > 0 && p.Dot(dir1) < 0 -} - -// vEdgeIsClosest reports whether a point P is closer to the interior of the specified -// Cell edge (either the right or left edge of the Cell) or to the endpoints. -func (c Cell) vEdgeIsClosest(p Point, uHi bool) bool { - v0 := c.uv.Y.Lo - v1 := c.uv.Y.Hi - u := c.uv.X.Lo - if uHi { - u = c.uv.X.Hi - } - dir0 := r3.Vector{-u * v0, u*u + 1, -v0} - dir1 := r3.Vector{-u * v1, u*u + 1, -v1} - return p.Dot(dir0) > 0 && p.Dot(dir1) < 0 -} - -// edgeDistance reports the distance from a Point P to a given Cell edge. The point -// P is given by its dot product, and the uv edge by its normal in the -// given coordinate value. -func edgeDistance(ij, uv float64) s1.ChordAngle { - // Let P by the target point and let R be the closest point on the given - // edge AB. The desired distance PR can be expressed as PR^2 = PQ^2 + QR^2 - // where Q is the point P projected onto the plane through the great circle - // through AB. We can compute the distance PQ^2 perpendicular to the plane - // from "dirIJ" (the dot product of the target point P with the edge - // normal) and the squared length the edge normal (1 + uv**2). - pq2 := (ij * ij) / (1 + uv*uv) - - // We can compute the distance QR as (1 - OQ) where O is the sphere origin, - // and we can compute OQ^2 = 1 - PQ^2 using the Pythagorean theorem. - // (This calculation loses accuracy as angle POQ approaches Pi/2.) - qr := 1 - math.Sqrt(1-pq2) - return s1.ChordAngleFromSquaredLength(pq2 + qr*qr) -} - -// distanceInternal reports the distance from the given point to the interior of -// the cell if toInterior is true or to the boundary of the cell otherwise. -func (c Cell) distanceInternal(targetXYZ Point, toInterior bool) s1.ChordAngle { - // All calculations are done in the (u,v,w) coordinates of this cell's face. - target := faceXYZtoUVW(int(c.face), targetXYZ) - - // Compute dot products with all four upward or rightward-facing edge - // normals. dirIJ is the dot product for the edge corresponding to axis - // I, endpoint J. For example, dir01 is the right edge of the Cell - // (corresponding to the upper endpoint of the u-axis). - dir00 := target.X - target.Z*c.uv.X.Lo - dir01 := target.X - target.Z*c.uv.X.Hi - dir10 := target.Y - target.Z*c.uv.Y.Lo - dir11 := target.Y - target.Z*c.uv.Y.Hi - inside := true - if dir00 < 0 { - inside = false // Target is to the left of the cell - if c.vEdgeIsClosest(target, false) { - return edgeDistance(-dir00, c.uv.X.Lo) - } - } - if dir01 > 0 { - inside = false // Target is to the right of the cell - if c.vEdgeIsClosest(target, true) { - return edgeDistance(dir01, c.uv.X.Hi) - } - } - if dir10 < 0 { - inside = false // Target is below the cell - if c.uEdgeIsClosest(target, false) { - return edgeDistance(-dir10, c.uv.Y.Lo) - } - } - if dir11 > 0 { - inside = false // Target is above the cell - if c.uEdgeIsClosest(target, true) { - return edgeDistance(dir11, c.uv.Y.Hi) - } - } - if inside { - if toInterior { - return s1.ChordAngle(0) - } - // Although you might think of Cells as rectangles, they are actually - // arbitrary quadrilaterals after they are projected onto the sphere. - // Therefore the simplest approach is just to find the minimum distance to - // any of the four edges. - return minChordAngle(edgeDistance(-dir00, c.uv.X.Lo), - edgeDistance(dir01, c.uv.X.Hi), - edgeDistance(-dir10, c.uv.Y.Lo), - edgeDistance(dir11, c.uv.Y.Hi)) - } - - // Otherwise, the closest point is one of the four cell vertices. Note that - // it is *not* trivial to narrow down the candidates based on the edge sign - // tests above, because (1) the edges don't meet at right angles and (2) - // there are points on the far side of the sphere that are both above *and* - // below the cell, etc. - return minChordAngle(c.vertexChordDist2(target, false, false), - c.vertexChordDist2(target, true, false), - c.vertexChordDist2(target, false, true), - c.vertexChordDist2(target, true, true)) -} - -// Distance reports the distance from the cell to the given point. Returns zero if -// the point is inside the cell. -func (c Cell) Distance(target Point) s1.ChordAngle { - return c.distanceInternal(target, true) -} - -// MaxDistance reports the maximum distance from the cell (including its interior) to the -// given point. -func (c Cell) MaxDistance(target Point) s1.ChordAngle { - // First check the 4 cell vertices. If all are within the hemisphere - // centered around target, the max distance will be to one of these vertices. - targetUVW := faceXYZtoUVW(int(c.face), target) - maxDist := maxChordAngle(c.vertexChordDist2(targetUVW, false, false), - c.vertexChordDist2(targetUVW, true, false), - c.vertexChordDist2(targetUVW, false, true), - c.vertexChordDist2(targetUVW, true, true)) - - if maxDist <= s1.RightChordAngle { - return maxDist - } - - // Otherwise, find the minimum distance dMin to the antipodal point and the - // maximum distance will be pi - dMin. - return s1.StraightChordAngle - c.BoundaryDistance(Point{target.Mul(-1)}) -} - -// BoundaryDistance reports the distance from the cell boundary to the given point. -func (c Cell) BoundaryDistance(target Point) s1.ChordAngle { - return c.distanceInternal(target, false) -} - -// DistanceToEdge returns the minimum distance from the cell to the given edge AB. Returns -// zero if the edge intersects the cell interior. -func (c Cell) DistanceToEdge(a, b Point) s1.ChordAngle { - // Possible optimizations: - // - Currently the (cell vertex, edge endpoint) distances are computed - // twice each, and the length of AB is computed 4 times. - // - To fix this, refactor GetDistance(target) so that it skips calculating - // the distance to each cell vertex. Instead, compute the cell vertices - // and distances in this function, and add a low-level UpdateMinDistance - // that allows the XA, XB, and AB distances to be passed in. - // - It might also be more efficient to do all calculations in UVW-space, - // since this would involve transforming 2 points rather than 4. - - // First, check the minimum distance to the edge endpoints A and B. - // (This also detects whether either endpoint is inside the cell.) - minDist := minChordAngle(c.Distance(a), c.Distance(b)) - if minDist == 0 { - return minDist - } - - // Otherwise, check whether the edge crosses the cell boundary. - crosser := NewChainEdgeCrosser(a, b, c.Vertex(3)) - for i := 0; i < 4; i++ { - if crosser.ChainCrossingSign(c.Vertex(i)) != DoNotCross { - return 0 - } - } - - // Finally, check whether the minimum distance occurs between a cell vertex - // and the interior of the edge AB. (Some of this work is redundant, since - // it also checks the distance to the endpoints A and B again.) - // - // Note that we don't need to check the distance from the interior of AB to - // the interior of a cell edge, because the only way that this distance can - // be minimal is if the two edges cross (already checked above). - for i := 0; i < 4; i++ { - minDist, _ = UpdateMinDistance(c.Vertex(i), a, b, minDist) - } - return minDist -} - -// MaxDistanceToEdge returns the maximum distance from the cell (including its interior) -// to the given edge AB. -func (c Cell) MaxDistanceToEdge(a, b Point) s1.ChordAngle { - // If the maximum distance from both endpoints to the cell is less than π/2 - // then the maximum distance from the edge to the cell is the maximum of the - // two endpoint distances. - maxDist := maxChordAngle(c.MaxDistance(a), c.MaxDistance(b)) - if maxDist <= s1.RightChordAngle { - return maxDist - } - - return s1.StraightChordAngle - c.DistanceToEdge(Point{a.Mul(-1)}, Point{b.Mul(-1)}) -} - -// DistanceToCell returns the minimum distance from this cell to the given cell. -// It returns zero if one cell contains the other. -func (c Cell) DistanceToCell(target Cell) s1.ChordAngle { - // If the cells intersect, the distance is zero. We use the (u,v) ranges - // rather than CellID intersects so that cells that share a partial edge or - // corner are considered to intersect. - if c.face == target.face && c.uv.Intersects(target.uv) { - return 0 - } - - // Otherwise, the minimum distance always occurs between a vertex of one - // cell and an edge of the other cell (including the edge endpoints). This - // represents a total of 32 possible (vertex, edge) pairs. - // - // TODO(roberts): This could be optimized to be at least 5x faster by pruning - // the set of possible closest vertex/edge pairs using the faces and (u,v) - // ranges of both cells. - var va, vb [4]Point - for i := 0; i < 4; i++ { - va[i] = c.Vertex(i) - vb[i] = target.Vertex(i) - } - minDist := s1.InfChordAngle() - for i := 0; i < 4; i++ { - for j := 0; j < 4; j++ { - minDist, _ = UpdateMinDistance(va[i], vb[j], vb[(j+1)&3], minDist) - minDist, _ = UpdateMinDistance(vb[i], va[j], va[(j+1)&3], minDist) - } - } - return minDist -} - -// MaxDistanceToCell returns the maximum distance from the cell (including its -// interior) to the given target cell. -func (c Cell) MaxDistanceToCell(target Cell) s1.ChordAngle { - // Need to check the antipodal target for intersection with the cell. If it - // intersects, the distance is the straight ChordAngle. - // antipodalUV is the transpose of the original UV, interpreted within the opposite face. - antipodalUV := r2.Rect{target.uv.Y, target.uv.X} - if int(c.face) == oppositeFace(int(target.face)) && c.uv.Intersects(antipodalUV) { - return s1.StraightChordAngle - } - - // Otherwise, the maximum distance always occurs between a vertex of one - // cell and an edge of the other cell (including the edge endpoints). This - // represents a total of 32 possible (vertex, edge) pairs. - // - // TODO(roberts): When the maximum distance is at most π/2, the maximum is - // always attained between a pair of vertices, and this could be made much - // faster by testing each vertex pair once rather than the current 4 times. - var va, vb [4]Point - for i := 0; i < 4; i++ { - va[i] = c.Vertex(i) - vb[i] = target.Vertex(i) - } - maxDist := s1.NegativeChordAngle - for i := 0; i < 4; i++ { - for j := 0; j < 4; j++ { - maxDist, _ = UpdateMaxDistance(va[i], vb[j], vb[(j+1)&3], maxDist) - maxDist, _ = UpdateMaxDistance(vb[i], va[j], va[(j+1)&3], maxDist) - } - } - return maxDist -} diff --git a/vendor/github.com/golang/geo/s2/cell_index.go b/vendor/github.com/golang/geo/s2/cell_index.go deleted file mode 100644 index ef16d0895..000000000 --- a/vendor/github.com/golang/geo/s2/cell_index.go +++ /dev/null @@ -1,498 +0,0 @@ -// Copyright 2020 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "sort" -) - -const ( - // A special label indicating that the ContentsIterator done is true. - cellIndexDoneContents = -1 -) - -// cellIndexNode represents a node in the CellIndex. Cells are organized in a -// tree such that the ancestors of a given node contain that node. -type cellIndexNode struct { - cellID CellID - label int32 - parent int32 -} - -// newCellIndexNode returns a node with the appropriate default values. -func newCellIndexNode() cellIndexNode { - return cellIndexNode{ - cellID: 0, - label: cellIndexDoneContents, - parent: -1, - } -} - -// A rangeNode represents a range of leaf CellIDs. The range starts at -// startID (a leaf cell) and ends at the startID field of the next -// rangeNode. contents points to the node of the CellIndex cellTree -// representing the cells that overlap this range. -type rangeNode struct { - startID CellID // First leaf cell contained by this range. - contents int32 // Contents of this node (an index within the cell tree). -} - -// CellIndexIterator is an iterator that visits the entire set of indexed -// (CellID, label) pairs in an unspecified order. -type CellIndexIterator struct { - // TODO(roberts): Implement -} - -// NewCellIndexIterator creates an iterator for the given CellIndex. -func NewCellIndexIterator(index *CellIndex) *CellIndexIterator { - return &CellIndexIterator{} -} - -// CellIndexRangeIterator is an iterator that seeks and iterates over a set of -// non-overlapping leaf cell ranges that cover the entire sphere. The indexed -// (CellID, label) pairs that intersect the current leaf cell range can be -// visited using CellIndexContentsIterator (see below). -type CellIndexRangeIterator struct { - rangeNodes []rangeNode - pos int - nonEmpty bool -} - -// NewCellIndexRangeIterator creates an iterator for the given CellIndex. -// The iterator is initially *unpositioned*; you must call a positioning method -// such as Begin() or Seek() before accessing its contents. -func NewCellIndexRangeIterator(index *CellIndex) *CellIndexRangeIterator { - return &CellIndexRangeIterator{ - rangeNodes: index.rangeNodes, - } -} - -// NewCellIndexNonEmptyRangeIterator creates an iterator for the given CellIndex. -// The iterator is initially *unpositioned*; you must call a positioning method such as -// Begin() or Seek() before accessing its contents. -func NewCellIndexNonEmptyRangeIterator(index *CellIndex) *CellIndexRangeIterator { - return &CellIndexRangeIterator{ - rangeNodes: index.rangeNodes, - nonEmpty: true, - } -} - -// StartID reports the CellID of the start of the current range of leaf CellIDs. -// -// If done is true, this returns the last possible CellID. This property means -// that most loops do not need to test done explicitly. -func (c *CellIndexRangeIterator) StartID() CellID { - return c.rangeNodes[c.pos].startID -} - -// LimitID reports the non-inclusive end of the current range of leaf CellIDs. -// -// This assumes the iterator is not done. -func (c *CellIndexRangeIterator) LimitID() CellID { - return c.rangeNodes[c.pos+1].startID -} - -// IsEmpty reports if no (CellID, label) pairs intersect this range. -// Also returns true if done() is true. -func (c *CellIndexRangeIterator) IsEmpty() bool { - return c.rangeNodes[c.pos].contents == cellIndexDoneContents -} - -// Begin positions the iterator at the first range of leaf cells (if any). -func (c *CellIndexRangeIterator) Begin() { - c.pos = 0 - for c.nonEmpty && c.IsEmpty() && !c.Done() { - c.pos++ - } -} - -// Prev positions the iterator at the previous entry and reports whether it was not -// already positioned at the beginning. -func (c *CellIndexRangeIterator) Prev() bool { - if c.nonEmpty { - return c.nonEmptyPrev() - } - return c.prev() -} - -// prev is used to position the iterator at the previous entry without checking -// if nonEmpty is true to prevent unwanted recursion. -func (c *CellIndexRangeIterator) prev() bool { - if c.pos == 0 { - return false - } - - c.pos-- - return true -} - -// Prev positions the iterator at the previous entry, and reports whether it was -// already positioned at the beginning. -func (c *CellIndexRangeIterator) nonEmptyPrev() bool { - for c.prev() { - if !c.IsEmpty() { - return true - } - } - - // Return the iterator to its original position. - if c.IsEmpty() && !c.Done() { - c.Next() - } - return false -} - -// Next advances the iterator to the next range of leaf cells. -// -// This assumes the iterator is not done. -func (c *CellIndexRangeIterator) Next() { - c.pos++ - for c.nonEmpty && c.IsEmpty() && !c.Done() { - c.pos++ - } -} - -// Advance reports if advancing would leave it positioned on a valid range. If -// the value would not be valid, the positioning is not changed. -func (c *CellIndexRangeIterator) Advance(n int) bool { - // Note that the last element of rangeNodes is a sentinel value. - if n >= len(c.rangeNodes)-1-c.pos { - return false - } - c.pos += n - return true -} - -// Finish positions the iterator so that done is true. -func (c *CellIndexRangeIterator) Finish() { - // Note that the last element of rangeNodes is a sentinel value. - c.pos = len(c.rangeNodes) - 1 -} - -// Done reports if the iterator is positioned beyond the last valid range. -func (c *CellIndexRangeIterator) Done() bool { - return c.pos >= len(c.rangeNodes)-1 -} - -// Seek positions the iterator at the first range with startID >= target. -// Such an entry always exists as long as "target" is a valid leaf cell. -// -// Note that it is valid to access startID even when done is true. -func (c *CellIndexRangeIterator) Seek(target CellID) { - c.pos = sort.Search(len(c.rangeNodes), func(i int) bool { - return c.rangeNodes[i].startID > target - }) - 1 - - // Ensure we don't go beyond the beginning. - if c.pos < 0 { - c.pos = 0 - } - - // Nonempty needs to find the next non-empty entry. - for c.nonEmpty && c.IsEmpty() && !c.Done() { - // c.Next() - c.pos++ - } -} - -// CellIndexContentsIterator is an iterator that visits the (CellID, label) pairs -// that cover a set of leaf cell ranges (see CellIndexRangeIterator). Note that -// when multiple leaf cell ranges are visited, this iterator only guarantees that -// each result will be reported at least once, i.e. duplicate values may be -// suppressed. If you want duplicate values to be reported again, be sure to call -// Clear first. -// -// In particular, the implementation guarantees that when multiple leaf -// cell ranges are visited in monotonically increasing order, then each -// (CellID, label) pair is reported exactly once. -type CellIndexContentsIterator struct { - // The maximum index within the cellTree slice visited during the - // previous call to StartUnion. This is used to eliminate duplicate - // values when StartUnion is called multiple times. - nodeCutoff int32 - - // The maximum index within the cellTree visited during the - // current call to StartUnion. This is used to update nodeCutoff. - nextNodeCutoff int32 - - // The value of startID from the previous call to StartUnion. - // This is used to check whether these values are monotonically - // increasing. - prevStartID CellID - - // The cell tree from CellIndex - cellTree []cellIndexNode - - // A copy of the current node in the cell tree. - node cellIndexNode -} - -// NewCellIndexContentsIterator returns a new contents iterator. -// -// Note that the iterator needs to be positioned using StartUnion before -// it can be safely used. -func NewCellIndexContentsIterator(index *CellIndex) *CellIndexContentsIterator { - it := &CellIndexContentsIterator{ - cellTree: index.cellTree, - prevStartID: 0, - nodeCutoff: -1, - nextNodeCutoff: -1, - node: cellIndexNode{label: cellIndexDoneContents}, - } - return it -} - -// Clear clears all state with respect to which range(s) have been visited. -func (c *CellIndexContentsIterator) Clear() { - c.prevStartID = 0 - c.nodeCutoff = -1 - c.nextNodeCutoff = -1 - c.node.label = cellIndexDoneContents -} - -// CellID returns the current CellID. -func (c *CellIndexContentsIterator) CellID() CellID { - return c.node.cellID -} - -// Label returns the current Label. -func (c *CellIndexContentsIterator) Label() int32 { - return c.node.label -} - -// Next advances the iterator to the next (CellID, label) pair covered by the -// current leaf cell range. -// -// This requires the iterator to not be done. -func (c *CellIndexContentsIterator) Next() { - if c.node.parent <= c.nodeCutoff { - // We have already processed this node and its ancestors. - c.nodeCutoff = c.nextNodeCutoff - c.node.label = cellIndexDoneContents - } else { - c.node = c.cellTree[c.node.parent] - } -} - -// Done reports if all (CellID, label) pairs have been visited. -func (c *CellIndexContentsIterator) Done() bool { - return c.node.label == cellIndexDoneContents -} - -// StartUnion positions the ContentsIterator at the first (cell_id, label) pair -// that covers the given leaf cell range. Note that when multiple leaf cell -// ranges are visited using the same ContentsIterator, duplicate values -// may be suppressed. If you don't want this behavior, call Reset() first. -func (c *CellIndexContentsIterator) StartUnion(r *CellIndexRangeIterator) { - if r.StartID() < c.prevStartID { - c.nodeCutoff = -1 // Can't automatically eliminate duplicates. - } - c.prevStartID = r.StartID() - - contents := r.rangeNodes[r.pos].contents - if contents <= c.nodeCutoff { - c.node.label = cellIndexDoneContents - } else { - c.node = c.cellTree[contents] - } - - // When visiting ancestors, we can stop as soon as the node index is smaller - // than any previously visited node index. Because indexes are assigned - // using a preorder traversal, such nodes are guaranteed to have already - // been reported. - c.nextNodeCutoff = contents -} - -// CellIndex stores a collection of (CellID, label) pairs. -// -// The CellIDs may be overlapping or contain duplicate values. For example, a -// CellIndex could store a collection of CellUnions, where each CellUnion -// gets its own non-negative int32 label. -// -// Similar to ShapeIndex and PointIndex which map each stored element to an -// identifier, CellIndex stores a label that is typically used to map the -// results of queries back to client's specific data. -// -// The zero value for a CellIndex is sufficient when constructing a CellIndex. -// -// To build a CellIndex where each Cell has a distinct label, call Add for each -// (CellID, label) pair, and then Build the index. For example: -// -// // contents is a mapping of an identifier in my system (restaurantID, -// // vehicleID, etc) to a CellID -// var contents = map[int32]CellID{...} -// -// for key, val := range contents { -// index.Add(val, key) -// } -// -// index.Build() -// -// There is also a helper method that adds all elements of CellUnion with the -// same label: -// -// index.AddCellUnion(cellUnion, label) -// -// Note that the index is not dynamic; the contents of the index cannot be -// changed once it has been built. Adding more after calling Build results in -// undefined behavior of the index. -// -// There are several options for retrieving data from the index. The simplest -// is to use a built-in method such as IntersectingLabels (which returns -// the labels of all cells that intersect a given target CellUnion): -// -// labels := index.IntersectingLabels(targetUnion); -// -// Alternatively, you can use a ClosestCellQuery which computes the cell(s) -// that are closest to a given target geometry. -// -// For example, here is how to find all cells that are closer than -// distanceLimit to a given target point: -// -// query := NewClosestCellQuery(cellIndex, opts) -// target := NewMinDistanceToPointTarget(targetPoint); -// for result := range query.FindCells(target) { -// // result.Distance() is the distance to the target. -// // result.CellID() is the indexed CellID. -// // result.Label() is the label associated with the CellID. -// DoSomething(targetPoint, result); -// } -// -// Internally, the index consists of a set of non-overlapping leaf cell ranges -// that subdivide the sphere and such that each range intersects a particular -// set of (cellID, label) pairs. -// -// Most clients should use either the methods such as VisitIntersectingCells -// and IntersectingLabels, or a helper such as ClosestCellQuery. -type CellIndex struct { - // A tree of (cellID, label) pairs such that if X is an ancestor of Y, then - // X.cellID contains Y.cellID. The contents of a given range of leaf - // cells can be represented by pointing to a node of this tree. - cellTree []cellIndexNode - - // The last element of rangeNodes is a sentinel value, which is necessary - // in order to represent the range covered by the previous element. - rangeNodes []rangeNode -} - -// Add adds the given CellID and Label to the index. -func (c *CellIndex) Add(id CellID, label int32) { - if label < 0 { - panic("labels must be non-negative") - } - c.cellTree = append(c.cellTree, cellIndexNode{cellID: id, label: label, parent: -1}) -} - -// AddCellUnion adds all of the elements of the given CellUnion to the index with the same label. -func (c *CellIndex) AddCellUnion(cu CellUnion, label int32) { - if label < 0 { - panic("labels must be non-negative") - } - for _, cell := range cu { - c.Add(cell, label) - } -} - -// Build builds the index for use. This method should only be called once. -func (c *CellIndex) Build() { - // To build the cell tree and leaf cell ranges, we maintain a stack of - // (CellID, label) pairs that contain the current leaf cell. This struct - // represents an instruction to push or pop a (cellID, label) pair. - // - // If label >= 0, the (cellID, label) pair is pushed on the stack. - // If CellID == SentinelCellID, a pair is popped from the stack. - // Otherwise the stack is unchanged but a rangeNode is still emitted. - - // delta represents an entry in a stack of (CellID, label) pairs used in the - // construction of the CellIndex structure. - type delta struct { - startID CellID - cellID CellID - label int32 - } - - deltas := make([]delta, 0, 2*len(c.cellTree)+2) - - // Create two deltas for each (cellID, label) pair: one to add the pair to - // the stack (at the start of its leaf cell range), and one to remove it from - // the stack (at the end of its leaf cell range). - for _, node := range c.cellTree { - deltas = append(deltas, delta{ - startID: node.cellID.RangeMin(), - cellID: node.cellID, - label: node.label, - }) - deltas = append(deltas, delta{ - startID: node.cellID.RangeMax().Next(), - cellID: SentinelCellID, - label: -1, - }) - } - - // We also create two special deltas to ensure that a RangeNode is emitted at - // the beginning and end of the CellID range. - deltas = append(deltas, delta{ - startID: CellIDFromFace(0).ChildBeginAtLevel(maxLevel), - cellID: CellID(0), - label: -1, - }) - deltas = append(deltas, delta{ - startID: CellIDFromFace(5).ChildEndAtLevel(maxLevel), - cellID: CellID(0), - label: -1, - }) - - sort.Slice(deltas, func(i, j int) bool { - // deltas are sorted first by startID, then in reverse order by cellID, - // and then by label. This is necessary to ensure that (1) larger cells - // are pushed on the stack before smaller cells, and (2) cells are popped - // off the stack before any new cells are added. - - if si, sj := deltas[i].startID, deltas[j].startID; si != sj { - return si < sj - } - if si, sj := deltas[i].cellID, deltas[j].cellID; si != sj { - return si > sj - } - return deltas[i].label < deltas[j].label - }) - - // Now walk through the deltas to build the leaf cell ranges and cell tree - // (which is essentially a permanent form of the "stack" described above). - c.cellTree = nil - c.rangeNodes = nil - contents := int32(-1) - for i := 0; i < len(deltas); { - startID := deltas[i].startID - // Process all the deltas associated with the current startID. - for ; i < len(deltas) && deltas[i].startID == startID; i++ { - if deltas[i].label >= 0 { - c.cellTree = append(c.cellTree, cellIndexNode{ - cellID: deltas[i].cellID, - label: deltas[i].label, - parent: contents}) - contents = int32(len(c.cellTree) - 1) - } else if deltas[i].cellID == SentinelCellID { - contents = c.cellTree[contents].parent - } - } - c.rangeNodes = append(c.rangeNodes, rangeNode{startID, contents}) - } -} - -// TODO(roberts): Differences from C++ -// IntersectingLabels -// VisitIntersectingCells -// CellIndexIterator diff --git a/vendor/github.com/golang/geo/s2/cellid.go b/vendor/github.com/golang/geo/s2/cellid.go deleted file mode 100644 index c6cbaf2db..000000000 --- a/vendor/github.com/golang/geo/s2/cellid.go +++ /dev/null @@ -1,944 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "bytes" - "fmt" - "io" - "math" - "sort" - "strconv" - "strings" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r2" - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// CellID uniquely identifies a cell in the S2 cell decomposition. -// The most significant 3 bits encode the face number (0-5). The -// remaining 61 bits encode the position of the center of this cell -// along the Hilbert curve on that face. The zero value and the value -// (1<<64)-1 are invalid cell IDs. The first compares less than any -// valid cell ID, the second as greater than any valid cell ID. -// -// Sequentially increasing cell IDs follow a continuous space-filling curve -// over the entire sphere. They have the following properties: -// -// - The ID of a cell at level k consists of a 3-bit face number followed -// by k bit pairs that recursively select one of the four children of -// each cell. The next bit is always 1, and all other bits are 0. -// Therefore, the level of a cell is determined by the position of its -// lowest-numbered bit that is turned on (for a cell at level k, this -// position is 2 * (maxLevel - k)). -// -// - The ID of a parent cell is at the midpoint of the range of IDs spanned -// by its children (or by its descendants at any level). -// -// Leaf cells are often used to represent points on the unit sphere, and -// this type provides methods for converting directly between these two -// representations. For cells that represent 2D regions rather than -// discrete point, it is better to use Cells. -type CellID uint64 - -// SentinelCellID is an invalid cell ID guaranteed to be larger than any -// valid cell ID. It is used primarily by ShapeIndex. The value is also used -// by some S2 types when encoding data. -// Note that the sentinel's RangeMin == RangeMax == itself. -const SentinelCellID = CellID(^uint64(0)) - -// sortCellIDs sorts the slice of CellIDs in place. -func sortCellIDs(ci []CellID) { - sort.Sort(cellIDs(ci)) -} - -// cellIDs implements the Sort interface for slices of CellIDs. -type cellIDs []CellID - -func (c cellIDs) Len() int { return len(c) } -func (c cellIDs) Swap(i, j int) { c[i], c[j] = c[j], c[i] } -func (c cellIDs) Less(i, j int) bool { return c[i] < c[j] } - -// TODO(dsymonds): Some of these constants should probably be exported. -const ( - faceBits = 3 - numFaces = 6 - - // This is the number of levels needed to specify a leaf cell. - maxLevel = 30 - - // The extra position bit (61 rather than 60) lets us encode each cell as its - // Hilbert curve position at the cell center (which is halfway along the - // portion of the Hilbert curve that fills that cell). - posBits = 2*maxLevel + 1 - - // The maximum index of a valid leaf cell plus one. The range of valid leaf - // cell indices is [0..maxSize-1]. - maxSize = 1 << maxLevel - - wrapOffset = uint64(numFaces) << posBits -) - -// CellIDFromFacePosLevel returns a cell given its face in the range -// [0,5], the 61-bit Hilbert curve position pos within that face, and -// the level in the range [0,maxLevel]. The position in the cell ID -// will be truncated to correspond to the Hilbert curve position at -// the center of the returned cell. -func CellIDFromFacePosLevel(face int, pos uint64, level int) CellID { - return CellID(uint64(face)<<posBits + pos | 1).Parent(level) -} - -// CellIDFromFace returns the cell corresponding to a given S2 cube face. -func CellIDFromFace(face int) CellID { - return CellID((uint64(face) << posBits) + lsbForLevel(0)) -} - -// CellIDFromLatLng returns the leaf cell containing ll. -func CellIDFromLatLng(ll LatLng) CellID { - return cellIDFromPoint(PointFromLatLng(ll)) -} - -// CellIDFromToken returns a cell given a hex-encoded string of its uint64 ID. -func CellIDFromToken(s string) CellID { - if len(s) > 16 { - return CellID(0) - } - n, err := strconv.ParseUint(s, 16, 64) - if err != nil { - return CellID(0) - } - // Equivalent to right-padding string with zeros to 16 characters. - if len(s) < 16 { - n = n << (4 * uint(16-len(s))) - } - return CellID(n) -} - -// ToToken returns a hex-encoded string of the uint64 cell id, with leading -// zeros included but trailing zeros stripped. -func (ci CellID) ToToken() string { - s := strings.TrimRight(fmt.Sprintf("%016x", uint64(ci)), "0") - if len(s) == 0 { - return "X" - } - return s -} - -// IsValid reports whether ci represents a valid cell. -func (ci CellID) IsValid() bool { - return ci.Face() < numFaces && (ci.lsb()&0x1555555555555555 != 0) -} - -// Face returns the cube face for this cell ID, in the range [0,5]. -func (ci CellID) Face() int { return int(uint64(ci) >> posBits) } - -// Pos returns the position along the Hilbert curve of this cell ID, in the range [0,2^posBits-1]. -func (ci CellID) Pos() uint64 { return uint64(ci) & (^uint64(0) >> faceBits) } - -// Level returns the subdivision level of this cell ID, in the range [0, maxLevel]. -func (ci CellID) Level() int { - return maxLevel - findLSBSetNonZero64(uint64(ci))>>1 -} - -// IsLeaf returns whether this cell ID is at the deepest level; -// that is, the level at which the cells are smallest. -func (ci CellID) IsLeaf() bool { return uint64(ci)&1 != 0 } - -// ChildPosition returns the child position (0..3) of this cell's -// ancestor at the given level, relative to its parent. The argument -// should be in the range 1..kMaxLevel. For example, -// ChildPosition(1) returns the position of this cell's level-1 -// ancestor within its top-level face cell. -func (ci CellID) ChildPosition(level int) int { - return int(uint64(ci)>>uint64(2*(maxLevel-level)+1)) & 3 -} - -// lsbForLevel returns the lowest-numbered bit that is on for cells at the given level. -func lsbForLevel(level int) uint64 { return 1 << uint64(2*(maxLevel-level)) } - -// Parent returns the cell at the given level, which must be no greater than the current level. -func (ci CellID) Parent(level int) CellID { - lsb := lsbForLevel(level) - return CellID((uint64(ci) & -lsb) | lsb) -} - -// immediateParent is cheaper than Parent, but assumes !ci.isFace(). -func (ci CellID) immediateParent() CellID { - nlsb := CellID(ci.lsb() << 2) - return (ci & -nlsb) | nlsb -} - -// isFace returns whether this is a top-level (face) cell. -func (ci CellID) isFace() bool { return uint64(ci)&(lsbForLevel(0)-1) == 0 } - -// lsb returns the least significant bit that is set. -func (ci CellID) lsb() uint64 { return uint64(ci) & -uint64(ci) } - -// Children returns the four immediate children of this cell. -// If ci is a leaf cell, it returns four identical cells that are not the children. -func (ci CellID) Children() [4]CellID { - var ch [4]CellID - lsb := CellID(ci.lsb()) - ch[0] = ci - lsb + lsb>>2 - lsb >>= 1 - ch[1] = ch[0] + lsb - ch[2] = ch[1] + lsb - ch[3] = ch[2] + lsb - return ch -} - -func sizeIJ(level int) int { - return 1 << uint(maxLevel-level) -} - -// EdgeNeighbors returns the four cells that are adjacent across the cell's four edges. -// Edges 0, 1, 2, 3 are in the down, right, up, left directions in the face space. -// All neighbors are guaranteed to be distinct. -func (ci CellID) EdgeNeighbors() [4]CellID { - level := ci.Level() - size := sizeIJ(level) - f, i, j, _ := ci.faceIJOrientation() - return [4]CellID{ - cellIDFromFaceIJWrap(f, i, j-size).Parent(level), - cellIDFromFaceIJWrap(f, i+size, j).Parent(level), - cellIDFromFaceIJWrap(f, i, j+size).Parent(level), - cellIDFromFaceIJWrap(f, i-size, j).Parent(level), - } -} - -// VertexNeighbors returns the neighboring cellIDs with vertex closest to this cell at the given level. -// (Normally there are four neighbors, but the closest vertex may only have three neighbors if it is one of -// the 8 cube vertices.) -func (ci CellID) VertexNeighbors(level int) []CellID { - halfSize := sizeIJ(level + 1) - size := halfSize << 1 - f, i, j, _ := ci.faceIJOrientation() - - var isame, jsame bool - var ioffset, joffset int - if i&halfSize != 0 { - ioffset = size - isame = (i + size) < maxSize - } else { - ioffset = -size - isame = (i - size) >= 0 - } - if j&halfSize != 0 { - joffset = size - jsame = (j + size) < maxSize - } else { - joffset = -size - jsame = (j - size) >= 0 - } - - results := []CellID{ - ci.Parent(level), - cellIDFromFaceIJSame(f, i+ioffset, j, isame).Parent(level), - cellIDFromFaceIJSame(f, i, j+joffset, jsame).Parent(level), - } - - if isame || jsame { - results = append(results, cellIDFromFaceIJSame(f, i+ioffset, j+joffset, isame && jsame).Parent(level)) - } - - return results -} - -// AllNeighbors returns all neighbors of this cell at the given level. Two -// cells X and Y are neighbors if their boundaries intersect but their -// interiors do not. In particular, two cells that intersect at a single -// point are neighbors. Note that for cells adjacent to a face vertex, the -// same neighbor may be returned more than once. There could be up to eight -// neighbors including the diagonal ones that share the vertex. -// -// This requires level >= ci.Level(). -func (ci CellID) AllNeighbors(level int) []CellID { - var neighbors []CellID - - face, i, j, _ := ci.faceIJOrientation() - - // Find the coordinates of the lower left-hand leaf cell. We need to - // normalize (i,j) to a known position within the cell because level - // may be larger than this cell's level. - size := sizeIJ(ci.Level()) - i &= -size - j &= -size - - nbrSize := sizeIJ(level) - - // We compute the top-bottom, left-right, and diagonal neighbors in one - // pass. The loop test is at the end of the loop to avoid 32-bit overflow. - for k := -nbrSize; ; k += nbrSize { - var sameFace bool - if k < 0 { - sameFace = (j+k >= 0) - } else if k >= size { - sameFace = (j+k < maxSize) - } else { - sameFace = true - // Top and bottom neighbors. - neighbors = append(neighbors, cellIDFromFaceIJSame(face, i+k, j-nbrSize, - j-size >= 0).Parent(level)) - neighbors = append(neighbors, cellIDFromFaceIJSame(face, i+k, j+size, - j+size < maxSize).Parent(level)) - } - - // Left, right, and diagonal neighbors. - neighbors = append(neighbors, cellIDFromFaceIJSame(face, i-nbrSize, j+k, - sameFace && i-size >= 0).Parent(level)) - neighbors = append(neighbors, cellIDFromFaceIJSame(face, i+size, j+k, - sameFace && i+size < maxSize).Parent(level)) - - if k >= size { - break - } - } - - return neighbors -} - -// RangeMin returns the minimum CellID that is contained within this cell. -func (ci CellID) RangeMin() CellID { return CellID(uint64(ci) - (ci.lsb() - 1)) } - -// RangeMax returns the maximum CellID that is contained within this cell. -func (ci CellID) RangeMax() CellID { return CellID(uint64(ci) + (ci.lsb() - 1)) } - -// Contains returns true iff the CellID contains oci. -func (ci CellID) Contains(oci CellID) bool { - return uint64(ci.RangeMin()) <= uint64(oci) && uint64(oci) <= uint64(ci.RangeMax()) -} - -// Intersects returns true iff the CellID intersects oci. -func (ci CellID) Intersects(oci CellID) bool { - return uint64(oci.RangeMin()) <= uint64(ci.RangeMax()) && uint64(oci.RangeMax()) >= uint64(ci.RangeMin()) -} - -// String returns the string representation of the cell ID in the form "1/3210". -func (ci CellID) String() string { - if !ci.IsValid() { - return "Invalid: " + strconv.FormatInt(int64(ci), 16) - } - var b bytes.Buffer - b.WriteByte("012345"[ci.Face()]) // values > 5 will have been picked off by !IsValid above - b.WriteByte('/') - for level := 1; level <= ci.Level(); level++ { - b.WriteByte("0123"[ci.ChildPosition(level)]) - } - return b.String() -} - -// cellIDFromString returns a CellID from a string in the form "1/3210". -func cellIDFromString(s string) CellID { - level := len(s) - 2 - if level < 0 || level > maxLevel { - return CellID(0) - } - face := int(s[0] - '0') - if face < 0 || face > 5 || s[1] != '/' { - return CellID(0) - } - id := CellIDFromFace(face) - for i := 2; i < len(s); i++ { - childPos := s[i] - '0' - if childPos < 0 || childPos > 3 { - return CellID(0) - } - id = id.Children()[childPos] - } - return id -} - -// Point returns the center of the s2 cell on the sphere as a Point. -// The maximum directional error in Point (compared to the exact -// mathematical result) is 1.5 * dblEpsilon radians, and the maximum length -// error is 2 * dblEpsilon (the same as Normalize). -func (ci CellID) Point() Point { return Point{ci.rawPoint().Normalize()} } - -// LatLng returns the center of the s2 cell on the sphere as a LatLng. -func (ci CellID) LatLng() LatLng { return LatLngFromPoint(Point{ci.rawPoint()}) } - -// ChildBegin returns the first child in a traversal of the children of this cell, in Hilbert curve order. -// -// for ci := c.ChildBegin(); ci != c.ChildEnd(); ci = ci.Next() { -// ... -// } -func (ci CellID) ChildBegin() CellID { - ol := ci.lsb() - return CellID(uint64(ci) - ol + ol>>2) -} - -// ChildBeginAtLevel returns the first cell in a traversal of children a given level deeper than this cell, in -// Hilbert curve order. The given level must be no smaller than the cell's level. -// See ChildBegin for example use. -func (ci CellID) ChildBeginAtLevel(level int) CellID { - return CellID(uint64(ci) - ci.lsb() + lsbForLevel(level)) -} - -// ChildEnd returns the first cell after a traversal of the children of this cell in Hilbert curve order. -// The returned cell may be invalid. -func (ci CellID) ChildEnd() CellID { - ol := ci.lsb() - return CellID(uint64(ci) + ol + ol>>2) -} - -// ChildEndAtLevel returns the first cell after the last child in a traversal of children a given level deeper -// than this cell, in Hilbert curve order. -// The given level must be no smaller than the cell's level. -// The returned cell may be invalid. -func (ci CellID) ChildEndAtLevel(level int) CellID { - return CellID(uint64(ci) + ci.lsb() + lsbForLevel(level)) -} - -// Next returns the next cell along the Hilbert curve. -// This is expected to be used with ChildBegin and ChildEnd, -// or ChildBeginAtLevel and ChildEndAtLevel. -func (ci CellID) Next() CellID { - return CellID(uint64(ci) + ci.lsb()<<1) -} - -// Prev returns the previous cell along the Hilbert curve. -func (ci CellID) Prev() CellID { - return CellID(uint64(ci) - ci.lsb()<<1) -} - -// NextWrap returns the next cell along the Hilbert curve, wrapping from last to -// first as necessary. This should not be used with ChildBegin and ChildEnd. -func (ci CellID) NextWrap() CellID { - n := ci.Next() - if uint64(n) < wrapOffset { - return n - } - return CellID(uint64(n) - wrapOffset) -} - -// PrevWrap returns the previous cell along the Hilbert curve, wrapping around from -// first to last as necessary. This should not be used with ChildBegin and ChildEnd. -func (ci CellID) PrevWrap() CellID { - p := ci.Prev() - if uint64(p) < wrapOffset { - return p - } - return CellID(uint64(p) + wrapOffset) -} - -// AdvanceWrap advances or retreats the indicated number of steps along the -// Hilbert curve at the current level and returns the new position. The -// position wraps between the first and last faces as necessary. -func (ci CellID) AdvanceWrap(steps int64) CellID { - if steps == 0 { - return ci - } - - // We clamp the number of steps if necessary to ensure that we do not - // advance past the End() or before the Begin() of this level. - shift := uint(2*(maxLevel-ci.Level()) + 1) - if steps < 0 { - if min := -int64(uint64(ci) >> shift); steps < min { - wrap := int64(wrapOffset >> shift) - steps %= wrap - if steps < min { - steps += wrap - } - } - } else { - // Unlike Advance(), we don't want to return End(level). - if max := int64((wrapOffset - uint64(ci)) >> shift); steps > max { - wrap := int64(wrapOffset >> shift) - steps %= wrap - if steps > max { - steps -= wrap - } - } - } - - // If steps is negative, then shifting it left has undefined behavior. - // Cast to uint64 for a 2's complement answer. - return CellID(uint64(ci) + (uint64(steps) << shift)) -} - -// Encode encodes the CellID. -func (ci CellID) Encode(w io.Writer) error { - e := &encoder{w: w} - ci.encode(e) - return e.err -} - -func (ci CellID) encode(e *encoder) { - e.writeUint64(uint64(ci)) -} - -// Decode decodes the CellID. -func (ci *CellID) Decode(r io.Reader) error { - d := &decoder{r: asByteReader(r)} - ci.decode(d) - return d.err -} - -func (ci *CellID) decode(d *decoder) { - *ci = CellID(d.readUint64()) -} - -// TODO: the methods below are not exported yet. Settle on the entire API design -// before doing this. Do we want to mirror the C++ one as closely as possible? - -// distanceFromBegin returns the number of steps along the Hilbert curve that -// this cell is from the first node in the S2 hierarchy at our level. (i.e., -// FromFace(0).ChildBeginAtLevel(ci.Level())). This is analogous to Pos(), but -// for this cell's level. -// The return value is always non-negative. -func (ci CellID) distanceFromBegin() int64 { - return int64(ci >> uint64(2*(maxLevel-ci.Level())+1)) -} - -// rawPoint returns an unnormalized r3 vector from the origin through the center -// of the s2 cell on the sphere. -func (ci CellID) rawPoint() r3.Vector { - face, si, ti := ci.faceSiTi() - return faceUVToXYZ(face, stToUV((0.5/maxSize)*float64(si)), stToUV((0.5/maxSize)*float64(ti))) -} - -// faceSiTi returns the Face/Si/Ti coordinates of the center of the cell. -func (ci CellID) faceSiTi() (face int, si, ti uint32) { - face, i, j, _ := ci.faceIJOrientation() - delta := 0 - if ci.IsLeaf() { - delta = 1 - } else { - if (i^(int(ci)>>2))&1 != 0 { - delta = 2 - } - } - return face, uint32(2*i + delta), uint32(2*j + delta) -} - -// faceIJOrientation uses the global lookupIJ table to unfiddle the bits of ci. -func (ci CellID) faceIJOrientation() (f, i, j, orientation int) { - f = ci.Face() - orientation = f & swapMask - nbits := maxLevel - 7*lookupBits // first iteration - - // Each iteration maps 8 bits of the Hilbert curve position into - // 4 bits of "i" and "j". The lookup table transforms a key of the - // form "ppppppppoo" to a value of the form "iiiijjjjoo", where the - // letters [ijpo] represents bits of "i", "j", the Hilbert curve - // position, and the Hilbert curve orientation respectively. - // - // On the first iteration we need to be careful to clear out the bits - // representing the cube face. - for k := 7; k >= 0; k-- { - orientation += (int(uint64(ci)>>uint64(k*2*lookupBits+1)) & ((1 << uint(2*nbits)) - 1)) << 2 - orientation = lookupIJ[orientation] - i += (orientation >> (lookupBits + 2)) << uint(k*lookupBits) - j += ((orientation >> 2) & ((1 << lookupBits) - 1)) << uint(k*lookupBits) - orientation &= (swapMask | invertMask) - nbits = lookupBits // following iterations - } - - // The position of a non-leaf cell at level "n" consists of a prefix of - // 2*n bits that identifies the cell, followed by a suffix of - // 2*(maxLevel-n)+1 bits of the form 10*. If n==maxLevel, the suffix is - // just "1" and has no effect. Otherwise, it consists of "10", followed - // by (maxLevel-n-1) repetitions of "00", followed by "0". The "10" has - // no effect, while each occurrence of "00" has the effect of reversing - // the swapMask bit. - if ci.lsb()&0x1111111111111110 != 0 { - orientation ^= swapMask - } - - return -} - -// cellIDFromFaceIJ returns a leaf cell given its cube face (range 0..5) and IJ coordinates. -func cellIDFromFaceIJ(f, i, j int) CellID { - // Note that this value gets shifted one bit to the left at the end - // of the function. - n := uint64(f) << (posBits - 1) - // Alternating faces have opposite Hilbert curve orientations; this - // is necessary in order for all faces to have a right-handed - // coordinate system. - bits := f & swapMask - // Each iteration maps 4 bits of "i" and "j" into 8 bits of the Hilbert - // curve position. The lookup table transforms a 10-bit key of the form - // "iiiijjjjoo" to a 10-bit value of the form "ppppppppoo", where the - // letters [ijpo] denote bits of "i", "j", Hilbert curve position, and - // Hilbert curve orientation respectively. - for k := 7; k >= 0; k-- { - mask := (1 << lookupBits) - 1 - bits += ((i >> uint(k*lookupBits)) & mask) << (lookupBits + 2) - bits += ((j >> uint(k*lookupBits)) & mask) << 2 - bits = lookupPos[bits] - n |= uint64(bits>>2) << (uint(k) * 2 * lookupBits) - bits &= (swapMask | invertMask) - } - return CellID(n*2 + 1) -} - -func cellIDFromFaceIJWrap(f, i, j int) CellID { - // Convert i and j to the coordinates of a leaf cell just beyond the - // boundary of this face. This prevents 32-bit overflow in the case - // of finding the neighbors of a face cell. - i = clampInt(i, -1, maxSize) - j = clampInt(j, -1, maxSize) - - // We want to wrap these coordinates onto the appropriate adjacent face. - // The easiest way to do this is to convert the (i,j) coordinates to (x,y,z) - // (which yields a point outside the normal face boundary), and then call - // xyzToFaceUV to project back onto the correct face. - // - // The code below converts (i,j) to (si,ti), and then (si,ti) to (u,v) using - // the linear projection (u=2*s-1 and v=2*t-1). (The code further below - // converts back using the inverse projection, s=0.5*(u+1) and t=0.5*(v+1). - // Any projection would work here, so we use the simplest.) We also clamp - // the (u,v) coordinates so that the point is barely outside the - // [-1,1]x[-1,1] face rectangle, since otherwise the reprojection step - // (which divides by the new z coordinate) might change the other - // coordinates enough so that we end up in the wrong leaf cell. - const scale = 1.0 / maxSize - limit := math.Nextafter(1, 2) - u := math.Max(-limit, math.Min(limit, scale*float64((i<<1)+1-maxSize))) - v := math.Max(-limit, math.Min(limit, scale*float64((j<<1)+1-maxSize))) - - // Find the leaf cell coordinates on the adjacent face, and convert - // them to a cell id at the appropriate level. - f, u, v = xyzToFaceUV(faceUVToXYZ(f, u, v)) - return cellIDFromFaceIJ(f, stToIJ(0.5*(u+1)), stToIJ(0.5*(v+1))) -} - -func cellIDFromFaceIJSame(f, i, j int, sameFace bool) CellID { - if sameFace { - return cellIDFromFaceIJ(f, i, j) - } - return cellIDFromFaceIJWrap(f, i, j) -} - -// ijToSTMin converts the i- or j-index of a leaf cell to the minimum corresponding -// s- or t-value contained by that cell. The argument must be in the range -// [0..2**30], i.e. up to one position beyond the normal range of valid leaf -// cell indices. -func ijToSTMin(i int) float64 { - return float64(i) / float64(maxSize) -} - -// stToIJ converts value in ST coordinates to a value in IJ coordinates. -func stToIJ(s float64) int { - return clampInt(int(math.Floor(maxSize*s)), 0, maxSize-1) -} - -// cellIDFromPoint returns a leaf cell containing point p. Usually there is -// exactly one such cell, but for points along the edge of a cell, any -// adjacent cell may be (deterministically) chosen. This is because -// s2.CellIDs are considered to be closed sets. The returned cell will -// always contain the given point, i.e. -// -// CellFromPoint(p).ContainsPoint(p) -// -// is always true. -func cellIDFromPoint(p Point) CellID { - f, u, v := xyzToFaceUV(r3.Vector{p.X, p.Y, p.Z}) - i := stToIJ(uvToST(u)) - j := stToIJ(uvToST(v)) - return cellIDFromFaceIJ(f, i, j) -} - -// ijLevelToBoundUV returns the bounds in (u,v)-space for the cell at the given -// level containing the leaf cell with the given (i,j)-coordinates. -func ijLevelToBoundUV(i, j, level int) r2.Rect { - cellSize := sizeIJ(level) - xLo := i & -cellSize - yLo := j & -cellSize - - return r2.Rect{ - X: r1.Interval{ - Lo: stToUV(ijToSTMin(xLo)), - Hi: stToUV(ijToSTMin(xLo + cellSize)), - }, - Y: r1.Interval{ - Lo: stToUV(ijToSTMin(yLo)), - Hi: stToUV(ijToSTMin(yLo + cellSize)), - }, - } -} - -// Constants related to the bit mangling in the Cell ID. -const ( - lookupBits = 4 - swapMask = 0x01 - invertMask = 0x02 -) - -// The following lookup tables are used to convert efficiently between an -// (i,j) cell index and the corresponding position along the Hilbert curve. -// -// lookupPos maps 4 bits of "i", 4 bits of "j", and 2 bits representing the -// orientation of the current cell into 8 bits representing the order in which -// that subcell is visited by the Hilbert curve, plus 2 bits indicating the -// new orientation of the Hilbert curve within that subcell. (Cell -// orientations are represented as combination of swapMask and invertMask.) -// -// lookupIJ is an inverted table used for mapping in the opposite -// direction. -// -// We also experimented with looking up 16 bits at a time (14 bits of position -// plus 2 of orientation) but found that smaller lookup tables gave better -// performance. (2KB fits easily in the primary cache.) -var ( - ijToPos = [4][4]int{ - {0, 1, 3, 2}, // canonical order - {0, 3, 1, 2}, // axes swapped - {2, 3, 1, 0}, // bits inverted - {2, 1, 3, 0}, // swapped & inverted - } - posToIJ = [4][4]int{ - {0, 1, 3, 2}, // canonical order: (0,0), (0,1), (1,1), (1,0) - {0, 2, 3, 1}, // axes swapped: (0,0), (1,0), (1,1), (0,1) - {3, 2, 0, 1}, // bits inverted: (1,1), (1,0), (0,0), (0,1) - {3, 1, 0, 2}, // swapped & inverted: (1,1), (0,1), (0,0), (1,0) - } - posToOrientation = [4]int{swapMask, 0, 0, invertMask | swapMask} - lookupIJ [1 << (2*lookupBits + 2)]int - lookupPos [1 << (2*lookupBits + 2)]int -) - -func init() { - initLookupCell(0, 0, 0, 0, 0, 0) - initLookupCell(0, 0, 0, swapMask, 0, swapMask) - initLookupCell(0, 0, 0, invertMask, 0, invertMask) - initLookupCell(0, 0, 0, swapMask|invertMask, 0, swapMask|invertMask) -} - -// initLookupCell initializes the lookupIJ table at init time. -func initLookupCell(level, i, j, origOrientation, pos, orientation int) { - if level == lookupBits { - ij := (i << lookupBits) + j - lookupPos[(ij<<2)+origOrientation] = (pos << 2) + orientation - lookupIJ[(pos<<2)+origOrientation] = (ij << 2) + orientation - return - } - - level++ - i <<= 1 - j <<= 1 - pos <<= 2 - r := posToIJ[orientation] - initLookupCell(level, i+(r[0]>>1), j+(r[0]&1), origOrientation, pos, orientation^posToOrientation[0]) - initLookupCell(level, i+(r[1]>>1), j+(r[1]&1), origOrientation, pos+1, orientation^posToOrientation[1]) - initLookupCell(level, i+(r[2]>>1), j+(r[2]&1), origOrientation, pos+2, orientation^posToOrientation[2]) - initLookupCell(level, i+(r[3]>>1), j+(r[3]&1), origOrientation, pos+3, orientation^posToOrientation[3]) -} - -// CommonAncestorLevel returns the level of the common ancestor of the two S2 CellIDs. -func (ci CellID) CommonAncestorLevel(other CellID) (level int, ok bool) { - bits := uint64(ci ^ other) - if bits < ci.lsb() { - bits = ci.lsb() - } - if bits < other.lsb() { - bits = other.lsb() - } - - msbPos := findMSBSetNonZero64(bits) - if msbPos > 60 { - return 0, false - } - return (60 - msbPos) >> 1, true -} - -// Advance advances or retreats the indicated number of steps along the -// Hilbert curve at the current level, and returns the new position. The -// position is never advanced past End() or before Begin(). -func (ci CellID) Advance(steps int64) CellID { - if steps == 0 { - return ci - } - - // We clamp the number of steps if necessary to ensure that we do not - // advance past the End() or before the Begin() of this level. Note that - // minSteps and maxSteps always fit in a signed 64-bit integer. - stepShift := uint(2*(maxLevel-ci.Level()) + 1) - if steps < 0 { - minSteps := -int64(uint64(ci) >> stepShift) - if steps < minSteps { - steps = minSteps - } - } else { - maxSteps := int64((wrapOffset + ci.lsb() - uint64(ci)) >> stepShift) - if steps > maxSteps { - steps = maxSteps - } - } - return ci + CellID(steps)<<stepShift -} - -// centerST return the center of the CellID in (s,t)-space. -func (ci CellID) centerST() r2.Point { - _, si, ti := ci.faceSiTi() - return r2.Point{siTiToST(si), siTiToST(ti)} -} - -// sizeST returns the edge length of this CellID in (s,t)-space at the given level. -func (ci CellID) sizeST(level int) float64 { - return ijToSTMin(sizeIJ(level)) -} - -// boundST returns the bound of this CellID in (s,t)-space. -func (ci CellID) boundST() r2.Rect { - s := ci.sizeST(ci.Level()) - return r2.RectFromCenterSize(ci.centerST(), r2.Point{s, s}) -} - -// centerUV returns the center of this CellID in (u,v)-space. Note that -// the center of the cell is defined as the point at which it is recursively -// subdivided into four children; in general, it is not at the midpoint of -// the (u,v) rectangle covered by the cell. -func (ci CellID) centerUV() r2.Point { - _, si, ti := ci.faceSiTi() - return r2.Point{stToUV(siTiToST(si)), stToUV(siTiToST(ti))} -} - -// boundUV returns the bound of this CellID in (u,v)-space. -func (ci CellID) boundUV() r2.Rect { - _, i, j, _ := ci.faceIJOrientation() - return ijLevelToBoundUV(i, j, ci.Level()) -} - -// expandEndpoint returns a new u-coordinate u' such that the distance from the -// line u=u' to the given edge (u,v0)-(u,v1) is exactly the given distance -// (which is specified as the sine of the angle corresponding to the distance). -func expandEndpoint(u, maxV, sinDist float64) float64 { - // This is based on solving a spherical right triangle, similar to the - // calculation in Cap.RectBound. - // Given an edge of the form (u,v0)-(u,v1), let maxV = max(abs(v0), abs(v1)). - sinUShift := sinDist * math.Sqrt((1+u*u+maxV*maxV)/(1+u*u)) - cosUShift := math.Sqrt(1 - sinUShift*sinUShift) - // The following is an expansion of tan(atan(u) + asin(sinUShift)). - return (cosUShift*u + sinUShift) / (cosUShift - sinUShift*u) -} - -// expandedByDistanceUV returns a rectangle expanded in (u,v)-space so that it -// contains all points within the given distance of the boundary, and return the -// smallest such rectangle. If the distance is negative, then instead shrink this -// rectangle so that it excludes all points within the given absolute distance -// of the boundary. -// -// Distances are measured *on the sphere*, not in (u,v)-space. For example, -// you can use this method to expand the (u,v)-bound of an CellID so that -// it contains all points within 5km of the original cell. You can then -// test whether a point lies within the expanded bounds like this: -// -// if u, v, ok := faceXYZtoUV(face, point); ok && bound.ContainsPoint(r2.Point{u,v}) { ... } -// -// Limitations: -// -// - Because the rectangle is drawn on one of the six cube-face planes -// (i.e., {x,y,z} = +/-1), it can cover at most one hemisphere. This -// limits the maximum amount that a rectangle can be expanded. For -// example, CellID bounds can be expanded safely by at most 45 degrees -// (about 5000 km on the Earth's surface). -// -// - The implementation is not exact for negative distances. The resulting -// rectangle will exclude all points within the given distance of the -// boundary but may be slightly smaller than necessary. -func expandedByDistanceUV(uv r2.Rect, distance s1.Angle) r2.Rect { - // Expand each of the four sides of the rectangle just enough to include all - // points within the given distance of that side. (The rectangle may be - // expanded by a different amount in (u,v)-space on each side.) - maxU := math.Max(math.Abs(uv.X.Lo), math.Abs(uv.X.Hi)) - maxV := math.Max(math.Abs(uv.Y.Lo), math.Abs(uv.Y.Hi)) - sinDist := math.Sin(float64(distance)) - return r2.Rect{ - X: r1.Interval{expandEndpoint(uv.X.Lo, maxV, -sinDist), - expandEndpoint(uv.X.Hi, maxV, sinDist)}, - Y: r1.Interval{expandEndpoint(uv.Y.Lo, maxU, -sinDist), - expandEndpoint(uv.Y.Hi, maxU, sinDist)}} -} - -// MaxTile returns the largest cell with the same RangeMin such that -// RangeMax < limit.RangeMin. It returns limit if no such cell exists. -// This method can be used to generate a small set of CellIDs that covers -// a given range (a tiling). This example shows how to generate a tiling -// for a semi-open range of leaf cells [start, limit): -// -// for id := start.MaxTile(limit); id != limit; id = id.Next().MaxTile(limit)) { ... } -// -// Note that in general the cells in the tiling will be of different sizes; -// they gradually get larger (near the middle of the range) and then -// gradually get smaller as limit is approached. -func (ci CellID) MaxTile(limit CellID) CellID { - start := ci.RangeMin() - if start >= limit.RangeMin() { - return limit - } - - if ci.RangeMax() >= limit { - // The cell is too large, shrink it. Note that when generating coverings - // of CellID ranges, this loop usually executes only once. Also because - // ci.RangeMin() < limit.RangeMin(), we will always exit the loop by the - // time we reach a leaf cell. - for { - ci = ci.Children()[0] - if ci.RangeMax() < limit { - break - } - } - return ci - } - - // The cell may be too small. Grow it if necessary. Note that generally - // this loop only iterates once. - for !ci.isFace() { - parent := ci.immediateParent() - if parent.RangeMin() != start || parent.RangeMax() >= limit { - break - } - ci = parent - } - return ci -} - -// centerFaceSiTi returns the (face, si, ti) coordinates of the center of the cell. -// Note that although (si,ti) coordinates span the range [0,2**31] in general, -// the cell center coordinates are always in the range [1,2**31-1] and -// therefore can be represented using a signed 32-bit integer. -func (ci CellID) centerFaceSiTi() (face, si, ti int) { - // First we compute the discrete (i,j) coordinates of a leaf cell contained - // within the given cell. Given that cells are represented by the Hilbert - // curve position corresponding at their center, it turns out that the cell - // returned by faceIJOrientation is always one of two leaf cells closest - // to the center of the cell (unless the given cell is a leaf cell itself, - // in which case there is only one possibility). - // - // Given a cell of size s >= 2 (i.e. not a leaf cell), and letting (imin, - // jmin) be the coordinates of its lower left-hand corner, the leaf cell - // returned by faceIJOrientation is either (imin + s/2, jmin + s/2) - // (imin + s/2 - 1, jmin + s/2 - 1). The first case is the one we want. - // We can distinguish these two cases by looking at the low bit of i or - // j. In the second case the low bit is one, unless s == 2 (i.e. the - // level just above leaf cells) in which case the low bit is zero. - // - // In the code below, the expression ((i ^ (int(id) >> 2)) & 1) is true - // if we are in the second case described above. - face, i, j, _ := ci.faceIJOrientation() - delta := 0 - if ci.IsLeaf() { - delta = 1 - } else if (int64(i)^(int64(ci)>>2))&1 == 1 { - delta = 2 - } - - // Note that (2 * {i,j} + delta) will never overflow a 32-bit integer. - return face, 2*i + delta, 2*j + delta -} diff --git a/vendor/github.com/golang/geo/s2/cellunion.go b/vendor/github.com/golang/geo/s2/cellunion.go deleted file mode 100644 index 0654de973..000000000 --- a/vendor/github.com/golang/geo/s2/cellunion.go +++ /dev/null @@ -1,590 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "sort" - - "github.com/golang/geo/s1" -) - -// A CellUnion is a collection of CellIDs. -// -// It is normalized if it is sorted, and does not contain redundancy. -// Specifically, it may not contain the same CellID twice, nor a CellID that -// is contained by another, nor the four sibling CellIDs that are children of -// a single higher level CellID. -// -// CellUnions are not required to be normalized, but certain operations will -// return different results if they are not (e.g. Contains). -type CellUnion []CellID - -// CellUnionFromRange creates a CellUnion that covers the half-open range -// of leaf cells [begin, end). If begin == end the resulting union is empty. -// This requires that begin and end are both leaves, and begin <= end. -// To create a closed-ended range, pass in end.Next(). -func CellUnionFromRange(begin, end CellID) CellUnion { - // We repeatedly add the largest cell we can. - var cu CellUnion - for id := begin.MaxTile(end); id != end; id = id.Next().MaxTile(end) { - cu = append(cu, id) - } - // The output is normalized because the cells are added in order by the iteration. - return cu -} - -// CellUnionFromUnion creates a CellUnion from the union of the given CellUnions. -func CellUnionFromUnion(cellUnions ...CellUnion) CellUnion { - var cu CellUnion - for _, cellUnion := range cellUnions { - cu = append(cu, cellUnion...) - } - cu.Normalize() - return cu -} - -// CellUnionFromIntersection creates a CellUnion from the intersection of the given CellUnions. -func CellUnionFromIntersection(x, y CellUnion) CellUnion { - var cu CellUnion - - // This is a fairly efficient calculation that uses binary search to skip - // over sections of both input vectors. It takes constant time if all the - // cells of x come before or after all the cells of y in CellID order. - var i, j int - for i < len(x) && j < len(y) { - iMin := x[i].RangeMin() - jMin := y[j].RangeMin() - if iMin > jMin { - // Either j.Contains(i) or the two cells are disjoint. - if x[i] <= y[j].RangeMax() { - cu = append(cu, x[i]) - i++ - } else { - // Advance j to the first cell possibly contained by x[i]. - j = y.lowerBound(j+1, len(y), iMin) - // The previous cell y[j-1] may now contain x[i]. - if x[i] <= y[j-1].RangeMax() { - j-- - } - } - } else if jMin > iMin { - // Identical to the code above with i and j reversed. - if y[j] <= x[i].RangeMax() { - cu = append(cu, y[j]) - j++ - } else { - i = x.lowerBound(i+1, len(x), jMin) - if y[j] <= x[i-1].RangeMax() { - i-- - } - } - } else { - // i and j have the same RangeMin(), so one contains the other. - if x[i] < y[j] { - cu = append(cu, x[i]) - i++ - } else { - cu = append(cu, y[j]) - j++ - } - } - } - - // The output is generated in sorted order. - cu.Normalize() - return cu -} - -// CellUnionFromIntersectionWithCellID creates a CellUnion from the intersection -// of a CellUnion with the given CellID. This can be useful for splitting a -// CellUnion into chunks. -func CellUnionFromIntersectionWithCellID(x CellUnion, id CellID) CellUnion { - var cu CellUnion - if x.ContainsCellID(id) { - cu = append(cu, id) - cu.Normalize() - return cu - } - - idmax := id.RangeMax() - for i := x.lowerBound(0, len(x), id.RangeMin()); i < len(x) && x[i] <= idmax; i++ { - cu = append(cu, x[i]) - } - - cu.Normalize() - return cu -} - -// CellUnionFromDifference creates a CellUnion from the difference (x - y) -// of the given CellUnions. -func CellUnionFromDifference(x, y CellUnion) CellUnion { - // TODO(roberts): This is approximately O(N*log(N)), but could probably - // use similar techniques as CellUnionFromIntersectionWithCellID to be more efficient. - - var cu CellUnion - for _, xid := range x { - cu.cellUnionDifferenceInternal(xid, &y) - } - - // The output is generated in sorted order, and there should not be any - // cells that can be merged (provided that both inputs were normalized). - return cu -} - -// The C++ constructor methods FromNormalized and FromVerbatim are not necessary -// since they don't call Normalize, and just set the CellIDs directly on the object, -// so straight casting is sufficient in Go to replicate this behavior. - -// IsValid reports whether the cell union is valid, meaning that the CellIDs are -// valid, non-overlapping, and sorted in increasing order. -func (cu *CellUnion) IsValid() bool { - for i, cid := range *cu { - if !cid.IsValid() { - return false - } - if i == 0 { - continue - } - if (*cu)[i-1].RangeMax() >= cid.RangeMin() { - return false - } - } - return true -} - -// IsNormalized reports whether the cell union is normalized, meaning that it is -// satisfies IsValid and that no four cells have a common parent. -// Certain operations such as Contains will return a different -// result if the cell union is not normalized. -func (cu *CellUnion) IsNormalized() bool { - for i, cid := range *cu { - if !cid.IsValid() { - return false - } - if i == 0 { - continue - } - if (*cu)[i-1].RangeMax() >= cid.RangeMin() { - return false - } - if i < 3 { - continue - } - if areSiblings((*cu)[i-3], (*cu)[i-2], (*cu)[i-1], cid) { - return false - } - } - return true -} - -// Normalize normalizes the CellUnion. -func (cu *CellUnion) Normalize() { - sortCellIDs(*cu) - - output := make([]CellID, 0, len(*cu)) // the list of accepted cells - // Loop invariant: output is a sorted list of cells with no redundancy. - for _, ci := range *cu { - // The first two passes here either ignore this new candidate, - // or remove previously accepted cells that are covered by this candidate. - - // Ignore this cell if it is contained by the previous one. - // We only need to check the last accepted cell. The ordering of the - // cells implies containment (but not the converse), and output has no redundancy, - // so if this candidate is not contained by the last accepted cell - // then it cannot be contained by any previously accepted cell. - if len(output) > 0 && output[len(output)-1].Contains(ci) { - continue - } - - // Discard any previously accepted cells contained by this one. - // This could be any contiguous trailing subsequence, but it can't be - // a discontiguous subsequence because of the containment property of - // sorted S2 cells mentioned above. - j := len(output) - 1 // last index to keep - for j >= 0 { - if !ci.Contains(output[j]) { - break - } - j-- - } - output = output[:j+1] - - // See if the last three cells plus this one can be collapsed. - // We loop because collapsing three accepted cells and adding a higher level cell - // could cascade into previously accepted cells. - for len(output) >= 3 && areSiblings(output[len(output)-3], output[len(output)-2], output[len(output)-1], ci) { - // Replace four children by their parent cell. - output = output[:len(output)-3] - ci = ci.immediateParent() // checked !ci.isFace above - } - output = append(output, ci) - } - *cu = output -} - -// IntersectsCellID reports whether this CellUnion intersects the given cell ID. -func (cu *CellUnion) IntersectsCellID(id CellID) bool { - // Find index of array item that occurs directly after our probe cell: - i := sort.Search(len(*cu), func(i int) bool { return id < (*cu)[i] }) - - if i != len(*cu) && (*cu)[i].RangeMin() <= id.RangeMax() { - return true - } - return i != 0 && (*cu)[i-1].RangeMax() >= id.RangeMin() -} - -// ContainsCellID reports whether the CellUnion contains the given cell ID. -// Containment is defined with respect to regions, e.g. a cell contains its 4 children. -// -// CAVEAT: If you have constructed a non-normalized CellUnion, note that groups -// of 4 child cells are *not* considered to contain their parent cell. To get -// this behavior you must use one of the call Normalize() explicitly. -func (cu *CellUnion) ContainsCellID(id CellID) bool { - // Find index of array item that occurs directly after our probe cell: - i := sort.Search(len(*cu), func(i int) bool { return id < (*cu)[i] }) - - if i != len(*cu) && (*cu)[i].RangeMin() <= id { - return true - } - return i != 0 && (*cu)[i-1].RangeMax() >= id -} - -// Denormalize replaces this CellUnion with an expanded version of the -// CellUnion where any cell whose level is less than minLevel or where -// (level - minLevel) is not a multiple of levelMod is replaced by its -// children, until either both of these conditions are satisfied or the -// maximum level is reached. -func (cu *CellUnion) Denormalize(minLevel, levelMod int) { - var denorm CellUnion - for _, id := range *cu { - level := id.Level() - newLevel := level - if newLevel < minLevel { - newLevel = minLevel - } - if levelMod > 1 { - newLevel += (maxLevel - (newLevel - minLevel)) % levelMod - if newLevel > maxLevel { - newLevel = maxLevel - } - } - if newLevel == level { - denorm = append(denorm, id) - } else { - end := id.ChildEndAtLevel(newLevel) - for ci := id.ChildBeginAtLevel(newLevel); ci != end; ci = ci.Next() { - denorm = append(denorm, ci) - } - } - } - *cu = denorm -} - -// RectBound returns a Rect that bounds this entity. -func (cu *CellUnion) RectBound() Rect { - bound := EmptyRect() - for _, c := range *cu { - bound = bound.Union(CellFromCellID(c).RectBound()) - } - return bound -} - -// CapBound returns a Cap that bounds this entity. -func (cu *CellUnion) CapBound() Cap { - if len(*cu) == 0 { - return EmptyCap() - } - - // Compute the approximate centroid of the region. This won't produce the - // bounding cap of minimal area, but it should be close enough. - var centroid Point - - for _, ci := range *cu { - area := AvgAreaMetric.Value(ci.Level()) - centroid = Point{centroid.Add(ci.Point().Mul(area))} - } - - if zero := (Point{}); centroid == zero { - centroid = PointFromCoords(1, 0, 0) - } else { - centroid = Point{centroid.Normalize()} - } - - // Use the centroid as the cap axis, and expand the cap angle so that it - // contains the bounding caps of all the individual cells. Note that it is - // *not* sufficient to just bound all the cell vertices because the bounding - // cap may be concave (i.e. cover more than one hemisphere). - c := CapFromPoint(centroid) - for _, ci := range *cu { - c = c.AddCap(CellFromCellID(ci).CapBound()) - } - - return c -} - -// ContainsCell reports whether this cell union contains the given cell. -func (cu *CellUnion) ContainsCell(c Cell) bool { - return cu.ContainsCellID(c.id) -} - -// IntersectsCell reports whether this cell union intersects the given cell. -func (cu *CellUnion) IntersectsCell(c Cell) bool { - return cu.IntersectsCellID(c.id) -} - -// ContainsPoint reports whether this cell union contains the given point. -func (cu *CellUnion) ContainsPoint(p Point) bool { - return cu.ContainsCell(CellFromPoint(p)) -} - -// CellUnionBound computes a covering of the CellUnion. -func (cu *CellUnion) CellUnionBound() []CellID { - return cu.CapBound().CellUnionBound() -} - -// LeafCellsCovered reports the number of leaf cells covered by this cell union. -// This will be no more than 6*2^60 for the whole sphere. -func (cu *CellUnion) LeafCellsCovered() int64 { - var numLeaves int64 - for _, c := range *cu { - numLeaves += 1 << uint64((maxLevel-int64(c.Level()))<<1) - } - return numLeaves -} - -// Returns true if the given four cells have a common parent. -// This requires that the four CellIDs are distinct. -func areSiblings(a, b, c, d CellID) bool { - // A necessary (but not sufficient) condition is that the XOR of the - // four cell IDs must be zero. This is also very fast to test. - if (a ^ b ^ c) != d { - return false - } - - // Now we do a slightly more expensive but exact test. First, compute a - // mask that blocks out the two bits that encode the child position of - // "id" with respect to its parent, then check that the other three - // children all agree with "mask". - mask := d.lsb() << 1 - mask = ^(mask + (mask << 1)) - idMasked := (uint64(d) & mask) - return ((uint64(a)&mask) == idMasked && - (uint64(b)&mask) == idMasked && - (uint64(c)&mask) == idMasked && - !d.isFace()) -} - -// Contains reports whether this CellUnion contains all of the CellIDs of the given CellUnion. -func (cu *CellUnion) Contains(o CellUnion) bool { - // TODO(roberts): Investigate alternatives such as divide-and-conquer - // or alternating-skip-search that may be significantly faster in both - // the average and worst case. This applies to Intersects as well. - for _, id := range o { - if !cu.ContainsCellID(id) { - return false - } - } - - return true -} - -// Intersects reports whether this CellUnion intersects any of the CellIDs of the given CellUnion. -func (cu *CellUnion) Intersects(o CellUnion) bool { - for _, c := range *cu { - if o.IntersectsCellID(c) { - return true - } - } - - return false -} - -// lowerBound returns the index in this CellUnion to the first element whose value -// is not considered to go before the given cell id. (i.e., either it is equivalent -// or comes after the given id.) If there is no match, then end is returned. -func (cu *CellUnion) lowerBound(begin, end int, id CellID) int { - for i := begin; i < end; i++ { - if (*cu)[i] >= id { - return i - } - } - - return end -} - -// cellUnionDifferenceInternal adds the difference between the CellID and the union to -// the result CellUnion. If they intersect but the difference is non-empty, it divides -// and conquers. -func (cu *CellUnion) cellUnionDifferenceInternal(id CellID, other *CellUnion) { - if !other.IntersectsCellID(id) { - (*cu) = append((*cu), id) - return - } - - if !other.ContainsCellID(id) { - for _, child := range id.Children() { - cu.cellUnionDifferenceInternal(child, other) - } - } -} - -// ExpandAtLevel expands this CellUnion by adding a rim of cells at expandLevel -// around the unions boundary. -// -// For each cell c in the union, we add all cells at level -// expandLevel that abut c. There are typically eight of those -// (four edge-abutting and four sharing a vertex). However, if c is -// finer than expandLevel, we add all cells abutting -// c.Parent(expandLevel) as well as c.Parent(expandLevel) itself, -// as an expandLevel cell rarely abuts a smaller cell. -// -// Note that the size of the output is exponential in -// expandLevel. For example, if expandLevel == 20 and the input -// has a cell at level 10, there will be on the order of 4000 -// adjacent cells in the output. For most applications the -// ExpandByRadius method below is easier to use. -func (cu *CellUnion) ExpandAtLevel(level int) { - var output CellUnion - levelLsb := lsbForLevel(level) - for i := len(*cu) - 1; i >= 0; i-- { - id := (*cu)[i] - if id.lsb() < levelLsb { - id = id.Parent(level) - // Optimization: skip over any cells contained by this one. This is - // especially important when very small regions are being expanded. - for i > 0 && id.Contains((*cu)[i-1]) { - i-- - } - } - output = append(output, id) - output = append(output, id.AllNeighbors(level)...) - } - sortCellIDs(output) - - *cu = output - cu.Normalize() -} - -// ExpandByRadius expands this CellUnion such that it contains all points whose -// distance to the CellUnion is at most minRadius, but do not use cells that -// are more than maxLevelDiff levels higher than the largest cell in the input. -// The second parameter controls the tradeoff between accuracy and output size -// when a large region is being expanded by a small amount (e.g. expanding Canada -// by 1km). For example, if maxLevelDiff == 4 the region will always be expanded -// by approximately 1/16 the width of its largest cell. Note that in the worst case, -// the number of cells in the output can be up to 4 * (1 + 2 ** maxLevelDiff) times -// larger than the number of cells in the input. -func (cu *CellUnion) ExpandByRadius(minRadius s1.Angle, maxLevelDiff int) { - minLevel := maxLevel - for _, cid := range *cu { - minLevel = minInt(minLevel, cid.Level()) - } - - // Find the maximum level such that all cells are at least "minRadius" wide. - radiusLevel := MinWidthMetric.MaxLevel(minRadius.Radians()) - if radiusLevel == 0 && minRadius.Radians() > MinWidthMetric.Value(0) { - // The requested expansion is greater than the width of a face cell. - // The easiest way to handle this is to expand twice. - cu.ExpandAtLevel(0) - } - cu.ExpandAtLevel(minInt(minLevel+maxLevelDiff, radiusLevel)) -} - -// Equal reports whether the two CellUnions are equal. -func (cu CellUnion) Equal(o CellUnion) bool { - if len(cu) != len(o) { - return false - } - for i := 0; i < len(cu); i++ { - if cu[i] != o[i] { - return false - } - } - return true -} - -// AverageArea returns the average area of this CellUnion. -// This is accurate to within a factor of 1.7. -func (cu *CellUnion) AverageArea() float64 { - return AvgAreaMetric.Value(maxLevel) * float64(cu.LeafCellsCovered()) -} - -// ApproxArea returns the approximate area of this CellUnion. This method is accurate -// to within 3% percent for all cell sizes and accurate to within 0.1% for cells -// at level 5 or higher within the union. -func (cu *CellUnion) ApproxArea() float64 { - var area float64 - for _, id := range *cu { - area += CellFromCellID(id).ApproxArea() - } - return area -} - -// ExactArea returns the area of this CellUnion as accurately as possible. -func (cu *CellUnion) ExactArea() float64 { - var area float64 - for _, id := range *cu { - area += CellFromCellID(id).ExactArea() - } - return area -} - -// Encode encodes the CellUnion. -func (cu *CellUnion) Encode(w io.Writer) error { - e := &encoder{w: w} - cu.encode(e) - return e.err -} - -func (cu *CellUnion) encode(e *encoder) { - e.writeInt8(encodingVersion) - e.writeInt64(int64(len(*cu))) - for _, ci := range *cu { - ci.encode(e) - } -} - -// Decode decodes the CellUnion. -func (cu *CellUnion) Decode(r io.Reader) error { - d := &decoder{r: asByteReader(r)} - cu.decode(d) - return d.err -} - -func (cu *CellUnion) decode(d *decoder) { - version := d.readInt8() - if d.err != nil { - return - } - if version != encodingVersion { - d.err = fmt.Errorf("only version %d is supported", encodingVersion) - return - } - n := d.readInt64() - if d.err != nil { - return - } - const maxCells = 1000000 - if n > maxCells { - d.err = fmt.Errorf("too many cells (%d; max is %d)", n, maxCells) - return - } - *cu = make([]CellID, n) - for i := range *cu { - (*cu)[i].decode(d) - } -} diff --git a/vendor/github.com/golang/geo/s2/centroids.go b/vendor/github.com/golang/geo/s2/centroids.go deleted file mode 100644 index e8a91c442..000000000 --- a/vendor/github.com/golang/geo/s2/centroids.go +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/r3" -) - -// There are several notions of the "centroid" of a triangle. First, there -// is the planar centroid, which is simply the centroid of the ordinary -// (non-spherical) triangle defined by the three vertices. Second, there is -// the surface centroid, which is defined as the intersection of the three -// medians of the spherical triangle. It is possible to show that this -// point is simply the planar centroid projected to the surface of the -// sphere. Finally, there is the true centroid (mass centroid), which is -// defined as the surface integral over the spherical triangle of (x,y,z) -// divided by the triangle area. This is the point that the triangle would -// rotate around if it was spinning in empty space. -// -// The best centroid for most purposes is the true centroid. Unlike the -// planar and surface centroids, the true centroid behaves linearly as -// regions are added or subtracted. That is, if you split a triangle into -// pieces and compute the average of their centroids (weighted by triangle -// area), the result equals the centroid of the original triangle. This is -// not true of the other centroids. -// -// Also note that the surface centroid may be nowhere near the intuitive -// "center" of a spherical triangle. For example, consider the triangle -// with vertices A=(1,eps,0), B=(0,0,1), C=(-1,eps,0) (a quarter-sphere). -// The surface centroid of this triangle is at S=(0, 2*eps, 1), which is -// within a distance of 2*eps of the vertex B. Note that the median from A -// (the segment connecting A to the midpoint of BC) passes through S, since -// this is the shortest path connecting the two endpoints. On the other -// hand, the true centroid is at M=(0, 0.5, 0.5), which when projected onto -// the surface is a much more reasonable interpretation of the "center" of -// this triangle. -// - -// TrueCentroid returns the true centroid of the spherical triangle ABC -// multiplied by the signed area of spherical triangle ABC. The reasons for -// multiplying by the signed area are (1) this is the quantity that needs to be -// summed to compute the centroid of a union or difference of triangles, and -// (2) it's actually easier to calculate this way. All points must have unit length. -// -// Note that the result of this function is defined to be Point(0, 0, 0) if -// the triangle is degenerate. -func TrueCentroid(a, b, c Point) Point { - // Use Distance to get accurate results for small triangles. - ra := float64(1) - if sa := float64(b.Distance(c)); sa != 0 { - ra = sa / math.Sin(sa) - } - rb := float64(1) - if sb := float64(c.Distance(a)); sb != 0 { - rb = sb / math.Sin(sb) - } - rc := float64(1) - if sc := float64(a.Distance(b)); sc != 0 { - rc = sc / math.Sin(sc) - } - - // Now compute a point M such that: - // - // [Ax Ay Az] [Mx] [ra] - // [Bx By Bz] [My] = 0.5 * det(A,B,C) * [rb] - // [Cx Cy Cz] [Mz] [rc] - // - // To improve the numerical stability we subtract the first row (A) from the - // other two rows; this reduces the cancellation error when A, B, and C are - // very close together. Then we solve it using Cramer's rule. - // - // The result is the true centroid of the triangle multiplied by the - // triangle's area. - // - // This code still isn't as numerically stable as it could be. - // The biggest potential improvement is to compute B-A and C-A more - // accurately so that (B-A)x(C-A) is always inside triangle ABC. - x := r3.Vector{a.X, b.X - a.X, c.X - a.X} - y := r3.Vector{a.Y, b.Y - a.Y, c.Y - a.Y} - z := r3.Vector{a.Z, b.Z - a.Z, c.Z - a.Z} - r := r3.Vector{ra, rb - ra, rc - ra} - - return Point{r3.Vector{y.Cross(z).Dot(r), z.Cross(x).Dot(r), x.Cross(y).Dot(r)}.Mul(0.5)} -} - -// EdgeTrueCentroid returns the true centroid of the spherical geodesic edge AB -// multiplied by the length of the edge AB. As with triangles, the true centroid -// of a collection of line segments may be computed simply by summing the result -// of this method for each segment. -// -// Note that the planar centroid of a line segment is simply 0.5 * (a + b), -// while the surface centroid is (a + b).Normalize(). However neither of -// these values is appropriate for computing the centroid of a collection of -// edges (such as a polyline). -// -// Also note that the result of this function is defined to be Point(0, 0, 0) -// if the edge is degenerate. -func EdgeTrueCentroid(a, b Point) Point { - // The centroid (multiplied by length) is a vector toward the midpoint - // of the edge, whose length is twice the sine of half the angle between - // the two vertices. Defining theta to be this angle, we have: - vDiff := a.Sub(b.Vector) // Length == 2*sin(theta) - vSum := a.Add(b.Vector) // Length == 2*cos(theta) - sin2 := vDiff.Norm2() - cos2 := vSum.Norm2() - if cos2 == 0 { - return Point{} // Ignore antipodal edges. - } - return Point{vSum.Mul(math.Sqrt(sin2 / cos2))} // Length == 2*sin(theta) -} - -// PlanarCentroid returns the centroid of the planar triangle ABC. This can be -// normalized to unit length to obtain the "surface centroid" of the corresponding -// spherical triangle, i.e. the intersection of the three medians. However, note -// that for large spherical triangles the surface centroid may be nowhere near -// the intuitive "center". -func PlanarCentroid(a, b, c Point) Point { - return Point{a.Add(b.Vector).Add(c.Vector).Mul(1. / 3)} -} diff --git a/vendor/github.com/golang/geo/s2/contains_point_query.go b/vendor/github.com/golang/geo/s2/contains_point_query.go deleted file mode 100644 index 3026f3601..000000000 --- a/vendor/github.com/golang/geo/s2/contains_point_query.go +++ /dev/null @@ -1,190 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// VertexModel defines whether shapes are considered to contain their vertices. -// Note that these definitions differ from the ones used by BooleanOperation. -// -// Note that points other than vertices are never contained by polylines. -// If you want need this behavior, use ClosestEdgeQuery's IsDistanceLess -// with a suitable distance threshold instead. -type VertexModel int - -const ( - // VertexModelOpen means no shapes contain their vertices (not even - // points). Therefore Contains(Point) returns true if and only if the - // point is in the interior of some polygon. - VertexModelOpen VertexModel = iota - - // VertexModelSemiOpen means that polygon point containment is defined - // such that if several polygons tile the region around a vertex, then - // exactly one of those polygons contains that vertex. Points and - // polylines still do not contain any vertices. - VertexModelSemiOpen - - // VertexModelClosed means all shapes contain their vertices (including - // points and polylines). - VertexModelClosed -) - -// ContainsPointQuery determines whether one or more shapes in a ShapeIndex -// contain a given Point. The ShapeIndex may contain any number of points, -// polylines, and/or polygons (possibly overlapping). Shape boundaries may be -// modeled as Open, SemiOpen, or Closed (this affects whether or not shapes are -// considered to contain their vertices). -// -// This type is not safe for concurrent use. -// -// However, note that if you need to do a large number of point containment -// tests, it is more efficient to re-use the query rather than creating a new -// one each time. -type ContainsPointQuery struct { - model VertexModel - index *ShapeIndex - iter *ShapeIndexIterator -} - -// NewContainsPointQuery creates a new instance of the ContainsPointQuery for the index -// and given vertex model choice. -func NewContainsPointQuery(index *ShapeIndex, model VertexModel) *ContainsPointQuery { - return &ContainsPointQuery{ - index: index, - model: model, - iter: index.Iterator(), - } -} - -// Contains reports whether any shape in the queries index contains the point p -// under the queries vertex model (Open, SemiOpen, or Closed). -func (q *ContainsPointQuery) Contains(p Point) bool { - if !q.iter.LocatePoint(p) { - return false - } - - cell := q.iter.IndexCell() - for _, clipped := range cell.shapes { - if q.shapeContains(clipped, q.iter.Center(), p) { - return true - } - } - return false -} - -// shapeContains reports whether the clippedShape from the iterator's center position contains -// the given point. -func (q *ContainsPointQuery) shapeContains(clipped *clippedShape, center, p Point) bool { - inside := clipped.containsCenter - numEdges := clipped.numEdges() - if numEdges <= 0 { - return inside - } - - shape := q.index.Shape(clipped.shapeID) - if shape.Dimension() != 2 { - // Points and polylines can be ignored unless the vertex model is Closed. - if q.model != VertexModelClosed { - return false - } - - // Otherwise, the point is contained if and only if it matches a vertex. - for _, edgeID := range clipped.edges { - edge := shape.Edge(edgeID) - if edge.V0 == p || edge.V1 == p { - return true - } - } - return false - } - - // Test containment by drawing a line segment from the cell center to the - // given point and counting edge crossings. - crosser := NewEdgeCrosser(center, p) - for _, edgeID := range clipped.edges { - edge := shape.Edge(edgeID) - sign := crosser.CrossingSign(edge.V0, edge.V1) - if sign == DoNotCross { - continue - } - if sign == MaybeCross { - // For the Open and Closed models, check whether p is a vertex. - if q.model != VertexModelSemiOpen && (edge.V0 == p || edge.V1 == p) { - return (q.model == VertexModelClosed) - } - // C++ plays fast and loose with the int <-> bool conversions here. - if VertexCrossing(crosser.a, crosser.b, edge.V0, edge.V1) { - sign = Cross - } else { - sign = DoNotCross - } - } - inside = inside != (sign == Cross) - } - - return inside -} - -// ShapeContains reports whether the given shape contains the point under this -// queries vertex model (Open, SemiOpen, or Closed). -// -// This requires the shape belongs to this queries index. -func (q *ContainsPointQuery) ShapeContains(shape Shape, p Point) bool { - if !q.iter.LocatePoint(p) { - return false - } - - clipped := q.iter.IndexCell().findByShapeID(q.index.idForShape(shape)) - if clipped == nil { - return false - } - return q.shapeContains(clipped, q.iter.Center(), p) -} - -// shapeVisitorFunc is a type of function that can be called against shaped in an index. -type shapeVisitorFunc func(shape Shape) bool - -// visitContainingShapes visits all shapes in the given index that contain the -// given point p, terminating early if the given visitor function returns false, -// in which case visitContainingShapes returns false. Each shape is -// visited at most once. -func (q *ContainsPointQuery) visitContainingShapes(p Point, f shapeVisitorFunc) bool { - // This function returns false only if the algorithm terminates early - // because the visitor function returned false. - if !q.iter.LocatePoint(p) { - return true - } - - cell := q.iter.IndexCell() - for _, clipped := range cell.shapes { - if q.shapeContains(clipped, q.iter.Center(), p) && - !f(q.index.Shape(clipped.shapeID)) { - return false - } - } - return true -} - -// ContainingShapes returns a slice of all shapes that contain the given point. -func (q *ContainsPointQuery) ContainingShapes(p Point) []Shape { - var shapes []Shape - q.visitContainingShapes(p, func(shape Shape) bool { - shapes = append(shapes, shape) - return true - }) - return shapes -} - -// TODO(roberts): Remaining methods from C++ -// type edgeVisitorFunc func(shape ShapeEdge) bool -// func (q *ContainsPointQuery) visitIncidentEdges(p Point, v edgeVisitorFunc) bool diff --git a/vendor/github.com/golang/geo/s2/contains_vertex_query.go b/vendor/github.com/golang/geo/s2/contains_vertex_query.go deleted file mode 100644 index 8e74f9e5b..000000000 --- a/vendor/github.com/golang/geo/s2/contains_vertex_query.go +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// ContainsVertexQuery is used to track the edges entering and leaving the -// given vertex of a Polygon in order to be able to determine if the point is -// contained by the Polygon. -// -// Point containment is defined according to the semi-open boundary model -// which means that if several polygons tile the region around a vertex, -// then exactly one of those polygons contains that vertex. -type ContainsVertexQuery struct { - target Point - edgeMap map[Point]int -} - -// NewContainsVertexQuery returns a new query for the given vertex whose -// containment will be determined. -func NewContainsVertexQuery(target Point) *ContainsVertexQuery { - return &ContainsVertexQuery{ - target: target, - edgeMap: make(map[Point]int), - } -} - -// AddEdge adds the edge between target and v with the given direction. -// (+1 = outgoing, -1 = incoming, 0 = degenerate). -func (q *ContainsVertexQuery) AddEdge(v Point, direction int) { - q.edgeMap[v] += direction -} - -// ContainsVertex reports a +1 if the target vertex is contained, -1 if it is -// not contained, and 0 if the incident edges consisted of matched sibling pairs. -func (q *ContainsVertexQuery) ContainsVertex() int { - // Find the unmatched edge that is immediately clockwise from Ortho(P). - referenceDir := Point{q.target.Ortho()} - - bestPoint := referenceDir - bestDir := 0 - - for k, v := range q.edgeMap { - if v == 0 { - continue // This is a "matched" edge. - } - if OrderedCCW(referenceDir, bestPoint, k, q.target) { - bestPoint = k - bestDir = v - } - } - return bestDir -} diff --git a/vendor/github.com/golang/geo/s2/convex_hull_query.go b/vendor/github.com/golang/geo/s2/convex_hull_query.go deleted file mode 100644 index 68539abb1..000000000 --- a/vendor/github.com/golang/geo/s2/convex_hull_query.go +++ /dev/null @@ -1,258 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "sort" - - "github.com/golang/geo/r3" -) - -// ConvexHullQuery builds the convex hull of any collection of points, -// polylines, loops, and polygons. It returns a single convex loop. -// -// The convex hull is defined as the smallest convex region on the sphere that -// contains all of your input geometry. Recall that a region is "convex" if -// for every pair of points inside the region, the straight edge between them -// is also inside the region. In our case, a "straight" edge is a geodesic, -// i.e. the shortest path on the sphere between two points. -// -// Containment of input geometry is defined as follows: -// -// - Each input loop and polygon is contained by the convex hull exactly -// (i.e., according to Polygon's Contains(Polygon)). -// -// - Each input point is either contained by the convex hull or is a vertex -// of the convex hull. (Recall that S2Loops do not necessarily contain their -// vertices.) -// -// - For each input polyline, the convex hull contains all of its vertices -// according to the rule for points above. (The definition of convexity -// then ensures that the convex hull also contains the polyline edges.) -// -// To use this type, call the various Add... methods to add your input geometry, and -// then call ConvexHull. Note that ConvexHull does *not* reset the -// state; you can continue adding geometry if desired and compute the convex -// hull again. If you want to start from scratch, simply create a new -// ConvexHullQuery value. -// -// This implement Andrew's monotone chain algorithm, which is a variant of the -// Graham scan (see https://en.wikipedia.org/wiki/Graham_scan). The time -// complexity is O(n log n), and the space required is O(n). In fact only the -// call to "sort" takes O(n log n) time; the rest of the algorithm is linear. -// -// Demonstration of the algorithm and code: -// en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain -// -// This type is not safe for concurrent use. -type ConvexHullQuery struct { - bound Rect - points []Point -} - -// NewConvexHullQuery creates a new ConvexHullQuery. -func NewConvexHullQuery() *ConvexHullQuery { - return &ConvexHullQuery{ - bound: EmptyRect(), - } -} - -// AddPoint adds the given point to the input geometry. -func (q *ConvexHullQuery) AddPoint(p Point) { - q.bound = q.bound.AddPoint(LatLngFromPoint(p)) - q.points = append(q.points, p) -} - -// AddPolyline adds the given polyline to the input geometry. -func (q *ConvexHullQuery) AddPolyline(p *Polyline) { - q.bound = q.bound.Union(p.RectBound()) - q.points = append(q.points, (*p)...) -} - -// AddLoop adds the given loop to the input geometry. -func (q *ConvexHullQuery) AddLoop(l *Loop) { - q.bound = q.bound.Union(l.RectBound()) - if l.isEmptyOrFull() { - return - } - q.points = append(q.points, l.vertices...) -} - -// AddPolygon adds the given polygon to the input geometry. -func (q *ConvexHullQuery) AddPolygon(p *Polygon) { - q.bound = q.bound.Union(p.RectBound()) - for _, l := range p.loops { - // Only loops at depth 0 can contribute to the convex hull. - if l.depth == 0 { - q.AddLoop(l) - } - } -} - -// CapBound returns a bounding cap for the input geometry provided. -// -// Note that this method does not clear the geometry; you can continue -// adding to it and call this method again if desired. -func (q *ConvexHullQuery) CapBound() Cap { - // We keep track of a rectangular bound rather than a spherical cap because - // it is easy to compute a tight bound for a union of rectangles, whereas it - // is quite difficult to compute a tight bound around a union of caps. - // Also, polygons and polylines implement CapBound() in terms of - // RectBound() for this same reason, so it is much better to keep track - // of a rectangular bound as we go along and convert it at the end. - // - // TODO(roberts): We could compute an optimal bound by implementing Welzl's - // algorithm. However we would still need to have special handling of loops - // and polygons, since if a loop spans more than 180 degrees in any - // direction (i.e., if it contains two antipodal points), then it is not - // enough just to bound its vertices. In this case the only convex bounding - // cap is FullCap(), and the only convex bounding loop is the full loop. - return q.bound.CapBound() -} - -// ConvexHull returns a Loop representing the convex hull of the input geometry provided. -// -// If there is no geometry, this method returns an empty loop containing no -// points. -// -// If the geometry spans more than half of the sphere, this method returns a -// full loop containing the entire sphere. -// -// If the geometry contains 1 or 2 points, or a single edge, this method -// returns a very small loop consisting of three vertices (which are a -// superset of the input vertices). -// -// Note that this method does not clear the geometry; you can continue -// adding to the query and call this method again. -func (q *ConvexHullQuery) ConvexHull() *Loop { - c := q.CapBound() - if c.Height() >= 1 { - // The bounding cap is not convex. The current bounding cap - // implementation is not optimal, but nevertheless it is likely that the - // input geometry itself is not contained by any convex polygon. In any - // case, we need a convex bounding cap to proceed with the algorithm below - // (in order to construct a point "origin" that is definitely outside the - // convex hull). - return FullLoop() - } - - // Remove duplicates. We need to do this before checking whether there are - // fewer than 3 points. - x := make(map[Point]bool) - r, w := 0, 0 // read/write indexes - for ; r < len(q.points); r++ { - if x[q.points[r]] { - continue - } - q.points[w] = q.points[r] - x[q.points[r]] = true - w++ - } - q.points = q.points[:w] - - // This code implements Andrew's monotone chain algorithm, which is a simple - // variant of the Graham scan. Rather than sorting by x-coordinate, instead - // we sort the points in CCW order around an origin O such that all points - // are guaranteed to be on one side of some geodesic through O. This - // ensures that as we scan through the points, each new point can only - // belong at the end of the chain (i.e., the chain is monotone in terms of - // the angle around O from the starting point). - origin := Point{c.Center().Ortho()} - sort.Slice(q.points, func(i, j int) bool { - return RobustSign(origin, q.points[i], q.points[j]) == CounterClockwise - }) - - // Special cases for fewer than 3 points. - switch len(q.points) { - case 0: - return EmptyLoop() - case 1: - return singlePointLoop(q.points[0]) - case 2: - return singleEdgeLoop(q.points[0], q.points[1]) - } - - // Generate the lower and upper halves of the convex hull. Each half - // consists of the maximal subset of vertices such that the edge chain - // makes only left (CCW) turns. - lower := q.monotoneChain() - - // reverse the points - for left, right := 0, len(q.points)-1; left < right; left, right = left+1, right-1 { - q.points[left], q.points[right] = q.points[right], q.points[left] - } - upper := q.monotoneChain() - - // Remove the duplicate vertices and combine the chains. - lower = lower[:len(lower)-1] - upper = upper[:len(upper)-1] - lower = append(lower, upper...) - - return LoopFromPoints(lower) -} - -// monotoneChain iterates through the points, selecting the maximal subset of points -// such that the edge chain makes only left (CCW) turns. -func (q *ConvexHullQuery) monotoneChain() []Point { - var output []Point - for _, p := range q.points { - // Remove any points that would cause the chain to make a clockwise turn. - for len(output) >= 2 && RobustSign(output[len(output)-2], output[len(output)-1], p) != CounterClockwise { - output = output[:len(output)-1] - } - output = append(output, p) - } - return output -} - -// singlePointLoop constructs a 3-vertex polygon consisting of "p" and two nearby -// vertices. Note that ContainsPoint(p) may be false for the resulting loop. -func singlePointLoop(p Point) *Loop { - const offset = 1e-15 - d0 := p.Ortho() - d1 := p.Cross(d0) - vertices := []Point{ - p, - {p.Add(d0.Mul(offset)).Normalize()}, - {p.Add(d1.Mul(offset)).Normalize()}, - } - return LoopFromPoints(vertices) -} - -// singleEdgeLoop constructs a loop consisting of the two vertices and their midpoint. -func singleEdgeLoop(a, b Point) *Loop { - // If the points are exactly antipodal we return the full loop. - // - // Note that we could use the code below even in this case (which would - // return a zero-area loop that follows the edge AB), except that (1) the - // direction of AB is defined using symbolic perturbations and therefore is - // not predictable by ordinary users, and (2) Loop disallows anitpodal - // adjacent vertices and so we would need to use 4 vertices to define the - // degenerate loop. (Note that the Loop antipodal vertex restriction is - // historical and now could easily be removed, however it would still have - // the problem that the edge direction is not easily predictable.) - if a.Add(b.Vector) == (r3.Vector{}) { - return FullLoop() - } - - // Construct a loop consisting of the two vertices and their midpoint. We - // use Interpolate() to ensure that the midpoint is very close to - // the edge even when its endpoints nearly antipodal. - vertices := []Point{a, b, Interpolate(0.5, a, b)} - loop := LoopFromPoints(vertices) - // The resulting loop may be clockwise, so invert it if necessary. - loop.Normalize() - return loop -} diff --git a/vendor/github.com/golang/geo/s2/crossing_edge_query.go b/vendor/github.com/golang/geo/s2/crossing_edge_query.go deleted file mode 100644 index 51852dab4..000000000 --- a/vendor/github.com/golang/geo/s2/crossing_edge_query.go +++ /dev/null @@ -1,409 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "sort" - - "github.com/golang/geo/r2" -) - -// CrossingEdgeQuery is used to find the Edge IDs of Shapes that are crossed by -// a given edge(s). -// -// Note that if you need to query many edges, it is more efficient to declare -// a single CrossingEdgeQuery instance and reuse it. -// -// If you want to find *all* the pairs of crossing edges, it is more efficient to -// use the not yet implemented VisitCrossings in shapeutil. -type CrossingEdgeQuery struct { - index *ShapeIndex - - // temporary values used while processing a query. - a, b r2.Point - iter *ShapeIndexIterator - - // candidate cells generated when finding crossings. - cells []*ShapeIndexCell -} - -// NewCrossingEdgeQuery creates a CrossingEdgeQuery for the given index. -func NewCrossingEdgeQuery(index *ShapeIndex) *CrossingEdgeQuery { - c := &CrossingEdgeQuery{ - index: index, - iter: index.Iterator(), - } - return c -} - -// Crossings returns the set of edge of the shape S that intersect the given edge AB. -// If the CrossingType is Interior, then only intersections at a point interior to both -// edges are reported, while if it is CrossingTypeAll then edges that share a vertex -// are also reported. -func (c *CrossingEdgeQuery) Crossings(a, b Point, shape Shape, crossType CrossingType) []int { - edges := c.candidates(a, b, shape) - if len(edges) == 0 { - return nil - } - - crosser := NewEdgeCrosser(a, b) - out := 0 - n := len(edges) - - for in := 0; in < n; in++ { - b := shape.Edge(edges[in]) - sign := crosser.CrossingSign(b.V0, b.V1) - if crossType == CrossingTypeAll && (sign == MaybeCross || sign == Cross) || crossType != CrossingTypeAll && sign == Cross { - edges[out] = edges[in] - out++ - } - } - - if out < n { - edges = edges[0:out] - } - return edges -} - -// EdgeMap stores a sorted set of edge ids for each shape. -type EdgeMap map[Shape][]int - -// CrossingsEdgeMap returns the set of all edges in the index that intersect the given -// edge AB. If crossType is CrossingTypeInterior, then only intersections at a -// point interior to both edges are reported, while if it is CrossingTypeAll -// then edges that share a vertex are also reported. -// -// The edges are returned as a mapping from shape to the edges of that shape -// that intersect AB. Every returned shape has at least one crossing edge. -func (c *CrossingEdgeQuery) CrossingsEdgeMap(a, b Point, crossType CrossingType) EdgeMap { - edgeMap := c.candidatesEdgeMap(a, b) - if len(edgeMap) == 0 { - return nil - } - - crosser := NewEdgeCrosser(a, b) - for shape, edges := range edgeMap { - out := 0 - n := len(edges) - for in := 0; in < n; in++ { - edge := shape.Edge(edges[in]) - sign := crosser.CrossingSign(edge.V0, edge.V1) - if (crossType == CrossingTypeAll && (sign == MaybeCross || sign == Cross)) || (crossType != CrossingTypeAll && sign == Cross) { - edgeMap[shape][out] = edges[in] - out++ - } - } - - if out == 0 { - delete(edgeMap, shape) - } else { - if out < n { - edgeMap[shape] = edgeMap[shape][0:out] - } - } - } - return edgeMap -} - -// candidates returns a superset of the edges of the given shape that intersect -// the edge AB. -func (c *CrossingEdgeQuery) candidates(a, b Point, shape Shape) []int { - var edges []int - - // For small loops it is faster to use brute force. The threshold below was - // determined using benchmarks. - const maxBruteForceEdges = 27 - maxEdges := shape.NumEdges() - if maxEdges <= maxBruteForceEdges { - edges = make([]int, maxEdges) - for i := 0; i < maxEdges; i++ { - edges[i] = i - } - return edges - } - - // Compute the set of index cells intersected by the query edge. - c.getCellsForEdge(a, b) - if len(c.cells) == 0 { - return nil - } - - // Gather all the edges that intersect those cells and sort them. - // TODO(roberts): Shapes don't track their ID, so we need to range over - // the index to find the ID manually. - var shapeID int32 - for k, v := range c.index.shapes { - if v == shape { - shapeID = k - } - } - - for _, cell := range c.cells { - if cell == nil { - continue - } - clipped := cell.findByShapeID(shapeID) - if clipped == nil { - continue - } - edges = append(edges, clipped.edges...) - } - - if len(c.cells) > 1 { - edges = uniqueInts(edges) - } - - return edges -} - -// uniqueInts returns the sorted uniqued values from the given input. -func uniqueInts(in []int) []int { - var edges []int - m := make(map[int]bool) - for _, i := range in { - if m[i] { - continue - } - m[i] = true - edges = append(edges, i) - } - sort.Ints(edges) - return edges -} - -// candidatesEdgeMap returns a map from shapes to the superse of edges for that -// shape that intersect the edge AB. -// -// CAVEAT: This method may return shapes that have an empty set of candidate edges. -// However the return value is non-empty only if at least one shape has a candidate edge. -func (c *CrossingEdgeQuery) candidatesEdgeMap(a, b Point) EdgeMap { - edgeMap := make(EdgeMap) - - // If there are only a few edges then it's faster to use brute force. We - // only bother with this optimization when there is a single shape. - if len(c.index.shapes) == 1 { - // Typically this method is called many times, so it is worth checking - // whether the edge map is empty or already consists of a single entry for - // this shape, and skip clearing edge map in that case. - shape := c.index.Shape(0) - - // Note that we leave the edge map non-empty even if there are no candidates - // (i.e., there is a single entry with an empty set of edges). - edgeMap[shape] = c.candidates(a, b, shape) - return edgeMap - } - - // Compute the set of index cells intersected by the query edge. - c.getCellsForEdge(a, b) - if len(c.cells) == 0 { - return edgeMap - } - - // Gather all the edges that intersect those cells and sort them. - for _, cell := range c.cells { - for _, clipped := range cell.shapes { - s := c.index.Shape(clipped.shapeID) - for j := 0; j < clipped.numEdges(); j++ { - edgeMap[s] = append(edgeMap[s], clipped.edges[j]) - } - } - } - - if len(c.cells) > 1 { - for s, edges := range edgeMap { - edgeMap[s] = uniqueInts(edges) - } - } - - return edgeMap -} - -// getCells returns the set of ShapeIndexCells that might contain edges intersecting -// the edge AB in the given cell root. This method is used primarily by loop and shapeutil. -func (c *CrossingEdgeQuery) getCells(a, b Point, root *PaddedCell) []*ShapeIndexCell { - aUV, bUV, ok := ClipToFace(a, b, root.id.Face()) - if ok { - c.a = aUV - c.b = bUV - edgeBound := r2.RectFromPoints(c.a, c.b) - if root.Bound().Intersects(edgeBound) { - c.computeCellsIntersected(root, edgeBound) - } - } - - if len(c.cells) == 0 { - return nil - } - - return c.cells -} - -// getCellsForEdge populates the cells field to the set of index cells intersected by an edge AB. -func (c *CrossingEdgeQuery) getCellsForEdge(a, b Point) { - c.cells = nil - - segments := FaceSegments(a, b) - for _, segment := range segments { - c.a = segment.a - c.b = segment.b - - // Optimization: rather than always starting the recursive subdivision at - // the top level face cell, instead we start at the smallest S2CellId that - // contains the edge (the edge root cell). This typically lets us skip - // quite a few levels of recursion since most edges are short. - edgeBound := r2.RectFromPoints(c.a, c.b) - pcell := PaddedCellFromCellID(CellIDFromFace(segment.face), 0) - edgeRoot := pcell.ShrinkToFit(edgeBound) - - // Now we need to determine how the edge root cell is related to the cells - // in the spatial index (cellMap). There are three cases: - // - // 1. edgeRoot is an index cell or is contained within an index cell. - // In this case we only need to look at the contents of that cell. - // 2. edgeRoot is subdivided into one or more index cells. In this case - // we recursively subdivide to find the cells intersected by AB. - // 3. edgeRoot does not intersect any index cells. In this case there - // is nothing to do. - relation := c.iter.LocateCellID(edgeRoot) - if relation == Indexed { - // edgeRoot is an index cell or is contained by an index cell (case 1). - c.cells = append(c.cells, c.iter.IndexCell()) - } else if relation == Subdivided { - // edgeRoot is subdivided into one or more index cells (case 2). We - // find the cells intersected by AB using recursive subdivision. - if !edgeRoot.isFace() { - pcell = PaddedCellFromCellID(edgeRoot, 0) - } - c.computeCellsIntersected(pcell, edgeBound) - } - } -} - -// computeCellsIntersected computes the index cells intersected by the current -// edge that are descendants of pcell and adds them to this queries set of cells. -func (c *CrossingEdgeQuery) computeCellsIntersected(pcell *PaddedCell, edgeBound r2.Rect) { - - c.iter.seek(pcell.id.RangeMin()) - if c.iter.Done() || c.iter.CellID() > pcell.id.RangeMax() { - // The index does not contain pcell or any of its descendants. - return - } - if c.iter.CellID() == pcell.id { - // The index contains this cell exactly. - c.cells = append(c.cells, c.iter.IndexCell()) - return - } - - // Otherwise, split the edge among the four children of pcell. - center := pcell.Middle().Lo() - - if edgeBound.X.Hi < center.X { - // Edge is entirely contained in the two left children. - c.clipVAxis(edgeBound, center.Y, 0, pcell) - return - } else if edgeBound.X.Lo >= center.X { - // Edge is entirely contained in the two right children. - c.clipVAxis(edgeBound, center.Y, 1, pcell) - return - } - - childBounds := c.splitUBound(edgeBound, center.X) - if edgeBound.Y.Hi < center.Y { - // Edge is entirely contained in the two lower children. - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, 0, 0), childBounds[0]) - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, 1, 0), childBounds[1]) - } else if edgeBound.Y.Lo >= center.Y { - // Edge is entirely contained in the two upper children. - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, 0, 1), childBounds[0]) - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, 1, 1), childBounds[1]) - } else { - // The edge bound spans all four children. The edge itself intersects - // at most three children (since no padding is being used). - c.clipVAxis(childBounds[0], center.Y, 0, pcell) - c.clipVAxis(childBounds[1], center.Y, 1, pcell) - } -} - -// clipVAxis computes the intersected cells recursively for a given padded cell. -// Given either the left (i=0) or right (i=1) side of a padded cell pcell, -// determine whether the current edge intersects the lower child, upper child, -// or both children, and call c.computeCellsIntersected recursively on those children. -// The center is the v-coordinate at the center of pcell. -func (c *CrossingEdgeQuery) clipVAxis(edgeBound r2.Rect, center float64, i int, pcell *PaddedCell) { - if edgeBound.Y.Hi < center { - // Edge is entirely contained in the lower child. - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, i, 0), edgeBound) - } else if edgeBound.Y.Lo >= center { - // Edge is entirely contained in the upper child. - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, i, 1), edgeBound) - } else { - // The edge intersects both children. - childBounds := c.splitVBound(edgeBound, center) - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, i, 0), childBounds[0]) - c.computeCellsIntersected(PaddedCellFromParentIJ(pcell, i, 1), childBounds[1]) - } -} - -// splitUBound returns the bound for two children as a result of spliting the -// current edge at the given value U. -func (c *CrossingEdgeQuery) splitUBound(edgeBound r2.Rect, u float64) [2]r2.Rect { - v := edgeBound.Y.ClampPoint(interpolateFloat64(u, c.a.X, c.b.X, c.a.Y, c.b.Y)) - // diag indicates which diagonal of the bounding box is spanned by AB: - // it is 0 if AB has positive slope, and 1 if AB has negative slope. - var diag int - if (c.a.X > c.b.X) != (c.a.Y > c.b.Y) { - diag = 1 - } - return splitBound(edgeBound, 0, diag, u, v) -} - -// splitVBound returns the bound for two children as a result of spliting the -// current edge into two child edges at the given value V. -func (c *CrossingEdgeQuery) splitVBound(edgeBound r2.Rect, v float64) [2]r2.Rect { - u := edgeBound.X.ClampPoint(interpolateFloat64(v, c.a.Y, c.b.Y, c.a.X, c.b.X)) - var diag int - if (c.a.X > c.b.X) != (c.a.Y > c.b.Y) { - diag = 1 - } - return splitBound(edgeBound, diag, 0, u, v) -} - -// splitBound returns the bounds for the two childrenn as a result of spliting -// the current edge into two child edges at the given point (u,v). uEnd and vEnd -// indicate which bound endpoints of the first child will be updated. -func splitBound(edgeBound r2.Rect, uEnd, vEnd int, u, v float64) [2]r2.Rect { - var childBounds = [2]r2.Rect{ - edgeBound, - edgeBound, - } - - if uEnd == 1 { - childBounds[0].X.Lo = u - childBounds[1].X.Hi = u - } else { - childBounds[0].X.Hi = u - childBounds[1].X.Lo = u - } - - if vEnd == 1 { - childBounds[0].Y.Lo = v - childBounds[1].Y.Hi = v - } else { - childBounds[0].Y.Hi = v - childBounds[1].Y.Lo = v - } - - return childBounds -} diff --git a/vendor/github.com/golang/geo/s2/distance_target.go b/vendor/github.com/golang/geo/s2/distance_target.go deleted file mode 100644 index 066bbacfa..000000000 --- a/vendor/github.com/golang/geo/s2/distance_target.go +++ /dev/null @@ -1,149 +0,0 @@ -// Copyright 2019 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "github.com/golang/geo/s1" -) - -// The distance interface represents a set of common methods used by algorithms -// that compute distances between various S2 types. -type distance interface { - // chordAngle returns this type as a ChordAngle. - chordAngle() s1.ChordAngle - - // fromChordAngle is used to type convert a ChordAngle to this type. - // This is to work around needing to be clever in parts of the code - // where a distanceTarget interface method expects distances, but the - // user only supplies a ChordAngle, and we need to dynamically cast it - // to an appropriate distance interface types. - fromChordAngle(o s1.ChordAngle) distance - - // zero returns a zero distance. - zero() distance - // negative returns a value smaller than any valid value. - negative() distance - // infinity returns a value larger than any valid value. - infinity() distance - - // less is similar to the Less method in Sort. To get minimum values, - // this would be a less than type operation. For maximum, this would - // be a greater than type operation. - less(other distance) bool - - // sub subtracts the other value from this one and returns the new value. - // This is done as a method and not simple mathematical operation to - // allow closest and furthest to implement this in opposite ways. - sub(other distance) distance - - // chordAngleBound reports the upper bound on a ChordAngle corresponding - // to this distance. For example, if distance measures WGS84 ellipsoid - // distance then the corresponding angle needs to be 0.56% larger. - chordAngleBound() s1.ChordAngle - - // updateDistance may update the value this distance represents - // based on the given input. The updated value and a boolean reporting - // if the value was changed are returned. - updateDistance(other distance) (distance, bool) -} - -// distanceTarget is an interface that represents a geometric type to which distances -// are measured. -// -// For example, there are implementations that measure distances to a Point, -// an Edge, a Cell, a CellUnion, and even to an arbitrary collection of geometry -// stored in ShapeIndex. -// -// The distanceTarget types are provided for the benefit of types that measure -// distances and/or find nearby geometry, such as ClosestEdgeQuery, FurthestEdgeQuery, -// ClosestPointQuery, and ClosestCellQuery, etc. -type distanceTarget interface { - // capBound returns a Cap that bounds the set of points whose distance to the - // target is distance.zero(). - capBound() Cap - - // updateDistanceToPoint updates the distance if the distance to - // the point P is within than the given dist. - // The boolean reports if the value was updated. - updateDistanceToPoint(p Point, dist distance) (distance, bool) - - // updateDistanceToEdge updates the distance if the distance to - // the edge E is within than the given dist. - // The boolean reports if the value was updated. - updateDistanceToEdge(e Edge, dist distance) (distance, bool) - - // updateDistanceToCell updates the distance if the distance to the cell C - // (including its interior) is within than the given dist. - // The boolean reports if the value was updated. - updateDistanceToCell(c Cell, dist distance) (distance, bool) - - // setMaxError potentially updates the value of MaxError, and reports if - // the specific type supports altering it. Whenever one of the - // updateDistanceTo... methods above returns true, the returned distance - // is allowed to be up to maxError larger than the true minimum distance. - // In other words, it gives this target object permission to terminate its - // distance calculation as soon as it has determined that (1) the minimum - // distance is less than minDist and (2) the best possible further - // improvement is less than maxError. - // - // If the target takes advantage of maxError to optimize its distance - // calculation, this method must return true. (Most target types will - // default to return false.) - setMaxError(maxErr s1.ChordAngle) bool - - // maxBruteForceIndexSize reports the maximum number of indexed objects for - // which it is faster to compute the distance by brute force (e.g., by testing - // every edge) rather than by using an index. - // - // The following method is provided as a convenience for types that compute - // distances to a collection of indexed geometry, such as ClosestEdgeQuery - // and ClosestPointQuery. - // - // Types that do not support this should return a -1. - maxBruteForceIndexSize() int - - // distance returns an instance of the underlying distance type this - // target uses. This is to work around the use of Templates in the C++. - distance() distance - - // visitContainingShapes finds all polygons in the given index that - // completely contain a connected component of the target geometry. (For - // example, if the target consists of 10 points, this method finds - // polygons that contain any of those 10 points.) For each such polygon, - // the visit function is called with the Shape of the polygon along with - // a point of the target geometry that is contained by that polygon. - // - // Optionally, any polygon that intersects the target geometry may also be - // returned. In other words, this method returns all polygons that - // contain any connected component of the target, along with an arbitrary - // subset of the polygons that intersect the target. - // - // For example, suppose that the index contains two abutting polygons - // A and B. If the target consists of two points "a" contained by A and - // "b" contained by B, then both A and B are returned. But if the target - // consists of the edge "ab", then any subset of {A, B} could be returned - // (because both polygons intersect the target but neither one contains - // the edge "ab"). - // - // If the visit function returns false, this method terminates early and - // returns false as well. Otherwise returns true. - // - // NOTE(roberts): This method exists only for the purpose of implementing - // edgeQuery IncludeInteriors efficiently. - visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool -} - -// shapePointVisitorFunc defines a type of function the visitContainingShapes can call. -type shapePointVisitorFunc func(containingShape Shape, targetPoint Point) bool diff --git a/vendor/github.com/golang/geo/s2/doc.go b/vendor/github.com/golang/geo/s2/doc.go deleted file mode 100644 index 43e7a6344..000000000 --- a/vendor/github.com/golang/geo/s2/doc.go +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/* -Package s2 is a library for working with geometry in S² (spherical geometry). - -Its related packages, parallel to this one, are s1 (operates on S¹), r1 (operates on ℝ¹), -r2 (operates on ℝ²) and r3 (operates on ℝ³). - -This package provides types and functions for the S2 cell hierarchy and coordinate systems. -The S2 cell hierarchy is a hierarchical decomposition of the surface of a unit sphere (S²) -into ``cells''; it is highly efficient, scales from continental size to under 1 cm² -and preserves spatial locality (nearby cells have close IDs). - -More information including an in-depth introduction to S2 can be found on the -S2 website https://s2geometry.io/ -*/ -package s2 diff --git a/vendor/github.com/golang/geo/s2/edge_clipping.go b/vendor/github.com/golang/geo/s2/edge_clipping.go deleted file mode 100644 index 57a53bf0f..000000000 --- a/vendor/github.com/golang/geo/s2/edge_clipping.go +++ /dev/null @@ -1,672 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// This file contains a collection of methods for: -// -// (1) Robustly clipping geodesic edges to the faces of the S2 biunit cube -// (see s2stuv), and -// -// (2) Robustly clipping 2D edges against 2D rectangles. -// -// These functions can be used to efficiently find the set of CellIDs that -// are intersected by a geodesic edge (e.g., see CrossingEdgeQuery). - -import ( - "math" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r2" - "github.com/golang/geo/r3" -) - -const ( - // edgeClipErrorUVCoord is the maximum error in a u- or v-coordinate - // compared to the exact result, assuming that the points A and B are in - // the rectangle [-1,1]x[1,1] or slightly outside it (by 1e-10 or less). - edgeClipErrorUVCoord = 2.25 * dblEpsilon - - // edgeClipErrorUVDist is the maximum distance from a clipped point to - // the corresponding exact result. It is equal to the error in a single - // coordinate because at most one coordinate is subject to error. - edgeClipErrorUVDist = 2.25 * dblEpsilon - - // faceClipErrorRadians is the maximum angle between a returned vertex - // and the nearest point on the exact edge AB. It is equal to the - // maximum directional error in PointCross, plus the error when - // projecting points onto a cube face. - faceClipErrorRadians = 3 * dblEpsilon - - // faceClipErrorDist is the same angle expressed as a maximum distance - // in (u,v)-space. In other words, a returned vertex is at most this far - // from the exact edge AB projected into (u,v)-space. - faceClipErrorUVDist = 9 * dblEpsilon - - // faceClipErrorUVCoord is the maximum angle between a returned vertex - // and the nearest point on the exact edge AB expressed as the maximum error - // in an individual u- or v-coordinate. In other words, for each - // returned vertex there is a point on the exact edge AB whose u- and - // v-coordinates differ from the vertex by at most this amount. - faceClipErrorUVCoord = 9.0 * (1.0 / math.Sqrt2) * dblEpsilon - - // intersectsRectErrorUVDist is the maximum error when computing if a point - // intersects with a given Rect. If some point of AB is inside the - // rectangle by at least this distance, the result is guaranteed to be true; - // if all points of AB are outside the rectangle by at least this distance, - // the result is guaranteed to be false. This bound assumes that rect is - // a subset of the rectangle [-1,1]x[-1,1] or extends slightly outside it - // (e.g., by 1e-10 or less). - intersectsRectErrorUVDist = 3 * math.Sqrt2 * dblEpsilon -) - -// ClipToFace returns the (u,v) coordinates for the portion of the edge AB that -// intersects the given face, or false if the edge AB does not intersect. -// This method guarantees that the clipped vertices lie within the [-1,1]x[-1,1] -// cube face rectangle and are within faceClipErrorUVDist of the line AB, but -// the results may differ from those produced by FaceSegments. -func ClipToFace(a, b Point, face int) (aUV, bUV r2.Point, intersects bool) { - return ClipToPaddedFace(a, b, face, 0.0) -} - -// ClipToPaddedFace returns the (u,v) coordinates for the portion of the edge AB that -// intersects the given face, but rather than clipping to the square [-1,1]x[-1,1] -// in (u,v) space, this method clips to [-R,R]x[-R,R] where R=(1+padding). -// Padding must be non-negative. -func ClipToPaddedFace(a, b Point, f int, padding float64) (aUV, bUV r2.Point, intersects bool) { - // Fast path: both endpoints are on the given face. - if face(a.Vector) == f && face(b.Vector) == f { - au, av := validFaceXYZToUV(f, a.Vector) - bu, bv := validFaceXYZToUV(f, b.Vector) - return r2.Point{au, av}, r2.Point{bu, bv}, true - } - - // Convert everything into the (u,v,w) coordinates of the given face. Note - // that the cross product *must* be computed in the original (x,y,z) - // coordinate system because PointCross (unlike the mathematical cross - // product) can produce different results in different coordinate systems - // when one argument is a linear multiple of the other, due to the use of - // symbolic perturbations. - normUVW := pointUVW(faceXYZtoUVW(f, a.PointCross(b))) - aUVW := pointUVW(faceXYZtoUVW(f, a)) - bUVW := pointUVW(faceXYZtoUVW(f, b)) - - // Padding is handled by scaling the u- and v-components of the normal. - // Letting R=1+padding, this means that when we compute the dot product of - // the normal with a cube face vertex (such as (-1,-1,1)), we will actually - // compute the dot product with the scaled vertex (-R,-R,1). This allows - // methods such as intersectsFace, exitAxis, etc, to handle padding - // with no further modifications. - scaleUV := 1 + padding - scaledN := pointUVW{r3.Vector{X: scaleUV * normUVW.X, Y: scaleUV * normUVW.Y, Z: normUVW.Z}} - if !scaledN.intersectsFace() { - return aUV, bUV, false - } - - // TODO(roberts): This is a workaround for extremely small vectors where some - // loss of precision can occur in Normalize causing underflow. When PointCross - // is updated to work around this, this can be removed. - if math.Max(math.Abs(normUVW.X), math.Max(math.Abs(normUVW.Y), math.Abs(normUVW.Z))) < math.Ldexp(1, -511) { - normUVW = pointUVW{normUVW.Mul(math.Ldexp(1, 563))} - } - - normUVW = pointUVW{normUVW.Normalize()} - - aTan := pointUVW{normUVW.Cross(aUVW.Vector)} - bTan := pointUVW{bUVW.Cross(normUVW.Vector)} - - // As described in clipDestination, if the sum of the scores from clipping the two - // endpoints is 3 or more, then the segment does not intersect this face. - aUV, aScore := clipDestination(bUVW, aUVW, pointUVW{scaledN.Mul(-1)}, bTan, aTan, scaleUV) - bUV, bScore := clipDestination(aUVW, bUVW, scaledN, aTan, bTan, scaleUV) - - return aUV, bUV, aScore+bScore < 3 -} - -// ClipEdge returns the portion of the edge defined by AB that is contained by the -// given rectangle. If there is no intersection, false is returned and aClip and bClip -// are undefined. -func ClipEdge(a, b r2.Point, clip r2.Rect) (aClip, bClip r2.Point, intersects bool) { - // Compute the bounding rectangle of AB, clip it, and then extract the new - // endpoints from the clipped bound. - bound := r2.RectFromPoints(a, b) - if bound, intersects = clipEdgeBound(a, b, clip, bound); !intersects { - return aClip, bClip, false - } - ai := 0 - if a.X > b.X { - ai = 1 - } - aj := 0 - if a.Y > b.Y { - aj = 1 - } - - return bound.VertexIJ(ai, aj), bound.VertexIJ(1-ai, 1-aj), true -} - -// The three functions below (sumEqual, intersectsFace, intersectsOppositeEdges) -// all compare a sum (u + v) to a third value w. They are implemented in such a -// way that they produce an exact result even though all calculations are done -// with ordinary floating-point operations. Here are the principles on which these -// functions are based: -// -// A. If u + v < w in floating-point, then u + v < w in exact arithmetic. -// -// B. If u + v < w in exact arithmetic, then at least one of the following -// expressions is true in floating-point: -// u + v < w -// u < w - v -// v < w - u -// -// Proof: By rearranging terms and substituting ">" for "<", we can assume -// that all values are non-negative. Now clearly "w" is not the smallest -// value, so assume WLOG that "u" is the smallest. We want to show that -// u < w - v in floating-point. If v >= w/2, the calculation of w - v is -// exact since the result is smaller in magnitude than either input value, -// so the result holds. Otherwise we have u <= v < w/2 and w - v >= w/2 -// (even in floating point), so the result also holds. - -// sumEqual reports whether u + v == w exactly. -func sumEqual(u, v, w float64) bool { - return (u+v == w) && (u == w-v) && (v == w-u) -} - -// pointUVW represents a Point in (u,v,w) coordinate space of a cube face. -type pointUVW Point - -// intersectsFace reports whether a given directed line L intersects the cube face F. -// The line L is defined by its normal N in the (u,v,w) coordinates of F. -func (p pointUVW) intersectsFace() bool { - // L intersects the [-1,1]x[-1,1] square in (u,v) if and only if the dot - // products of N with the four corner vertices (-1,-1,1), (1,-1,1), (1,1,1), - // and (-1,1,1) do not all have the same sign. This is true exactly when - // |Nu| + |Nv| >= |Nw|. The code below evaluates this expression exactly. - u := math.Abs(p.X) - v := math.Abs(p.Y) - w := math.Abs(p.Z) - - // We only need to consider the cases where u or v is the smallest value, - // since if w is the smallest then both expressions below will have a - // positive LHS and a negative RHS. - return (v >= w-u) && (u >= w-v) -} - -// intersectsOppositeEdges reports whether a directed line L intersects two -// opposite edges of a cube face F. This includs the case where L passes -// exactly through a corner vertex of F. The directed line L is defined -// by its normal N in the (u,v,w) coordinates of F. -func (p pointUVW) intersectsOppositeEdges() bool { - // The line L intersects opposite edges of the [-1,1]x[-1,1] (u,v) square if - // and only exactly two of the corner vertices lie on each side of L. This - // is true exactly when ||Nu| - |Nv|| >= |Nw|. The code below evaluates this - // expression exactly. - u := math.Abs(p.X) - v := math.Abs(p.Y) - w := math.Abs(p.Z) - - // If w is the smallest, the following line returns an exact result. - if math.Abs(u-v) != w { - return math.Abs(u-v) >= w - } - - // Otherwise u - v = w exactly, or w is not the smallest value. In either - // case the following returns the correct result. - if u >= v { - return u-w >= v - } - return v-w >= u -} - -// axis represents the possible results of exitAxis. -type axis int - -const ( - axisU axis = iota - axisV -) - -// exitAxis reports which axis the directed line L exits the cube face F on. -// The directed line L is represented by its CCW normal N in the (u,v,w) coordinates -// of F. It returns axisU if L exits through the u=-1 or u=+1 edge, and axisV if L exits -// through the v=-1 or v=+1 edge. Either result is acceptable if L exits exactly -// through a corner vertex of the cube face. -func (p pointUVW) exitAxis() axis { - if p.intersectsOppositeEdges() { - // The line passes through through opposite edges of the face. - // It exits through the v=+1 or v=-1 edge if the u-component of N has a - // larger absolute magnitude than the v-component. - if math.Abs(p.X) >= math.Abs(p.Y) { - return axisV - } - return axisU - } - - // The line passes through through two adjacent edges of the face. - // It exits the v=+1 or v=-1 edge if an even number of the components of N - // are negative. We test this using signbit() rather than multiplication - // to avoid the possibility of underflow. - var x, y, z int - if math.Signbit(p.X) { - x = 1 - } - if math.Signbit(p.Y) { - y = 1 - } - if math.Signbit(p.Z) { - z = 1 - } - - if x^y^z == 0 { - return axisV - } - return axisU -} - -// exitPoint returns the UV coordinates of the point where a directed line L (represented -// by the CCW normal of this point), exits the cube face this point is derived from along -// the given axis. -func (p pointUVW) exitPoint(a axis) r2.Point { - if a == axisU { - u := -1.0 - if p.Y > 0 { - u = 1.0 - } - return r2.Point{u, (-u*p.X - p.Z) / p.Y} - } - - v := -1.0 - if p.X < 0 { - v = 1.0 - } - return r2.Point{(-v*p.Y - p.Z) / p.X, v} -} - -// clipDestination returns a score which is used to indicate if the clipped edge AB -// on the given face intersects the face at all. This function returns the score for -// the given endpoint, which is an integer ranging from 0 to 3. If the sum of the scores -// from both of the endpoints is 3 or more, then edge AB does not intersect this face. -// -// First, it clips the line segment AB to find the clipped destination B' on a given -// face. (The face is specified implicitly by expressing *all arguments* in the (u,v,w) -// coordinates of that face.) Second, it partially computes whether the segment AB -// intersects this face at all. The actual condition is fairly complicated, but it -// turns out that it can be expressed as a "score" that can be computed independently -// when clipping the two endpoints A and B. -func clipDestination(a, b, scaledN, aTan, bTan pointUVW, scaleUV float64) (r2.Point, int) { - var uv r2.Point - - // Optimization: if B is within the safe region of the face, use it. - maxSafeUVCoord := 1 - faceClipErrorUVCoord - if b.Z > 0 { - uv = r2.Point{b.X / b.Z, b.Y / b.Z} - if math.Max(math.Abs(uv.X), math.Abs(uv.Y)) <= maxSafeUVCoord { - return uv, 0 - } - } - - // Otherwise find the point B' where the line AB exits the face. - uv = scaledN.exitPoint(scaledN.exitAxis()).Mul(scaleUV) - - p := pointUVW(Point{r3.Vector{uv.X, uv.Y, 1.0}}) - - // Determine if the exit point B' is contained within the segment. We do this - // by computing the dot products with two inward-facing tangent vectors at A - // and B. If either dot product is negative, we say that B' is on the "wrong - // side" of that point. As the point B' moves around the great circle AB past - // the segment endpoint B, it is initially on the wrong side of B only; as it - // moves further it is on the wrong side of both endpoints; and then it is on - // the wrong side of A only. If the exit point B' is on the wrong side of - // either endpoint, we can't use it; instead the segment is clipped at the - // original endpoint B. - // - // We reject the segment if the sum of the scores of the two endpoints is 3 - // or more. Here is what that rule encodes: - // - If B' is on the wrong side of A, then the other clipped endpoint A' - // must be in the interior of AB (otherwise AB' would go the wrong way - // around the circle). There is a similar rule for A'. - // - If B' is on the wrong side of either endpoint (and therefore we must - // use the original endpoint B instead), then it must be possible to - // project B onto this face (i.e., its w-coordinate must be positive). - // This rule is only necessary to handle certain zero-length edges (A=B). - score := 0 - if p.Sub(a.Vector).Dot(aTan.Vector) < 0 { - score = 2 // B' is on wrong side of A. - } else if p.Sub(b.Vector).Dot(bTan.Vector) < 0 { - score = 1 // B' is on wrong side of B. - } - - if score > 0 { // B' is not in the interior of AB. - if b.Z <= 0 { - score = 3 // B cannot be projected onto this face. - } else { - uv = r2.Point{b.X / b.Z, b.Y / b.Z} - } - } - - return uv, score -} - -// updateEndpoint returns the interval with the specified endpoint updated to -// the given value. If the value lies beyond the opposite endpoint, nothing is -// changed and false is returned. -func updateEndpoint(bound r1.Interval, highEndpoint bool, value float64) (r1.Interval, bool) { - if !highEndpoint { - if bound.Hi < value { - return bound, false - } - if bound.Lo < value { - bound.Lo = value - } - return bound, true - } - - if bound.Lo > value { - return bound, false - } - if bound.Hi > value { - bound.Hi = value - } - return bound, true -} - -// clipBoundAxis returns the clipped versions of the bounding intervals for the given -// axes for the line segment from (a0,a1) to (b0,b1) so that neither extends beyond the -// given clip interval. negSlope is a precomputed helper variable that indicates which -// diagonal of the bounding box is spanned by AB; it is false if AB has positive slope, -// and true if AB has negative slope. If the clipping interval doesn't overlap the bounds, -// false is returned. -func clipBoundAxis(a0, b0 float64, bound0 r1.Interval, a1, b1 float64, bound1 r1.Interval, - negSlope bool, clip r1.Interval) (bound0c, bound1c r1.Interval, updated bool) { - - if bound0.Lo < clip.Lo { - // If the upper bound is below the clips lower bound, there is nothing to do. - if bound0.Hi < clip.Lo { - return bound0, bound1, false - } - // narrow the intervals lower bound to the clip bound. - bound0.Lo = clip.Lo - if bound1, updated = updateEndpoint(bound1, negSlope, interpolateFloat64(clip.Lo, a0, b0, a1, b1)); !updated { - return bound0, bound1, false - } - } - - if bound0.Hi > clip.Hi { - // If the lower bound is above the clips upper bound, there is nothing to do. - if bound0.Lo > clip.Hi { - return bound0, bound1, false - } - // narrow the intervals upper bound to the clip bound. - bound0.Hi = clip.Hi - if bound1, updated = updateEndpoint(bound1, !negSlope, interpolateFloat64(clip.Hi, a0, b0, a1, b1)); !updated { - return bound0, bound1, false - } - } - return bound0, bound1, true -} - -// edgeIntersectsRect reports whether the edge defined by AB intersects the -// given closed rectangle to within the error bound. -func edgeIntersectsRect(a, b r2.Point, r r2.Rect) bool { - // First check whether the bounds of a Rect around AB intersects the given rect. - if !r.Intersects(r2.RectFromPoints(a, b)) { - return false - } - - // Otherwise AB intersects the rect if and only if all four vertices of rect - // do not lie on the same side of the extended line AB. We test this by finding - // the two vertices of rect with minimum and maximum projections onto the normal - // of AB, and computing their dot products with the edge normal. - n := b.Sub(a).Ortho() - - i := 0 - if n.X >= 0 { - i = 1 - } - j := 0 - if n.Y >= 0 { - j = 1 - } - - max := n.Dot(r.VertexIJ(i, j).Sub(a)) - min := n.Dot(r.VertexIJ(1-i, 1-j).Sub(a)) - - return (max >= 0) && (min <= 0) -} - -// clippedEdgeBound returns the bounding rectangle of the portion of the edge defined -// by AB intersected by clip. The resulting bound may be empty. This is a convenience -// function built on top of clipEdgeBound. -func clippedEdgeBound(a, b r2.Point, clip r2.Rect) r2.Rect { - bound := r2.RectFromPoints(a, b) - if b1, intersects := clipEdgeBound(a, b, clip, bound); intersects { - return b1 - } - return r2.EmptyRect() -} - -// clipEdgeBound clips an edge AB to sequence of rectangles efficiently. -// It represents the clipped edges by their bounding boxes rather than as a pair of -// endpoints. Specifically, let A'B' be some portion of an edge AB, and let bound be -// a tight bound of A'B'. This function returns the bound that is a tight bound -// of A'B' intersected with a given rectangle. If A'B' does not intersect clip, -// it returns false and the original bound. -func clipEdgeBound(a, b r2.Point, clip, bound r2.Rect) (r2.Rect, bool) { - // negSlope indicates which diagonal of the bounding box is spanned by AB: it - // is false if AB has positive slope, and true if AB has negative slope. This is - // used to determine which interval endpoints need to be updated each time - // the edge is clipped. - negSlope := (a.X > b.X) != (a.Y > b.Y) - - b0x, b0y, up1 := clipBoundAxis(a.X, b.X, bound.X, a.Y, b.Y, bound.Y, negSlope, clip.X) - if !up1 { - return bound, false - } - b1y, b1x, up2 := clipBoundAxis(a.Y, b.Y, b0y, a.X, b.X, b0x, negSlope, clip.Y) - if !up2 { - return r2.Rect{b0x, b0y}, false - } - return r2.Rect{X: b1x, Y: b1y}, true -} - -// interpolateFloat64 returns a value with the same combination of a1 and b1 as the -// given value x is of a and b. This function makes the following guarantees: -// - If x == a, then x1 = a1 (exactly). -// - If x == b, then x1 = b1 (exactly). -// - If a <= x <= b, then a1 <= x1 <= b1 (even if a1 == b1). -// This requires a != b. -func interpolateFloat64(x, a, b, a1, b1 float64) float64 { - // To get results that are accurate near both A and B, we interpolate - // starting from the closer of the two points. - if math.Abs(a-x) <= math.Abs(b-x) { - return a1 + (b1-a1)*(x-a)/(b-a) - } - return b1 + (a1-b1)*(x-b)/(a-b) -} - -// FaceSegment represents an edge AB clipped to an S2 cube face. It is -// represented by a face index and a pair of (u,v) coordinates. -type FaceSegment struct { - face int - a, b r2.Point -} - -// FaceSegments subdivides the given edge AB at every point where it crosses the -// boundary between two S2 cube faces and returns the corresponding FaceSegments. -// The segments are returned in order from A toward B. The input points must be -// unit length. -// -// This function guarantees that the returned segments form a continuous path -// from A to B, and that all vertices are within faceClipErrorUVDist of the -// line AB. All vertices lie within the [-1,1]x[-1,1] cube face rectangles. -// The results are consistent with Sign, i.e. the edge is well-defined even its -// endpoints are antipodal. -// TODO(roberts): Extend the implementation of PointCross so that this is true. -func FaceSegments(a, b Point) []FaceSegment { - var segment FaceSegment - - // Fast path: both endpoints are on the same face. - var aFace, bFace int - aFace, segment.a.X, segment.a.Y = xyzToFaceUV(a.Vector) - bFace, segment.b.X, segment.b.Y = xyzToFaceUV(b.Vector) - if aFace == bFace { - segment.face = aFace - return []FaceSegment{segment} - } - - // Starting at A, we follow AB from face to face until we reach the face - // containing B. The following code is designed to ensure that we always - // reach B, even in the presence of numerical errors. - // - // First we compute the normal to the plane containing A and B. This normal - // becomes the ultimate definition of the line AB; it is used to resolve all - // questions regarding where exactly the line goes. Unfortunately due to - // numerical errors, the line may not quite intersect the faces containing - // the original endpoints. We handle this by moving A and/or B slightly if - // necessary so that they are on faces intersected by the line AB. - ab := a.PointCross(b) - - aFace, segment.a = moveOriginToValidFace(aFace, a, ab, segment.a) - bFace, segment.b = moveOriginToValidFace(bFace, b, Point{ab.Mul(-1)}, segment.b) - - // Now we simply follow AB from face to face until we reach B. - var segments []FaceSegment - segment.face = aFace - bSaved := segment.b - - for face := aFace; face != bFace; { - // Complete the current segment by finding the point where AB - // exits the current face. - z := faceXYZtoUVW(face, ab) - n := pointUVW{z.Vector} - - exitAxis := n.exitAxis() - segment.b = n.exitPoint(exitAxis) - segments = append(segments, segment) - - // Compute the next face intersected by AB, and translate the exit - // point of the current segment into the (u,v) coordinates of the - // next face. This becomes the first point of the next segment. - exitXyz := faceUVToXYZ(face, segment.b.X, segment.b.Y) - face = nextFace(face, segment.b, exitAxis, n, bFace) - exitUvw := faceXYZtoUVW(face, Point{exitXyz}) - segment.face = face - segment.a = r2.Point{exitUvw.X, exitUvw.Y} - } - // Finish the last segment. - segment.b = bSaved - return append(segments, segment) -} - -// moveOriginToValidFace updates the origin point to a valid face if necessary. -// Given a line segment AB whose origin A has been projected onto a given cube -// face, determine whether it is necessary to project A onto a different face -// instead. This can happen because the normal of the line AB is not computed -// exactly, so that the line AB (defined as the set of points perpendicular to -// the normal) may not intersect the cube face containing A. Even if it does -// intersect the face, the exit point of the line from that face may be on -// the wrong side of A (i.e., in the direction away from B). If this happens, -// we reproject A onto the adjacent face where the line AB approaches A most -// closely. This moves the origin by a small amount, but never more than the -// error tolerances. -func moveOriginToValidFace(face int, a, ab Point, aUV r2.Point) (int, r2.Point) { - // Fast path: if the origin is sufficiently far inside the face, it is - // always safe to use it. - const maxSafeUVCoord = 1 - faceClipErrorUVCoord - if math.Max(math.Abs((aUV).X), math.Abs((aUV).Y)) <= maxSafeUVCoord { - return face, aUV - } - - // Otherwise check whether the normal AB even intersects this face. - z := faceXYZtoUVW(face, ab) - n := pointUVW{z.Vector} - if n.intersectsFace() { - // Check whether the point where the line AB exits this face is on the - // wrong side of A (by more than the acceptable error tolerance). - uv := n.exitPoint(n.exitAxis()) - exit := faceUVToXYZ(face, uv.X, uv.Y) - aTangent := ab.Normalize().Cross(a.Vector) - - // We can use the given face. - if exit.Sub(a.Vector).Dot(aTangent) >= -faceClipErrorRadians { - return face, aUV - } - } - - // Otherwise we reproject A to the nearest adjacent face. (If line AB does - // not pass through a given face, it must pass through all adjacent faces.) - var dir int - if math.Abs((aUV).X) >= math.Abs((aUV).Y) { - // U-axis - if aUV.X > 0 { - dir = 1 - } - face = uvwFace(face, 0, dir) - } else { - // V-axis - if aUV.Y > 0 { - dir = 1 - } - face = uvwFace(face, 1, dir) - } - - aUV.X, aUV.Y = validFaceXYZToUV(face, a.Vector) - aUV.X = math.Max(-1.0, math.Min(1.0, aUV.X)) - aUV.Y = math.Max(-1.0, math.Min(1.0, aUV.Y)) - - return face, aUV -} - -// nextFace returns the next face that should be visited by FaceSegments, given that -// we have just visited face and we are following the line AB (represented -// by its normal N in the (u,v,w) coordinates of that face). The other -// arguments include the point where AB exits face, the corresponding -// exit axis, and the target face containing the destination point B. -func nextFace(face int, exit r2.Point, axis axis, n pointUVW, targetFace int) int { - // this bit is to work around C++ cleverly casting bools to ints for you. - exitA := exit.X - exit1MinusA := exit.Y - - if axis == axisV { - exitA = exit.Y - exit1MinusA = exit.X - } - exitAPos := 0 - if exitA > 0 { - exitAPos = 1 - } - exit1MinusAPos := 0 - if exit1MinusA > 0 { - exit1MinusAPos = 1 - } - - // We return the face that is adjacent to the exit point along the given - // axis. If line AB exits *exactly* through a corner of the face, there are - // two possible next faces. If one is the target face containing B, then - // we guarantee that we advance to that face directly. - // - // The three conditions below check that (1) AB exits approximately through - // a corner, (2) the adjacent face along the non-exit axis is the target - // face, and (3) AB exits *exactly* through the corner. (The sumEqual - // code checks whether the dot product of (u,v,1) and n is exactly zero.) - if math.Abs(exit1MinusA) == 1 && - uvwFace(face, int(1-axis), exit1MinusAPos) == targetFace && - sumEqual(exit.X*n.X, exit.Y*n.Y, -n.Z) { - return targetFace - } - - // Otherwise return the face that is adjacent to the exit point in the - // direction of the exit axis. - return uvwFace(face, int(axis), exitAPos) -} diff --git a/vendor/github.com/golang/geo/s2/edge_crosser.go b/vendor/github.com/golang/geo/s2/edge_crosser.go deleted file mode 100644 index 69c6da6b9..000000000 --- a/vendor/github.com/golang/geo/s2/edge_crosser.go +++ /dev/null @@ -1,227 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" -) - -// EdgeCrosser allows edges to be efficiently tested for intersection with a -// given fixed edge AB. It is especially efficient when testing for -// intersection with an edge chain connecting vertices v0, v1, v2, ... -// -// Example usage: -// -// func CountIntersections(a, b Point, edges []Edge) int { -// count := 0 -// crosser := NewEdgeCrosser(a, b) -// for _, edge := range edges { -// if crosser.CrossingSign(&edge.First, &edge.Second) != DoNotCross { -// count++ -// } -// } -// return count -// } -// -type EdgeCrosser struct { - a Point - b Point - aXb Point - - // To reduce the number of calls to expensiveSign, we compute an - // outward-facing tangent at A and B if necessary. If the plane - // perpendicular to one of these tangents separates AB from CD (i.e., one - // edge on each side) then there is no intersection. - aTangent Point // Outward-facing tangent at A. - bTangent Point // Outward-facing tangent at B. - - // The fields below are updated for each vertex in the chain. - c Point // Previous vertex in the vertex chain. - acb Direction // The orientation of triangle ACB. -} - -// NewEdgeCrosser returns an EdgeCrosser with the fixed edge AB. -func NewEdgeCrosser(a, b Point) *EdgeCrosser { - norm := a.PointCross(b) - return &EdgeCrosser{ - a: a, - b: b, - aXb: Point{a.Cross(b.Vector)}, - aTangent: Point{a.Cross(norm.Vector)}, - bTangent: Point{norm.Cross(b.Vector)}, - } -} - -// CrossingSign reports whether the edge AB intersects the edge CD. If any two -// vertices from different edges are the same, returns MaybeCross. If either edge -// is degenerate (A == B or C == D), returns either DoNotCross or MaybeCross. -// -// Properties of CrossingSign: -// -// (1) CrossingSign(b,a,c,d) == CrossingSign(a,b,c,d) -// (2) CrossingSign(c,d,a,b) == CrossingSign(a,b,c,d) -// (3) CrossingSign(a,b,c,d) == MaybeCross if a==c, a==d, b==c, b==d -// (3) CrossingSign(a,b,c,d) == DoNotCross or MaybeCross if a==b or c==d -// -// Note that if you want to check an edge against a chain of other edges, -// it is slightly more efficient to use the single-argument version -// ChainCrossingSign below. -func (e *EdgeCrosser) CrossingSign(c, d Point) Crossing { - if c != e.c { - e.RestartAt(c) - } - return e.ChainCrossingSign(d) -} - -// EdgeOrVertexCrossing reports whether if CrossingSign(c, d) > 0, or AB and -// CD share a vertex and VertexCrossing(a, b, c, d) is true. -// -// This method extends the concept of a "crossing" to the case where AB -// and CD have a vertex in common. The two edges may or may not cross, -// according to the rules defined in VertexCrossing above. The rules -// are designed so that point containment tests can be implemented simply -// by counting edge crossings. Similarly, determining whether one edge -// chain crosses another edge chain can be implemented by counting. -func (e *EdgeCrosser) EdgeOrVertexCrossing(c, d Point) bool { - if c != e.c { - e.RestartAt(c) - } - return e.EdgeOrVertexChainCrossing(d) -} - -// NewChainEdgeCrosser is a convenience constructor that uses AB as the fixed edge, -// and C as the first vertex of the vertex chain (equivalent to calling RestartAt(c)). -// -// You don't need to use this or any of the chain functions unless you're trying to -// squeeze out every last drop of performance. Essentially all you are saving is a test -// whether the first vertex of the current edge is the same as the second vertex of the -// previous edge. -func NewChainEdgeCrosser(a, b, c Point) *EdgeCrosser { - e := NewEdgeCrosser(a, b) - e.RestartAt(c) - return e -} - -// RestartAt sets the current point of the edge crosser to be c. -// Call this method when your chain 'jumps' to a new place. -// The argument must point to a value that persists until the next call. -func (e *EdgeCrosser) RestartAt(c Point) { - e.c = c - e.acb = -triageSign(e.a, e.b, e.c) -} - -// ChainCrossingSign is like CrossingSign, but uses the last vertex passed to one of -// the crossing methods (or RestartAt) as the first vertex of the current edge. -func (e *EdgeCrosser) ChainCrossingSign(d Point) Crossing { - // For there to be an edge crossing, the triangles ACB, CBD, BDA, DAC must - // all be oriented the same way (CW or CCW). We keep the orientation of ACB - // as part of our state. When each new point D arrives, we compute the - // orientation of BDA and check whether it matches ACB. This checks whether - // the points C and D are on opposite sides of the great circle through AB. - - // Recall that triageSign is invariant with respect to rotating its - // arguments, i.e. ABD has the same orientation as BDA. - bda := triageSign(e.a, e.b, d) - if e.acb == -bda && bda != Indeterminate { - // The most common case -- triangles have opposite orientations. Save the - // current vertex D as the next vertex C, and also save the orientation of - // the new triangle ACB (which is opposite to the current triangle BDA). - e.c = d - e.acb = -bda - return DoNotCross - } - return e.crossingSign(d, bda) -} - -// EdgeOrVertexChainCrossing is like EdgeOrVertexCrossing, but uses the last vertex -// passed to one of the crossing methods (or RestartAt) as the first vertex of the current edge. -func (e *EdgeCrosser) EdgeOrVertexChainCrossing(d Point) bool { - // We need to copy e.c since it is clobbered by ChainCrossingSign. - c := e.c - switch e.ChainCrossingSign(d) { - case DoNotCross: - return false - case Cross: - return true - } - return VertexCrossing(e.a, e.b, c, d) -} - -// crossingSign handle the slow path of CrossingSign. -func (e *EdgeCrosser) crossingSign(d Point, bda Direction) Crossing { - // Compute the actual result, and then save the current vertex D as the next - // vertex C, and save the orientation of the next triangle ACB (which is - // opposite to the current triangle BDA). - defer func() { - e.c = d - e.acb = -bda - }() - - // At this point, a very common situation is that A,B,C,D are four points on - // a line such that AB does not overlap CD. (For example, this happens when - // a line or curve is sampled finely, or when geometry is constructed by - // computing the union of S2CellIds.) Most of the time, we can determine - // that AB and CD do not intersect using the two outward-facing - // tangents at A and B (parallel to AB) and testing whether AB and CD are on - // opposite sides of the plane perpendicular to one of these tangents. This - // is moderately expensive but still much cheaper than expensiveSign. - - // The error in RobustCrossProd is insignificant. The maximum error in - // the call to CrossProd (i.e., the maximum norm of the error vector) is - // (0.5 + 1/sqrt(3)) * dblEpsilon. The maximum error in each call to - // DotProd below is dblEpsilon. (There is also a small relative error - // term that is insignificant because we are comparing the result against a - // constant that is very close to zero.) - maxError := (1.5 + 1/math.Sqrt(3)) * dblEpsilon - if (e.c.Dot(e.aTangent.Vector) > maxError && d.Dot(e.aTangent.Vector) > maxError) || (e.c.Dot(e.bTangent.Vector) > maxError && d.Dot(e.bTangent.Vector) > maxError) { - return DoNotCross - } - - // Otherwise, eliminate the cases where two vertices from different edges are - // equal. (These cases could be handled in the code below, but we would rather - // avoid calling ExpensiveSign if possible.) - if e.a == e.c || e.a == d || e.b == e.c || e.b == d { - return MaybeCross - } - - // Eliminate the cases where an input edge is degenerate. (Note that in - // most cases, if CD is degenerate then this method is not even called - // because acb and bda have different signs.) - if e.a == e.b || e.c == d { - return DoNotCross - } - - // Otherwise it's time to break out the big guns. - if e.acb == Indeterminate { - e.acb = -expensiveSign(e.a, e.b, e.c) - } - if bda == Indeterminate { - bda = expensiveSign(e.a, e.b, d) - } - - if bda != e.acb { - return DoNotCross - } - - cbd := -RobustSign(e.c, d, e.b) - if cbd != e.acb { - return DoNotCross - } - dac := RobustSign(e.c, d, e.a) - if dac != e.acb { - return DoNotCross - } - return Cross -} diff --git a/vendor/github.com/golang/geo/s2/edge_crossings.go b/vendor/github.com/golang/geo/s2/edge_crossings.go deleted file mode 100644 index a98ec76ff..000000000 --- a/vendor/github.com/golang/geo/s2/edge_crossings.go +++ /dev/null @@ -1,396 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "math" - - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -const ( - // intersectionError can be set somewhat arbitrarily, because the algorithm - // uses more precision if necessary in order to achieve the specified error. - // The only strict requirement is that intersectionError >= dblEpsilon - // radians. However, using a larger error tolerance makes the algorithm more - // efficient because it reduces the number of cases where exact arithmetic is - // needed. - intersectionError = s1.Angle(8 * dblError) - - // intersectionMergeRadius is used to ensure that intersection points that - // are supposed to be coincident are merged back together into a single - // vertex. This is required in order for various polygon operations (union, - // intersection, etc) to work correctly. It is twice the intersection error - // because two coincident intersection points might have errors in - // opposite directions. - intersectionMergeRadius = 2 * intersectionError -) - -// A Crossing indicates how edges cross. -type Crossing int - -const ( - // Cross means the edges cross. - Cross Crossing = iota - // MaybeCross means two vertices from different edges are the same. - MaybeCross - // DoNotCross means the edges do not cross. - DoNotCross -) - -func (c Crossing) String() string { - switch c { - case Cross: - return "Cross" - case MaybeCross: - return "MaybeCross" - case DoNotCross: - return "DoNotCross" - default: - return fmt.Sprintf("(BAD CROSSING %d)", c) - } -} - -// CrossingSign reports whether the edge AB intersects the edge CD. -// If AB crosses CD at a point that is interior to both edges, Cross is returned. -// If any two vertices from different edges are the same it returns MaybeCross. -// Otherwise it returns DoNotCross. -// If either edge is degenerate (A == B or C == D), the return value is MaybeCross -// if two vertices from different edges are the same and DoNotCross otherwise. -// -// Properties of CrossingSign: -// -// (1) CrossingSign(b,a,c,d) == CrossingSign(a,b,c,d) -// (2) CrossingSign(c,d,a,b) == CrossingSign(a,b,c,d) -// (3) CrossingSign(a,b,c,d) == MaybeCross if a==c, a==d, b==c, b==d -// (3) CrossingSign(a,b,c,d) == DoNotCross or MaybeCross if a==b or c==d -// -// This method implements an exact, consistent perturbation model such -// that no three points are ever considered to be collinear. This means -// that even if you have 4 points A, B, C, D that lie exactly in a line -// (say, around the equator), C and D will be treated as being slightly to -// one side or the other of AB. This is done in a way such that the -// results are always consistent (see RobustSign). -func CrossingSign(a, b, c, d Point) Crossing { - crosser := NewChainEdgeCrosser(a, b, c) - return crosser.ChainCrossingSign(d) -} - -// VertexCrossing reports whether two edges "cross" in such a way that point-in-polygon -// containment tests can be implemented by counting the number of edge crossings. -// -// Given two edges AB and CD where at least two vertices are identical -// (i.e. CrossingSign(a,b,c,d) == 0), the basic rule is that a "crossing" -// occurs if AB is encountered after CD during a CCW sweep around the shared -// vertex starting from a fixed reference point. -// -// Note that according to this rule, if AB crosses CD then in general CD -// does not cross AB. However, this leads to the correct result when -// counting polygon edge crossings. For example, suppose that A,B,C are -// three consecutive vertices of a CCW polygon. If we now consider the edge -// crossings of a segment BP as P sweeps around B, the crossing number -// changes parity exactly when BP crosses BA or BC. -// -// Useful properties of VertexCrossing (VC): -// -// (1) VC(a,a,c,d) == VC(a,b,c,c) == false -// (2) VC(a,b,a,b) == VC(a,b,b,a) == true -// (3) VC(a,b,c,d) == VC(a,b,d,c) == VC(b,a,c,d) == VC(b,a,d,c) -// (3) If exactly one of a,b equals one of c,d, then exactly one of -// VC(a,b,c,d) and VC(c,d,a,b) is true -// -// It is an error to call this method with 4 distinct vertices. -func VertexCrossing(a, b, c, d Point) bool { - // If A == B or C == D there is no intersection. We need to check this - // case first in case 3 or more input points are identical. - if a == b || c == d { - return false - } - - // If any other pair of vertices is equal, there is a crossing if and only - // if OrderedCCW indicates that the edge AB is further CCW around the - // shared vertex O (either A or B) than the edge CD, starting from an - // arbitrary fixed reference point. - - // Optimization: if AB=CD or AB=DC, we can avoid most of the calculations. - switch { - case a == c: - return (b == d) || OrderedCCW(Point{a.Ortho()}, d, b, a) - case b == d: - return OrderedCCW(Point{b.Ortho()}, c, a, b) - case a == d: - return (b == c) || OrderedCCW(Point{a.Ortho()}, c, b, a) - case b == c: - return OrderedCCW(Point{b.Ortho()}, d, a, b) - } - - return false -} - -// EdgeOrVertexCrossing is a convenience function that calls CrossingSign to -// handle cases where all four vertices are distinct, and VertexCrossing to -// handle cases where two or more vertices are the same. This defines a crossing -// function such that point-in-polygon containment tests can be implemented -// by simply counting edge crossings. -func EdgeOrVertexCrossing(a, b, c, d Point) bool { - switch CrossingSign(a, b, c, d) { - case DoNotCross: - return false - case Cross: - return true - default: - return VertexCrossing(a, b, c, d) - } -} - -// Intersection returns the intersection point of two edges AB and CD that cross -// (CrossingSign(a,b,c,d) == Crossing). -// -// Useful properties of Intersection: -// -// (1) Intersection(b,a,c,d) == Intersection(a,b,d,c) == Intersection(a,b,c,d) -// (2) Intersection(c,d,a,b) == Intersection(a,b,c,d) -// -// The returned intersection point X is guaranteed to be very close to the -// true intersection point of AB and CD, even if the edges intersect at a -// very small angle. -func Intersection(a0, a1, b0, b1 Point) Point { - // It is difficult to compute the intersection point of two edges accurately - // when the angle between the edges is very small. Previously we handled - // this by only guaranteeing that the returned intersection point is within - // intersectionError of each edge. However, this means that when the edges - // cross at a very small angle, the computed result may be very far from the - // true intersection point. - // - // Instead this function now guarantees that the result is always within - // intersectionError of the true intersection. This requires using more - // sophisticated techniques and in some cases extended precision. - // - // - intersectionStable computes the intersection point using - // projection and interpolation, taking care to minimize cancellation - // error. - // - // - intersectionExact computes the intersection point using precision - // arithmetic and converts the final result back to an Point. - pt, ok := intersectionStable(a0, a1, b0, b1) - if !ok { - pt = intersectionExact(a0, a1, b0, b1) - } - - // Make sure the intersection point is on the correct side of the sphere. - // Since all vertices are unit length, and edges are less than 180 degrees, - // (a0 + a1) and (b0 + b1) both have positive dot product with the - // intersection point. We use the sum of all vertices to make sure that the - // result is unchanged when the edges are swapped or reversed. - if pt.Dot((a0.Add(a1.Vector)).Add(b0.Add(b1.Vector))) < 0 { - pt = Point{pt.Mul(-1)} - } - - return pt -} - -// Computes the cross product of two vectors, normalized to be unit length. -// Also returns the length of the cross -// product before normalization, which is useful for estimating the amount of -// error in the result. For numerical stability, the vectors should both be -// approximately unit length. -func robustNormalWithLength(x, y r3.Vector) (r3.Vector, float64) { - var pt r3.Vector - // This computes 2 * (x.Cross(y)), but has much better numerical - // stability when x and y are unit length. - tmp := x.Sub(y).Cross(x.Add(y)) - length := tmp.Norm() - if length != 0 { - pt = tmp.Mul(1 / length) - } - return pt, 0.5 * length // Since tmp == 2 * (x.Cross(y)) -} - -/* -// intersectionSimple is not used by the C++ so it is skipped here. -*/ - -// projection returns the projection of aNorm onto X (x.Dot(aNorm)), and a bound -// on the error in the result. aNorm is not necessarily unit length. -// -// The remaining parameters (the length of aNorm (aNormLen) and the edge endpoints -// a0 and a1) allow this dot product to be computed more accurately and efficiently. -func projection(x, aNorm r3.Vector, aNormLen float64, a0, a1 Point) (proj, bound float64) { - // The error in the dot product is proportional to the lengths of the input - // vectors, so rather than using x itself (a unit-length vector) we use - // the vectors from x to the closer of the two edge endpoints. This - // typically reduces the error by a huge factor. - x0 := x.Sub(a0.Vector) - x1 := x.Sub(a1.Vector) - x0Dist2 := x0.Norm2() - x1Dist2 := x1.Norm2() - - // If both distances are the same, we need to be careful to choose one - // endpoint deterministically so that the result does not change if the - // order of the endpoints is reversed. - var dist float64 - if x0Dist2 < x1Dist2 || (x0Dist2 == x1Dist2 && x0.Cmp(x1) == -1) { - dist = math.Sqrt(x0Dist2) - proj = x0.Dot(aNorm) - } else { - dist = math.Sqrt(x1Dist2) - proj = x1.Dot(aNorm) - } - - // This calculation bounds the error from all sources: the computation of - // the normal, the subtraction of one endpoint, and the dot product itself. - // dblError appears because the input points are assumed to be - // normalized in double precision. - // - // For reference, the bounds that went into this calculation are: - // ||N'-N|| <= ((1 + 2 * sqrt(3))||N|| + 32 * sqrt(3) * dblError) * epsilon - // |(A.B)'-(A.B)| <= (1.5 * (A.B) + 1.5 * ||A|| * ||B||) * epsilon - // ||(X-Y)'-(X-Y)|| <= ||X-Y|| * epsilon - bound = (((3.5+2*math.Sqrt(3))*aNormLen+32*math.Sqrt(3)*dblError)*dist + 1.5*math.Abs(proj)) * epsilon - return proj, bound -} - -// compareEdges reports whether (a0,a1) is less than (b0,b1) with respect to a total -// ordering on edges that is invariant under edge reversals. -func compareEdges(a0, a1, b0, b1 Point) bool { - if a0.Cmp(a1.Vector) != -1 { - a0, a1 = a1, a0 - } - if b0.Cmp(b1.Vector) != -1 { - b0, b1 = b1, b0 - } - return a0.Cmp(b0.Vector) == -1 || (a0 == b0 && b0.Cmp(b1.Vector) == -1) -} - -// intersectionStable returns the intersection point of the edges (a0,a1) and -// (b0,b1) if it can be computed to within an error of at most intersectionError -// by this function. -// -// The intersection point is not guaranteed to have the correct sign because we -// choose to use the longest of the two edges first. The sign is corrected by -// Intersection. -func intersectionStable(a0, a1, b0, b1 Point) (Point, bool) { - // Sort the two edges so that (a0,a1) is longer, breaking ties in a - // deterministic way that does not depend on the ordering of the endpoints. - // This is desirable for two reasons: - // - So that the result doesn't change when edges are swapped or reversed. - // - It reduces error, since the first edge is used to compute the edge - // normal (where a longer edge means less error), and the second edge - // is used for interpolation (where a shorter edge means less error). - aLen2 := a1.Sub(a0.Vector).Norm2() - bLen2 := b1.Sub(b0.Vector).Norm2() - if aLen2 < bLen2 || (aLen2 == bLen2 && compareEdges(a0, a1, b0, b1)) { - return intersectionStableSorted(b0, b1, a0, a1) - } - return intersectionStableSorted(a0, a1, b0, b1) -} - -// intersectionStableSorted is a helper function for intersectionStable. -// It expects that the edges (a0,a1) and (b0,b1) have been sorted so that -// the first edge passed in is longer. -func intersectionStableSorted(a0, a1, b0, b1 Point) (Point, bool) { - var pt Point - - // Compute the normal of the plane through (a0, a1) in a stable way. - aNorm := a0.Sub(a1.Vector).Cross(a0.Add(a1.Vector)) - aNormLen := aNorm.Norm() - bLen := b1.Sub(b0.Vector).Norm() - - // Compute the projection (i.e., signed distance) of b0 and b1 onto the - // plane through (a0, a1). Distances are scaled by the length of aNorm. - b0Dist, b0Error := projection(b0.Vector, aNorm, aNormLen, a0, a1) - b1Dist, b1Error := projection(b1.Vector, aNorm, aNormLen, a0, a1) - - // The total distance from b0 to b1 measured perpendicularly to (a0,a1) is - // |b0Dist - b1Dist|. Note that b0Dist and b1Dist generally have - // opposite signs because b0 and b1 are on opposite sides of (a0, a1). The - // code below finds the intersection point by interpolating along the edge - // (b0, b1) to a fractional distance of b0Dist / (b0Dist - b1Dist). - // - // It can be shown that the maximum error in the interpolation fraction is - // - // (b0Dist * b1Error - b1Dist * b0Error) / (distSum * (distSum - errorSum)) - // - // We save ourselves some work by scaling the result and the error bound by - // "distSum", since the result is normalized to be unit length anyway. - distSum := math.Abs(b0Dist - b1Dist) - errorSum := b0Error + b1Error - if distSum <= errorSum { - return pt, false // Error is unbounded in this case. - } - - x := b1.Mul(b0Dist).Sub(b0.Mul(b1Dist)) - err := bLen*math.Abs(b0Dist*b1Error-b1Dist*b0Error)/ - (distSum-errorSum) + 2*distSum*epsilon - - // Finally we normalize the result, compute the corresponding error, and - // check whether the total error is acceptable. - xLen := x.Norm() - maxError := intersectionError - if err > (float64(maxError)-epsilon)*xLen { - return pt, false - } - - return Point{x.Mul(1 / xLen)}, true -} - -// intersectionExact returns the intersection point of (a0, a1) and (b0, b1) -// using precise arithmetic. Note that the result is not exact because it is -// rounded down to double precision at the end. Also, the intersection point -// is not guaranteed to have the correct sign (i.e., the return value may need -// to be negated). -func intersectionExact(a0, a1, b0, b1 Point) Point { - // Since we are using presice arithmetic, we don't need to worry about - // numerical stability. - a0P := r3.PreciseVectorFromVector(a0.Vector) - a1P := r3.PreciseVectorFromVector(a1.Vector) - b0P := r3.PreciseVectorFromVector(b0.Vector) - b1P := r3.PreciseVectorFromVector(b1.Vector) - aNormP := a0P.Cross(a1P) - bNormP := b0P.Cross(b1P) - xP := aNormP.Cross(bNormP) - - // The final Normalize() call is done in double precision, which creates a - // directional error of up to 2*dblError. (Precise conversion and Normalize() - // each contribute up to dblError of directional error.) - x := xP.Vector() - - if x == (r3.Vector{}) { - // The two edges are exactly collinear, but we still consider them to be - // "crossing" because of simulation of simplicity. Out of the four - // endpoints, exactly two lie in the interior of the other edge. Of - // those two we return the one that is lexicographically smallest. - x = r3.Vector{10, 10, 10} // Greater than any valid S2Point - - aNorm := Point{aNormP.Vector()} - bNorm := Point{bNormP.Vector()} - if OrderedCCW(b0, a0, b1, bNorm) && a0.Cmp(x) == -1 { - return a0 - } - if OrderedCCW(b0, a1, b1, bNorm) && a1.Cmp(x) == -1 { - return a1 - } - if OrderedCCW(a0, b0, a1, aNorm) && b0.Cmp(x) == -1 { - return b0 - } - if OrderedCCW(a0, b1, a1, aNorm) && b1.Cmp(x) == -1 { - return b1 - } - } - - return Point{x} -} diff --git a/vendor/github.com/golang/geo/s2/edge_distances.go b/vendor/github.com/golang/geo/s2/edge_distances.go deleted file mode 100644 index ca197af1d..000000000 --- a/vendor/github.com/golang/geo/s2/edge_distances.go +++ /dev/null @@ -1,408 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// This file defines a collection of methods for computing the distance to an edge, -// interpolating along an edge, projecting points onto edges, etc. - -import ( - "math" - - "github.com/golang/geo/s1" -) - -// DistanceFromSegment returns the distance of point X from line segment AB. -// The points are expected to be normalized. The result is very accurate for small -// distances but may have some numerical error if the distance is large -// (approximately pi/2 or greater). The case A == B is handled correctly. -func DistanceFromSegment(x, a, b Point) s1.Angle { - var minDist s1.ChordAngle - minDist, _ = updateMinDistance(x, a, b, minDist, true) - return minDist.Angle() -} - -// IsDistanceLess reports whether the distance from X to the edge AB is less -// than limit. (For less than or equal to, specify limit.Successor()). -// This method is faster than DistanceFromSegment(). If you want to -// compare against a fixed s1.Angle, you should convert it to an s1.ChordAngle -// once and save the value, since this conversion is relatively expensive. -func IsDistanceLess(x, a, b Point, limit s1.ChordAngle) bool { - _, less := UpdateMinDistance(x, a, b, limit) - return less -} - -// UpdateMinDistance checks if the distance from X to the edge AB is less -// than minDist, and if so, returns the updated value and true. -// The case A == B is handled correctly. -// -// Use this method when you want to compute many distances and keep track of -// the minimum. It is significantly faster than using DistanceFromSegment -// because (1) using s1.ChordAngle is much faster than s1.Angle, and (2) it -// can save a lot of work by not actually computing the distance when it is -// obviously larger than the current minimum. -func UpdateMinDistance(x, a, b Point, minDist s1.ChordAngle) (s1.ChordAngle, bool) { - return updateMinDistance(x, a, b, minDist, false) -} - -// UpdateMaxDistance checks if the distance from X to the edge AB is greater -// than maxDist, and if so, returns the updated value and true. -// Otherwise it returns false. The case A == B is handled correctly. -func UpdateMaxDistance(x, a, b Point, maxDist s1.ChordAngle) (s1.ChordAngle, bool) { - dist := maxChordAngle(ChordAngleBetweenPoints(x, a), ChordAngleBetweenPoints(x, b)) - if dist > s1.RightChordAngle { - dist, _ = updateMinDistance(Point{x.Mul(-1)}, a, b, dist, true) - dist = s1.StraightChordAngle - dist - } - if maxDist < dist { - return dist, true - } - - return maxDist, false -} - -// IsInteriorDistanceLess reports whether the minimum distance from X to the edge -// AB is attained at an interior point of AB (i.e., not an endpoint), and that -// distance is less than limit. (Specify limit.Successor() for less than or equal to). -func IsInteriorDistanceLess(x, a, b Point, limit s1.ChordAngle) bool { - _, less := UpdateMinInteriorDistance(x, a, b, limit) - return less -} - -// UpdateMinInteriorDistance reports whether the minimum distance from X to AB -// is attained at an interior point of AB (i.e., not an endpoint), and that distance -// is less than minDist. If so, the value of minDist is updated and true is returned. -// Otherwise it is unchanged and returns false. -func UpdateMinInteriorDistance(x, a, b Point, minDist s1.ChordAngle) (s1.ChordAngle, bool) { - return interiorDist(x, a, b, minDist, false) -} - -// Project returns the point along the edge AB that is closest to the point X. -// The fractional distance of this point along the edge AB can be obtained -// using DistanceFraction. -// -// This requires that all points are unit length. -func Project(x, a, b Point) Point { - aXb := a.PointCross(b) - // Find the closest point to X along the great circle through AB. - p := x.Sub(aXb.Mul(x.Dot(aXb.Vector) / aXb.Vector.Norm2())) - - // If this point is on the edge AB, then it's the closest point. - if Sign(aXb, a, Point{p}) && Sign(Point{p}, b, aXb) { - return Point{p.Normalize()} - } - - // Otherwise, the closest point is either A or B. - if x.Sub(a.Vector).Norm2() <= x.Sub(b.Vector).Norm2() { - return a - } - return b -} - -// DistanceFraction returns the distance ratio of the point X along an edge AB. -// If X is on the line segment AB, this is the fraction T such -// that X == Interpolate(T, A, B). -// -// This requires that A and B are distinct. -func DistanceFraction(x, a, b Point) float64 { - d0 := x.Angle(a.Vector) - d1 := x.Angle(b.Vector) - return float64(d0 / (d0 + d1)) -} - -// Interpolate returns the point X along the line segment AB whose distance from A -// is the given fraction "t" of the distance AB. Does NOT require that "t" be -// between 0 and 1. Note that all distances are measured on the surface of -// the sphere, so this is more complicated than just computing (1-t)*a + t*b -// and normalizing the result. -func Interpolate(t float64, a, b Point) Point { - if t == 0 { - return a - } - if t == 1 { - return b - } - ab := a.Angle(b.Vector) - return InterpolateAtDistance(s1.Angle(t)*ab, a, b) -} - -// InterpolateAtDistance returns the point X along the line segment AB whose -// distance from A is the angle ax. -func InterpolateAtDistance(ax s1.Angle, a, b Point) Point { - aRad := ax.Radians() - - // Use PointCross to compute the tangent vector at A towards B. The - // result is always perpendicular to A, even if A=B or A=-B, but it is not - // necessarily unit length. (We effectively normalize it below.) - normal := a.PointCross(b) - tangent := normal.Vector.Cross(a.Vector) - - // Now compute the appropriate linear combination of A and "tangent". With - // infinite precision the result would always be unit length, but we - // normalize it anyway to ensure that the error is within acceptable bounds. - // (Otherwise errors can build up when the result of one interpolation is - // fed into another interpolation.) - return Point{(a.Mul(math.Cos(aRad)).Add(tangent.Mul(math.Sin(aRad) / tangent.Norm()))).Normalize()} -} - -// minUpdateDistanceMaxError returns the maximum error in the result of -// UpdateMinDistance (and the associated functions such as -// UpdateMinInteriorDistance, IsDistanceLess, etc), assuming that all -// input points are normalized to within the bounds guaranteed by r3.Vector's -// Normalize. The error can be added or subtracted from an s1.ChordAngle -// using its Expanded method. -func minUpdateDistanceMaxError(dist s1.ChordAngle) float64 { - // There are two cases for the maximum error in UpdateMinDistance(), - // depending on whether the closest point is interior to the edge. - return math.Max(minUpdateInteriorDistanceMaxError(dist), dist.MaxPointError()) -} - -// minUpdateInteriorDistanceMaxError returns the maximum error in the result of -// UpdateMinInteriorDistance, assuming that all input points are normalized -// to within the bounds guaranteed by Point's Normalize. The error can be added -// or subtracted from an s1.ChordAngle using its Expanded method. -// -// Note that accuracy goes down as the distance approaches 0 degrees or 180 -// degrees (for different reasons). Near 0 degrees the error is acceptable -// for all practical purposes (about 1.2e-15 radians ~= 8 nanometers). For -// exactly antipodal points the maximum error is quite high (0.5 meters), -// but this error drops rapidly as the points move away from antipodality -// (approximately 1 millimeter for points that are 50 meters from antipodal, -// and 1 micrometer for points that are 50km from antipodal). -// -// TODO(roberts): Currently the error bound does not hold for edges whose endpoints -// are antipodal to within about 1e-15 radians (less than 1 micron). This could -// be fixed by extending PointCross to use higher precision when necessary. -func minUpdateInteriorDistanceMaxError(dist s1.ChordAngle) float64 { - // If a point is more than 90 degrees from an edge, then the minimum - // distance is always to one of the endpoints, not to the edge interior. - if dist >= s1.RightChordAngle { - return 0.0 - } - - // This bound includes all source of error, assuming that the input points - // are normalized. a and b are components of chord length that are - // perpendicular and parallel to a plane containing the edge respectively. - b := math.Min(1.0, 0.5*float64(dist)) - a := math.Sqrt(b * (2 - b)) - return ((2.5+2*math.Sqrt(3)+8.5*a)*a + - (2+2*math.Sqrt(3)/3+6.5*(1-b))*b + - (23+16/math.Sqrt(3))*dblEpsilon) * dblEpsilon -} - -// updateMinDistance computes the distance from a point X to a line segment AB, -// and if either the distance was less than the given minDist, or alwaysUpdate is -// true, the value and whether it was updated are returned. -func updateMinDistance(x, a, b Point, minDist s1.ChordAngle, alwaysUpdate bool) (s1.ChordAngle, bool) { - if d, ok := interiorDist(x, a, b, minDist, alwaysUpdate); ok { - // Minimum distance is attained along the edge interior. - return d, true - } - - // Otherwise the minimum distance is to one of the endpoints. - xa2, xb2 := (x.Sub(a.Vector)).Norm2(), x.Sub(b.Vector).Norm2() - dist := s1.ChordAngle(math.Min(xa2, xb2)) - if !alwaysUpdate && dist >= minDist { - return minDist, false - } - return dist, true -} - -// interiorDist returns the shortest distance from point x to edge ab, assuming -// that the closest point to X is interior to AB. If the closest point is not -// interior to AB, interiorDist returns (minDist, false). If alwaysUpdate is set to -// false, the distance is only updated when the value exceeds certain the given minDist. -func interiorDist(x, a, b Point, minDist s1.ChordAngle, alwaysUpdate bool) (s1.ChordAngle, bool) { - // Chord distance of x to both end points a and b. - xa2, xb2 := (x.Sub(a.Vector)).Norm2(), x.Sub(b.Vector).Norm2() - - // The closest point on AB could either be one of the two vertices (the - // vertex case) or in the interior (the interior case). Let C = A x B. - // If X is in the spherical wedge extending from A to B around the axis - // through C, then we are in the interior case. Otherwise we are in the - // vertex case. - // - // Check whether we might be in the interior case. For this to be true, XAB - // and XBA must both be acute angles. Checking this condition exactly is - // expensive, so instead we consider the planar triangle ABX (which passes - // through the sphere's interior). The planar angles XAB and XBA are always - // less than the corresponding spherical angles, so if we are in the - // interior case then both of these angles must be acute. - // - // We check this by computing the squared edge lengths of the planar - // triangle ABX, and testing whether angles XAB and XBA are both acute using - // the law of cosines: - // - // | XA^2 - XB^2 | < AB^2 (*) - // - // This test must be done conservatively (taking numerical errors into - // account) since otherwise we might miss a situation where the true minimum - // distance is achieved by a point on the edge interior. - // - // There are two sources of error in the expression above (*). The first is - // that points are not normalized exactly; they are only guaranteed to be - // within 2 * dblEpsilon of unit length. Under the assumption that the two - // sides of (*) are nearly equal, the total error due to normalization errors - // can be shown to be at most - // - // 2 * dblEpsilon * (XA^2 + XB^2 + AB^2) + 8 * dblEpsilon ^ 2 . - // - // The other source of error is rounding of results in the calculation of (*). - // Each of XA^2, XB^2, AB^2 has a maximum relative error of 2.5 * dblEpsilon, - // plus an additional relative error of 0.5 * dblEpsilon in the final - // subtraction which we further bound as 0.25 * dblEpsilon * (XA^2 + XB^2 + - // AB^2) for convenience. This yields a final error bound of - // - // 4.75 * dblEpsilon * (XA^2 + XB^2 + AB^2) + 8 * dblEpsilon ^ 2 . - ab2 := a.Sub(b.Vector).Norm2() - maxError := (4.75*dblEpsilon*(xa2+xb2+ab2) + 8*dblEpsilon*dblEpsilon) - if math.Abs(xa2-xb2) >= ab2+maxError { - return minDist, false - } - - // The minimum distance might be to a point on the edge interior. Let R - // be closest point to X that lies on the great circle through AB. Rather - // than computing the geodesic distance along the surface of the sphere, - // instead we compute the "chord length" through the sphere's interior. - // - // The squared chord length XR^2 can be expressed as XQ^2 + QR^2, where Q - // is the point X projected onto the plane through the great circle AB. - // The distance XQ^2 can be written as (X.C)^2 / |C|^2 where C = A x B. - // We ignore the QR^2 term and instead use XQ^2 as a lower bound, since it - // is faster and the corresponding distance on the Earth's surface is - // accurate to within 1% for distances up to about 1800km. - c := a.PointCross(b) - c2 := c.Norm2() - xDotC := x.Dot(c.Vector) - xDotC2 := xDotC * xDotC - if !alwaysUpdate && xDotC2 > c2*float64(minDist) { - // The closest point on the great circle AB is too far away. We need to - // test this using ">" rather than ">=" because the actual minimum bound - // on the distance is (xDotC2 / c2), which can be rounded differently - // than the (more efficient) multiplicative test above. - return minDist, false - } - - // Otherwise we do the exact, more expensive test for the interior case. - // This test is very likely to succeed because of the conservative planar - // test we did initially. - // - // TODO(roberts): Ensure that the errors in test are accurately reflected in the - // minUpdateInteriorDistanceMaxError. - cx := c.Cross(x.Vector) - if a.Sub(x.Vector).Dot(cx) >= 0 || b.Sub(x.Vector).Dot(cx) <= 0 { - return minDist, false - } - - // Compute the squared chord length XR^2 = XQ^2 + QR^2 (see above). - // This calculation has good accuracy for all chord lengths since it - // is based on both the dot product and cross product (rather than - // deriving one from the other). However, note that the chord length - // representation itself loses accuracy as the angle approaches π. - qr := 1 - math.Sqrt(cx.Norm2()/c2) - dist := s1.ChordAngle((xDotC2 / c2) + (qr * qr)) - - if !alwaysUpdate && dist >= minDist { - return minDist, false - } - - return dist, true -} - -// updateEdgePairMinDistance computes the minimum distance between the given -// pair of edges. If the two edges cross, the distance is zero. The cases -// a0 == a1 and b0 == b1 are handled correctly. -func updateEdgePairMinDistance(a0, a1, b0, b1 Point, minDist s1.ChordAngle) (s1.ChordAngle, bool) { - if minDist == 0 { - return 0, false - } - if CrossingSign(a0, a1, b0, b1) == Cross { - minDist = 0 - return 0, true - } - - // Otherwise, the minimum distance is achieved at an endpoint of at least - // one of the two edges. We ensure that all four possibilities are always checked. - // - // The calculation below computes each of the six vertex-vertex distances - // twice (this could be optimized). - var ok1, ok2, ok3, ok4 bool - minDist, ok1 = UpdateMinDistance(a0, b0, b1, minDist) - minDist, ok2 = UpdateMinDistance(a1, b0, b1, minDist) - minDist, ok3 = UpdateMinDistance(b0, a0, a1, minDist) - minDist, ok4 = UpdateMinDistance(b1, a0, a1, minDist) - return minDist, ok1 || ok2 || ok3 || ok4 -} - -// updateEdgePairMaxDistance reports the minimum distance between the given pair of edges. -// If one edge crosses the antipodal reflection of the other, the distance is pi. -func updateEdgePairMaxDistance(a0, a1, b0, b1 Point, maxDist s1.ChordAngle) (s1.ChordAngle, bool) { - if maxDist == s1.StraightChordAngle { - return s1.StraightChordAngle, false - } - if CrossingSign(a0, a1, Point{b0.Mul(-1)}, Point{b1.Mul(-1)}) == Cross { - return s1.StraightChordAngle, true - } - - // Otherwise, the maximum distance is achieved at an endpoint of at least - // one of the two edges. We ensure that all four possibilities are always checked. - // - // The calculation below computes each of the six vertex-vertex distances - // twice (this could be optimized). - var ok1, ok2, ok3, ok4 bool - maxDist, ok1 = UpdateMaxDistance(a0, b0, b1, maxDist) - maxDist, ok2 = UpdateMaxDistance(a1, b0, b1, maxDist) - maxDist, ok3 = UpdateMaxDistance(b0, a0, a1, maxDist) - maxDist, ok4 = UpdateMaxDistance(b1, a0, a1, maxDist) - return maxDist, ok1 || ok2 || ok3 || ok4 -} - -// EdgePairClosestPoints returns the pair of points (a, b) that achieves the -// minimum distance between edges a0a1 and b0b1, where a is a point on a0a1 and -// b is a point on b0b1. If the two edges intersect, a and b are both equal to -// the intersection point. Handles a0 == a1 and b0 == b1 correctly. -func EdgePairClosestPoints(a0, a1, b0, b1 Point) (Point, Point) { - if CrossingSign(a0, a1, b0, b1) == Cross { - x := Intersection(a0, a1, b0, b1) - return x, x - } - // We save some work by first determining which vertex/edge pair achieves - // the minimum distance, and then computing the closest point on that edge. - var minDist s1.ChordAngle - var ok bool - - minDist, ok = updateMinDistance(a0, b0, b1, minDist, true) - closestVertex := 0 - if minDist, ok = UpdateMinDistance(a1, b0, b1, minDist); ok { - closestVertex = 1 - } - if minDist, ok = UpdateMinDistance(b0, a0, a1, minDist); ok { - closestVertex = 2 - } - if minDist, ok = UpdateMinDistance(b1, a0, a1, minDist); ok { - closestVertex = 3 - } - switch closestVertex { - case 0: - return a0, Project(a0, b0, b1) - case 1: - return a1, Project(a1, b0, b1) - case 2: - return Project(b0, a0, a1), b0 - case 3: - return Project(b1, a0, a1), b1 - default: - panic("illegal case reached") - } -} diff --git a/vendor/github.com/golang/geo/s2/edge_query.go b/vendor/github.com/golang/geo/s2/edge_query.go deleted file mode 100644 index 2d443d1ce..000000000 --- a/vendor/github.com/golang/geo/s2/edge_query.go +++ /dev/null @@ -1,803 +0,0 @@ -// Copyright 2019 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "sort" - - "github.com/golang/geo/s1" -) - -// EdgeQueryOptions holds the options for controlling how EdgeQuery operates. -// -// Options can be chained together builder-style: -// -// opts = NewClosestEdgeQueryOptions(). -// MaxResults(1). -// DistanceLimit(s1.ChordAngleFromAngle(3 * s1.Degree)). -// MaxError(s1.ChordAngleFromAngle(0.001 * s1.Degree)) -// query = NewClosestEdgeQuery(index, opts) -// -// or set individually: -// -// opts = NewClosestEdgeQueryOptions() -// opts.IncludeInteriors(true) -// -// or just inline: -// -// query = NewClosestEdgeQuery(index, NewClosestEdgeQueryOptions().MaxResults(3)) -// -// If you pass a nil as the options you get the default values for the options. -type EdgeQueryOptions struct { - common *queryOptions -} - -// DistanceLimit specifies that only edges whose distance to the target is -// within, this distance should be returned. Edges whose distance is equal -// are not returned. To include values that are equal, specify the limit with -// the next largest representable distance. i.e. limit.Successor(). -func (e *EdgeQueryOptions) DistanceLimit(limit s1.ChordAngle) *EdgeQueryOptions { - e.common = e.common.DistanceLimit(limit) - return e -} - -// IncludeInteriors specifies whether polygon interiors should be -// included when measuring distances. -func (e *EdgeQueryOptions) IncludeInteriors(x bool) *EdgeQueryOptions { - e.common = e.common.IncludeInteriors(x) - return e -} - -// UseBruteForce sets or disables the use of brute force in a query. -func (e *EdgeQueryOptions) UseBruteForce(x bool) *EdgeQueryOptions { - e.common = e.common.UseBruteForce(x) - return e -} - -// MaxError specifies that edges up to dist away than the true -// matching edges may be substituted in the result set, as long as such -// edges satisfy all the remaining search criteria (such as DistanceLimit). -// This option only has an effect if MaxResults is also specified; -// otherwise all edges closer than MaxDistance will always be returned. -func (e *EdgeQueryOptions) MaxError(dist s1.ChordAngle) *EdgeQueryOptions { - e.common = e.common.MaxError(dist) - return e -} - -// MaxResults specifies that at most MaxResults edges should be returned. -// This must be at least 1. -func (e *EdgeQueryOptions) MaxResults(n int) *EdgeQueryOptions { - e.common = e.common.MaxResults(n) - return e -} - -// NewClosestEdgeQueryOptions returns a set of edge query options suitable -// for performing closest edge queries. -func NewClosestEdgeQueryOptions() *EdgeQueryOptions { - return &EdgeQueryOptions{ - common: newQueryOptions(minDistance(0)), - } -} - -// NewFurthestEdgeQueryOptions returns a set of edge query options suitable -// for performing furthest edge queries. -func NewFurthestEdgeQueryOptions() *EdgeQueryOptions { - return &EdgeQueryOptions{ - common: newQueryOptions(maxDistance(0)), - } -} - -// EdgeQueryResult represents an edge that meets the target criteria for the -// query. Note the following special cases: -// -// - ShapeID >= 0 && EdgeID < 0 represents the interior of a shape. -// Such results may be returned when the option IncludeInteriors is true. -// -// - ShapeID < 0 && EdgeID < 0 is returned to indicate that no edge -// satisfies the requested query options. -type EdgeQueryResult struct { - distance distance - shapeID int32 - edgeID int32 -} - -// Distance reports the distance between the edge in this shape that satisfied -// the query's parameters. -func (e EdgeQueryResult) Distance() s1.ChordAngle { return e.distance.chordAngle() } - -// ShapeID reports the ID of the Shape this result is for. -func (e EdgeQueryResult) ShapeID() int32 { return e.shapeID } - -// EdgeID reports the ID of the edge in the results Shape. -func (e EdgeQueryResult) EdgeID() int32 { return e.edgeID } - -// newEdgeQueryResult returns a result instance with default values. -func newEdgeQueryResult(target distanceTarget) EdgeQueryResult { - return EdgeQueryResult{ - distance: target.distance().infinity(), - shapeID: -1, - edgeID: -1, - } -} - -// IsInterior reports if this result represents the interior of a Shape. -func (e EdgeQueryResult) IsInterior() bool { - return e.shapeID >= 0 && e.edgeID < 0 -} - -// IsEmpty reports if this has no edge that satisfies the given edge query options. -// This result is only returned in one special case, namely when FindEdge() does -// not find any suitable edges. -func (e EdgeQueryResult) IsEmpty() bool { - return e.shapeID < 0 -} - -// Less reports if this results is less that the other first by distance, -// then by (shapeID, edgeID). This is used for sorting. -func (e EdgeQueryResult) Less(other EdgeQueryResult) bool { - if e.distance.chordAngle() != other.distance.chordAngle() { - return e.distance.less(other.distance) - } - if e.shapeID != other.shapeID { - return e.shapeID < other.shapeID - } - return e.edgeID < other.edgeID -} - -// EdgeQuery is used to find the edge(s) between two geometries that match a -// given set of options. It is flexible enough so that it can be adapted to -// compute maximum distances and even potentially Hausdorff distances. -// -// By using the appropriate options, this type can answer questions such as: -// -// - Find the minimum distance between two geometries A and B. -// - Find all edges of geometry A that are within a distance D of geometry B. -// - Find the k edges of geometry A that are closest to a given point P. -// -// You can also specify whether polygons should include their interiors (i.e., -// if a point is contained by a polygon, should the distance be zero or should -// it be measured to the polygon boundary?) -// -// The input geometries may consist of any number of points, polylines, and -// polygons (collectively referred to as "shapes"). Shapes do not need to be -// disjoint; they may overlap or intersect arbitrarily. The implementation is -// designed to be fast for both simple and complex geometries. -type EdgeQuery struct { - index *ShapeIndex - opts *queryOptions - target distanceTarget - - // True if opts.maxError must be subtracted from ShapeIndex cell distances - // in order to ensure that such distances are measured conservatively. This - // is true only if the target takes advantage of maxError in order to - // return faster results, and 0 < maxError < distanceLimit. - useConservativeCellDistance bool - - // The decision about whether to use the brute force algorithm is based on - // counting the total number of edges in the index. However if the index - // contains a large number of shapes, this in itself might take too long. - // So instead we only count edges up to (maxBruteForceIndexSize() + 1) - // for the current target type (stored as indexNumEdgesLimit). - indexNumEdges int - indexNumEdgesLimit int - - // The distance beyond which we can safely ignore further candidate edges. - // (Candidates that are exactly at the limit are ignored; this is more - // efficient for UpdateMinDistance and should not affect clients since - // distance measurements have a small amount of error anyway.) - // - // Initially this is the same as the maximum distance specified by the user, - // but it can also be updated by the algorithm (see maybeAddResult). - distanceLimit distance - - // The current set of results of the query. - results []EdgeQueryResult - - // This field is true when duplicates must be avoided explicitly. This - // is achieved by maintaining a separate set keyed by (shapeID, edgeID) - // only, and checking whether each edge is in that set before computing the - // distance to it. - avoidDuplicates bool - - // testedEdges tracks the set of shape and edges that have already been tested. - testedEdges map[ShapeEdgeID]uint32 - - // For the optimized algorihm we precompute the top-level CellIDs that - // will be added to the priority queue. There can be at most 6 of these - // cells. Essentially this is just a covering of the indexed edges, except - // that we also store pointers to the corresponding ShapeIndexCells to - // reduce the number of index seeks required. - indexCovering []CellID - indexCells []*ShapeIndexCell - - // The algorithm maintains a priority queue of unprocessed CellIDs, sorted - // in increasing order of distance from the target. - queue *queryQueue - - iter *ShapeIndexIterator - maxDistanceCovering []CellID - initialCells []CellID -} - -// NewClosestEdgeQuery returns an EdgeQuery that is used for finding the -// closest edge(s) to a given Point, Edge, Cell, or geometry collection. -// -// You can find either the k closest edges, or all edges within a given -// radius, or both (i.e., the k closest edges up to a given maximum radius). -// E.g. to find all the edges within 5 kilometers, set the DistanceLimit in -// the options. -// -// By default *all* edges are returned, so you should always specify either -// MaxResults or DistanceLimit options or both. -// -// Note that by default, distances are measured to the boundary and interior -// of polygons. For example, if a point is inside a polygon then its distance -// is zero. To change this behavior, set the IncludeInteriors option to false. -// -// If you only need to test whether the distance is above or below a given -// threshold (e.g., 10 km), you can use the IsDistanceLess() method. This is -// much faster than actually calculating the distance with FindEdge, -// since the implementation can stop as soon as it can prove that the minimum -// distance is either above or below the threshold. -func NewClosestEdgeQuery(index *ShapeIndex, opts *EdgeQueryOptions) *EdgeQuery { - if opts == nil { - opts = NewClosestEdgeQueryOptions() - } - e := &EdgeQuery{ - testedEdges: make(map[ShapeEdgeID]uint32), - index: index, - opts: opts.common, - queue: newQueryQueue(), - } - - return e -} - -// NewFurthestEdgeQuery returns an EdgeQuery that is used for finding the -// furthest edge(s) to a given Point, Edge, Cell, or geometry collection. -// -// The furthest edge is defined as the one which maximizes the -// distance from any point on that edge to any point on the target geometry. -// -// Similar to the example in NewClosestEdgeQuery, to find the 5 furthest edges -// from a given Point: -func NewFurthestEdgeQuery(index *ShapeIndex, opts *EdgeQueryOptions) *EdgeQuery { - if opts == nil { - opts = NewFurthestEdgeQueryOptions() - } - e := &EdgeQuery{ - testedEdges: make(map[ShapeEdgeID]uint32), - index: index, - opts: opts.common, - queue: newQueryQueue(), - } - - return e -} - -// Reset resets the state of this EdgeQuery. -func (e *EdgeQuery) Reset() { - e.indexNumEdges = 0 - e.indexNumEdgesLimit = 0 - e.indexCovering = nil - e.indexCells = nil -} - -// FindEdges returns the edges for the given target that satisfy the current options. -// -// Note that if opts.IncludeInteriors is true, the results may include some -// entries with edge_id == -1. This indicates that the target intersects -// the indexed polygon with the given ShapeID. -func (e *EdgeQuery) FindEdges(target distanceTarget) []EdgeQueryResult { - return e.findEdges(target, e.opts) -} - -// Distance reports the distance to the target. If the index or target is empty, -// returns the EdgeQuery's maximal sentinel. -// -// Use IsDistanceLess()/IsDistanceGreater() if you only want to compare the -// distance against a threshold value, since it is often much faster. -func (e *EdgeQuery) Distance(target distanceTarget) s1.ChordAngle { - return e.findEdge(target, e.opts).Distance() -} - -// IsDistanceLess reports if the distance to target is less than the given limit. -// -// This method is usually much faster than Distance(), since it is much -// less work to determine whether the minimum distance is above or below a -// threshold than it is to calculate the actual minimum distance. -// -// If you wish to check if the distance is less than or equal to the limit, use: -// -// query.IsDistanceLess(target, limit.Successor()) -// -func (e *EdgeQuery) IsDistanceLess(target distanceTarget, limit s1.ChordAngle) bool { - opts := e.opts - opts = opts.MaxResults(1). - DistanceLimit(limit). - MaxError(s1.StraightChordAngle) - return !e.findEdge(target, opts).IsEmpty() -} - -// IsDistanceGreater reports if the distance to target is greater than limit. -// -// This method is usually much faster than Distance, since it is much -// less work to determine whether the maximum distance is above or below a -// threshold than it is to calculate the actual maximum distance. -// If you wish to check if the distance is less than or equal to the limit, use: -// -// query.IsDistanceGreater(target, limit.Predecessor()) -// -func (e *EdgeQuery) IsDistanceGreater(target distanceTarget, limit s1.ChordAngle) bool { - return e.IsDistanceLess(target, limit) -} - -// IsConservativeDistanceLessOrEqual reports if the distance to target is less -// or equal to the limit, where the limit has been expanded by the maximum error -// for the distance calculation. -// -// For example, suppose that we want to test whether two geometries might -// intersect each other after they are snapped together using Builder -// (using the IdentitySnapFunction with a given "snap radius"). Since -// Builder uses exact distance predicates (s2predicates), we need to -// measure the distance between the two geometries conservatively. If the -// distance is definitely greater than "snap radius", then the geometries -// are guaranteed to not intersect after snapping. -func (e *EdgeQuery) IsConservativeDistanceLessOrEqual(target distanceTarget, limit s1.ChordAngle) bool { - return e.IsDistanceLess(target, limit.Expanded(minUpdateDistanceMaxError(limit))) -} - -// IsConservativeDistanceGreaterOrEqual reports if the distance to the target is greater -// than or equal to the given limit with some small tolerance. -func (e *EdgeQuery) IsConservativeDistanceGreaterOrEqual(target distanceTarget, limit s1.ChordAngle) bool { - return e.IsDistanceGreater(target, limit.Expanded(-minUpdateDistanceMaxError(limit))) -} - -// findEdges returns the closest edges to the given target that satisfy the given options. -// -// Note that if opts.includeInteriors is true, the results may include some -// entries with edgeID == -1. This indicates that the target intersects the -// indexed polygon with the given shapeID. -func (e *EdgeQuery) findEdges(target distanceTarget, opts *queryOptions) []EdgeQueryResult { - e.findEdgesInternal(target, opts) - // TODO(roberts): Revisit this if there is a heap or other sorted and - // uniquing datastructure we can use instead of just a slice. - e.results = sortAndUniqueResults(e.results) - if len(e.results) > e.opts.maxResults { - e.results = e.results[:e.opts.maxResults] - } - return e.results -} - -func sortAndUniqueResults(results []EdgeQueryResult) []EdgeQueryResult { - if len(results) <= 1 { - return results - } - sort.Slice(results, func(i, j int) bool { return results[i].Less(results[j]) }) - j := 0 - for i := 1; i < len(results); i++ { - if results[j] == results[i] { - continue - } - j++ - results[j] = results[i] - } - return results[:j+1] -} - -// findEdge is a convenience method that returns exactly one edge, and if no -// edges satisfy the given search criteria, then a default Result is returned. -// -// This is primarily to ease the usage of a number of the methods in the DistanceTargets -// and in EdgeQuery. -func (e *EdgeQuery) findEdge(target distanceTarget, opts *queryOptions) EdgeQueryResult { - opts.MaxResults(1) - e.findEdges(target, opts) - if len(e.results) > 0 { - return e.results[0] - } - - return newEdgeQueryResult(target) -} - -// findEdgesInternal does the actual work for find edges that match the given options. -func (e *EdgeQuery) findEdgesInternal(target distanceTarget, opts *queryOptions) { - e.target = target - e.opts = opts - - e.testedEdges = make(map[ShapeEdgeID]uint32) - e.distanceLimit = target.distance().fromChordAngle(opts.distanceLimit) - e.results = make([]EdgeQueryResult, 0) - - if e.distanceLimit == target.distance().zero() { - return - } - - if opts.includeInteriors { - shapeIDs := map[int32]struct{}{} - e.target.visitContainingShapes(e.index, func(containingShape Shape, targetPoint Point) bool { - shapeIDs[e.index.idForShape(containingShape)] = struct{}{} - return len(shapeIDs) < opts.maxResults - }) - for shapeID := range shapeIDs { - e.addResult(EdgeQueryResult{target.distance().zero(), shapeID, -1}) - } - - if e.distanceLimit == target.distance().zero() { - return - } - } - - // If maxError > 0 and the target takes advantage of this, then we may - // need to adjust the distance estimates to ShapeIndex cells to ensure - // that they are always a lower bound on the true distance. For example, - // suppose max_distance == 100, maxError == 30, and we compute the distance - // to the target from some cell C0 as d(C0) == 80. Then because the target - // takes advantage of maxError, the true distance could be as low as 50. - // In order not to miss edges contained by such cells, we need to subtract - // maxError from the distance estimates. This behavior is controlled by - // the useConservativeCellDistance flag. - // - // However there is one important case where this adjustment is not - // necessary, namely when distanceLimit < maxError, This is because - // maxError only affects the algorithm once at least maxEdges edges - // have been found that satisfy the given distance limit. At that point, - // maxError is subtracted from distanceLimit in order to ensure that - // any further matches are closer by at least that amount. But when - // distanceLimit < maxError, this reduces the distance limit to 0, - // i.e. all remaining candidate cells and edges can safely be discarded. - // (This is how IsDistanceLess() and friends are implemented.) - targetUsesMaxError := opts.maxError != target.distance().zero().chordAngle() && - e.target.setMaxError(opts.maxError) - - // Note that we can't compare maxError and distanceLimit directly - // because one is a Delta and one is a Distance. Instead we subtract them. - e.useConservativeCellDistance = targetUsesMaxError && - (e.distanceLimit == target.distance().infinity() || - target.distance().zero().less(e.distanceLimit.sub(target.distance().fromChordAngle(opts.maxError)))) - - // Use the brute force algorithm if the index is small enough. To avoid - // spending too much time counting edges when there are many shapes, we stop - // counting once there are too many edges. We may need to recount the edges - // if we later see a target with a larger brute force edge threshold. - minOptimizedEdges := e.target.maxBruteForceIndexSize() + 1 - if minOptimizedEdges > e.indexNumEdgesLimit && e.indexNumEdges >= e.indexNumEdgesLimit { - e.indexNumEdges = e.index.NumEdgesUpTo(minOptimizedEdges) - e.indexNumEdgesLimit = minOptimizedEdges - } - - if opts.useBruteForce || e.indexNumEdges < minOptimizedEdges { - // The brute force algorithm already considers each edge exactly once. - e.avoidDuplicates = false - e.findEdgesBruteForce() - } else { - // If the target takes advantage of maxError then we need to avoid - // duplicate edges explicitly. (Otherwise it happens automatically.) - e.avoidDuplicates = targetUsesMaxError && opts.maxResults > 1 - e.findEdgesOptimized() - } -} - -func (e *EdgeQuery) addResult(r EdgeQueryResult) { - e.results = append(e.results, r) - if e.opts.maxResults == 1 { - // Optimization for the common case where only the closest edge is wanted. - e.distanceLimit = r.distance.sub(e.target.distance().fromChordAngle(e.opts.maxError)) - } - // TODO(roberts): Add the other if/else cases when a different data structure - // is used for the results. -} - -func (e *EdgeQuery) maybeAddResult(shape Shape, edgeID int32) { - if _, ok := e.testedEdges[ShapeEdgeID{e.index.idForShape(shape), edgeID}]; e.avoidDuplicates && !ok { - return - } - edge := shape.Edge(int(edgeID)) - dist := e.distanceLimit - - if dist, ok := e.target.updateDistanceToEdge(edge, dist); ok { - e.addResult(EdgeQueryResult{dist, e.index.idForShape(shape), edgeID}) - } -} - -func (e *EdgeQuery) findEdgesBruteForce() { - // Range over all shapes in the index. Does order matter here? if so - // switch to for i = 0 .. n? - for _, shape := range e.index.shapes { - // TODO(roberts): can this happen if we are only ranging over current entries? - if shape == nil { - continue - } - for edgeID := int32(0); edgeID < int32(shape.NumEdges()); edgeID++ { - e.maybeAddResult(shape, edgeID) - } - } -} - -func (e *EdgeQuery) findEdgesOptimized() { - e.initQueue() - // Repeatedly find the closest Cell to "target" and either split it into - // its four children or process all of its edges. - for e.queue.size() > 0 { - // We need to copy the top entry before removing it, and we need to - // remove it before adding any new entries to the queue. - entry := e.queue.pop() - - if !entry.distance.less(e.distanceLimit) { - e.queue.reset() // Clear any remaining entries. - break - } - // If this is already known to be an index cell, just process it. - if entry.indexCell != nil { - e.processEdges(entry) - continue - } - // Otherwise split the cell into its four children. Before adding a - // child back to the queue, we first check whether it is empty. We do - // this in two seek operations rather than four by seeking to the key - // between children 0 and 1 and to the key between children 2 and 3. - id := entry.id - ch := id.Children() - e.iter.seek(ch[1].RangeMin()) - - if !e.iter.Done() && e.iter.CellID() <= ch[1].RangeMax() { - e.processOrEnqueueCell(ch[1]) - } - if e.iter.Prev() && e.iter.CellID() >= id.RangeMin() { - e.processOrEnqueueCell(ch[0]) - } - - e.iter.seek(ch[3].RangeMin()) - if !e.iter.Done() && e.iter.CellID() <= id.RangeMax() { - e.processOrEnqueueCell(ch[3]) - } - if e.iter.Prev() && e.iter.CellID() >= ch[2].RangeMin() { - e.processOrEnqueueCell(ch[2]) - } - } -} - -func (e *EdgeQuery) processOrEnqueueCell(id CellID) { - if e.iter.CellID() == id { - e.processOrEnqueue(id, e.iter.IndexCell()) - } else { - e.processOrEnqueue(id, nil) - } -} - -func (e *EdgeQuery) initQueue() { - if len(e.indexCovering) == 0 { - // We delay iterator initialization until now to make queries on very - // small indexes a bit faster (i.e., where brute force is used). - e.iter = NewShapeIndexIterator(e.index) - } - - // Optimization: if the user is searching for just the closest edge, and the - // center of the target's bounding cap happens to intersect an index cell, - // then we try to limit the search region to a small disc by first - // processing the edges in that cell. This sets distance_limit_ based on - // the closest edge in that cell, which we can then use to limit the search - // area. This means that the cell containing "target" will be processed - // twice, but in general this is still faster. - // - // TODO(roberts): Even if the cap center is not contained, we could still - // process one or both of the adjacent index cells in CellID order, - // provided that those cells are closer than distanceLimit. - cb := e.target.capBound() - if cb.IsEmpty() { - return // Empty target. - } - - if e.opts.maxResults == 1 && e.iter.LocatePoint(cb.Center()) { - e.processEdges(&queryQueueEntry{ - distance: e.target.distance().zero(), - id: e.iter.CellID(), - indexCell: e.iter.IndexCell(), - }) - // Skip the rest of the algorithm if we found an intersecting edge. - if e.distanceLimit == e.target.distance().zero() { - return - } - } - if len(e.indexCovering) == 0 { - e.initCovering() - } - if e.distanceLimit == e.target.distance().infinity() { - // Start with the precomputed index covering. - for i := range e.indexCovering { - e.processOrEnqueue(e.indexCovering[i], e.indexCells[i]) - } - } else { - // Compute a covering of the search disc and intersect it with the - // precomputed index covering. - coverer := &RegionCoverer{MaxCells: 4, LevelMod: 1, MaxLevel: maxLevel} - - radius := cb.Radius() + e.distanceLimit.chordAngleBound().Angle() - searchCB := CapFromCenterAngle(cb.Center(), radius) - maxDistCover := coverer.FastCovering(searchCB) - e.initialCells = CellUnionFromIntersection(e.indexCovering, maxDistCover) - - // Now we need to clean up the initial cells to ensure that they all - // contain at least one cell of the ShapeIndex. (Some may not intersect - // the index at all, while other may be descendants of an index cell.) - i, j := 0, 0 - for i < len(e.initialCells) { - idI := e.initialCells[i] - // Find the top-level cell that contains this initial cell. - for e.indexCovering[j].RangeMax() < idI { - j++ - } - - idJ := e.indexCovering[j] - if idI == idJ { - // This initial cell is one of the top-level cells. Use the - // precomputed ShapeIndexCell pointer to avoid an index seek. - e.processOrEnqueue(idJ, e.indexCells[j]) - i++ - j++ - } else { - // This initial cell is a proper descendant of a top-level cell. - // Check how it is related to the cells of the ShapeIndex. - r := e.iter.LocateCellID(idI) - if r == Indexed { - // This cell is a descendant of an index cell. - // Enqueue it and skip any other initial cells - // that are also descendants of this cell. - e.processOrEnqueue(e.iter.CellID(), e.iter.IndexCell()) - lastID := e.iter.CellID().RangeMax() - for i < len(e.initialCells) && e.initialCells[i] <= lastID { - i++ - } - } else { - // Enqueue the cell only if it contains at least one index cell. - if r == Subdivided { - e.processOrEnqueue(idI, nil) - } - i++ - } - } - } - } -} - -func (e *EdgeQuery) initCovering() { - // Find the range of Cells spanned by the index and choose a level such - // that the entire index can be covered with just a few cells. These are - // the "top-level" cells. There are two cases: - // - // - If the index spans more than one face, then there is one top-level cell - // per spanned face, just big enough to cover the index cells on that face. - // - // - If the index spans only one face, then we find the smallest cell "C" - // that covers the index cells on that face (just like the case above). - // Then for each of the 4 children of "C", if the child contains any index - // cells then we create a top-level cell that is big enough to just fit - // those index cells (i.e., shrinking the child as much as possible to fit - // its contents). This essentially replicates what would happen if we - // started with "C" as the top-level cell, since "C" would immediately be - // split, except that we take the time to prune the children further since - // this will save work on every subsequent query. - e.indexCovering = make([]CellID, 0, 6) - - // TODO(roberts): Use a single iterator below and save position - // information using pair {CellID, ShapeIndexCell}. - next := NewShapeIndexIterator(e.index, IteratorBegin) - last := NewShapeIndexIterator(e.index, IteratorEnd) - last.Prev() - if next.CellID() != last.CellID() { - // The index has at least two cells. Choose a level such that the entire - // index can be spanned with at most 6 cells (if the index spans multiple - // faces) or 4 cells (it the index spans a single face). - level, ok := next.CellID().CommonAncestorLevel(last.CellID()) - if !ok { - level = 0 - } else { - level++ - } - - // Visit each potential top-level cell except the last (handled below). - lastID := last.CellID().Parent(level) - for id := next.CellID().Parent(level); id != lastID; id = id.Next() { - // Skip any top-level cells that don't contain any index cells. - if id.RangeMax() < next.CellID() { - continue - } - - // Find the range of index cells contained by this top-level cell and - // then shrink the cell if necessary so that it just covers them. - cellFirst := next.clone() - next.seek(id.RangeMax().Next()) - cellLast := next.clone() - cellLast.Prev() - e.addInitialRange(cellFirst, cellLast) - break - } - - } - e.addInitialRange(next, last) -} - -// addInitialRange adds an entry to the indexCovering and indexCells that covers the given -// inclusive range of cells. -// -// This requires that first and last cells have a common ancestor. -func (e *EdgeQuery) addInitialRange(first, last *ShapeIndexIterator) { - if first.CellID() == last.CellID() { - // The range consists of a single index cell. - e.indexCovering = append(e.indexCovering, first.CellID()) - e.indexCells = append(e.indexCells, first.IndexCell()) - } else { - // Add the lowest common ancestor of the given range. - level, _ := first.CellID().CommonAncestorLevel(last.CellID()) - e.indexCovering = append(e.indexCovering, first.CellID().Parent(level)) - e.indexCells = append(e.indexCells, nil) - } -} - -// processEdges processes all the edges of the given index cell. -func (e *EdgeQuery) processEdges(entry *queryQueueEntry) { - for _, clipped := range entry.indexCell.shapes { - shape := e.index.Shape(clipped.shapeID) - for j := 0; j < clipped.numEdges(); j++ { - e.maybeAddResult(shape, int32(clipped.edges[j])) - } - } -} - -// processOrEnqueue the given cell id and indexCell. -func (e *EdgeQuery) processOrEnqueue(id CellID, indexCell *ShapeIndexCell) { - if indexCell != nil { - // If this index cell has only a few edges, then it is faster to check - // them directly rather than computing the minimum distance to the Cell - // and inserting it into the queue. - const minEdgesToEnqueue = 10 - numEdges := indexCell.numEdges() - if numEdges == 0 { - return - } - if numEdges < minEdgesToEnqueue { - // Set "distance" to zero to avoid the expense of computing it. - e.processEdges(&queryQueueEntry{ - distance: e.target.distance().zero(), - id: id, - indexCell: indexCell, - }) - return - } - } - - // Otherwise compute the minimum distance to any point in the cell and add - // it to the priority queue. - cell := CellFromCellID(id) - dist := e.distanceLimit - var ok bool - if dist, ok = e.target.updateDistanceToCell(cell, dist); !ok { - return - } - if e.useConservativeCellDistance { - // Ensure that "distance" is a lower bound on the true distance to the cell. - dist = dist.sub(e.target.distance().fromChordAngle(e.opts.maxError)) - } - - e.queue.push(&queryQueueEntry{ - distance: dist, - id: id, - indexCell: indexCell, - }) -} - -// TODO(roberts): Remaining pieces -// GetEdge -// Project diff --git a/vendor/github.com/golang/geo/s2/edge_tessellator.go b/vendor/github.com/golang/geo/s2/edge_tessellator.go deleted file mode 100644 index 1d5805c26..000000000 --- a/vendor/github.com/golang/geo/s2/edge_tessellator.go +++ /dev/null @@ -1,291 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "github.com/golang/geo/r2" - "github.com/golang/geo/s1" -) - -// Tessellation is implemented by subdividing the edge until the estimated -// maximum error is below the given tolerance. Estimating error is a hard -// problem, especially when the only methods available are point evaluation of -// the projection and its inverse. (These are the only methods that -// Projection provides, which makes it easier and less error-prone to -// implement new projections.) -// -// One technique that significantly increases robustness is to treat the -// geodesic and projected edges as parametric curves rather than geometric ones. -// Given a spherical edge AB and a projection p:S2->R2, let f(t) be the -// normalized arc length parametrization of AB and let g(t) be the normalized -// arc length parameterization of the projected edge p(A)p(B). (In other words, -// f(0)=A, f(1)=B, g(0)=p(A), g(1)=p(B).) We now define the geometric error as -// the maximum distance from the point p^-1(g(t)) to the geodesic edge AB for -// any t in [0,1], where p^-1 denotes the inverse projection. In other words, -// the geometric error is the maximum distance from any point on the projected -// edge (mapped back onto the sphere) to the geodesic edge AB. On the other -// hand we define the parametric error as the maximum distance between the -// points f(t) and p^-1(g(t)) for any t in [0,1], i.e. the maximum distance -// (measured on the sphere) between the geodesic and projected points at the -// same interpolation fraction t. -// -// The easiest way to estimate the parametric error is to simply evaluate both -// edges at their midpoints and measure the distance between them (the "midpoint -// method"). This is very fast and works quite well for most edges, however it -// has one major drawback: it doesn't handle points of inflection (i.e., points -// where the curvature changes sign). For example, edges in the Mercator and -// Plate Carree projections always curve towards the equator relative to the -// corresponding geodesic edge, so in these projections there is a point of -// inflection whenever the projected edge crosses the equator. The worst case -// occurs when the edge endpoints have different longitudes but the same -// absolute latitude, since in that case the error is non-zero but the edges -// have exactly the same midpoint (on the equator). -// -// One solution to this problem is to split the input edges at all inflection -// points (i.e., along the equator in the case of the Mercator and Plate Carree -// projections). However for general projections these inflection points can -// occur anywhere on the sphere (e.g., consider the Transverse Mercator -// projection). This could be addressed by adding methods to the S2Projection -// interface to split edges at inflection points but this would make it harder -// and more error-prone to implement new projections. -// -// Another problem with this approach is that the midpoint method sometimes -// underestimates the true error even when edges do not cross the equator. -// For the Plate Carree and Mercator projections, the midpoint method can -// underestimate the error by up to 3%. -// -// Both of these problems can be solved as follows. We assume that the error -// can be modeled as a convex combination of two worst-case functions, one -// where the error is maximized at the edge midpoint and another where the -// error is *minimized* (i.e., zero) at the edge midpoint. For example, we -// could choose these functions as: -// -// E1(x) = 1 - x^2 -// E2(x) = x * (1 - x^2) -// -// where for convenience we use an interpolation parameter "x" in the range -// [-1, 1] rather than the original "t" in the range [0, 1]. Note that both -// error functions must have roots at x = {-1, 1} since the error must be zero -// at the edge endpoints. E1 is simply a parabola whose maximum value is 1 -// attained at x = 0, while E2 is a cubic with an additional root at x = 0, -// and whose maximum value is 2 * sqrt(3) / 9 attained at x = 1 / sqrt(3). -// -// Next, it is convenient to scale these functions so that the both have a -// maximum value of 1. E1 already satisfies this requirement, and we simply -// redefine E2 as -// -// E2(x) = x * (1 - x^2) / (2 * sqrt(3) / 9) -// -// Now define x0 to be the point where these two functions intersect, i.e. the -// point in the range (-1, 1) where E1(x0) = E2(x0). This value has the very -// convenient property that if we evaluate the actual error E(x0), then the -// maximum error on the entire interval [-1, 1] is bounded by -// -// E(x) <= E(x0) / E1(x0) -// -// since whether the error is modeled using E1 or E2, the resulting function -// has the same maximum value (namely E(x0) / E1(x0)). If it is modeled as -// some other convex combination of E1 and E2, the maximum value can only -// decrease. -// -// Finally, since E2 is not symmetric about the y-axis, we must also allow for -// the possibility that the error is a convex combination of E1 and -E2. This -// can be handled by evaluating the error at E(-x0) as well, and then -// computing the final error bound as -// -// E(x) <= max(E(x0), E(-x0)) / E1(x0) . -// -// Effectively, this method is simply evaluating the error at two points about -// 1/3 and 2/3 of the way along the edges, and then scaling the maximum of -// these two errors by a constant factor. Intuitively, the reason this works -// is that if the two edges cross somewhere in the interior, then at least one -// of these points will be far from the crossing. -// -// The actual algorithm implemented below has some additional refinements. -// First, edges longer than 90 degrees are always subdivided; this avoids -// various unusual situations that can happen with very long edges, and there -// is really no reason to avoid adding vertices to edges that are so long. -// -// Second, the error function E1 above needs to be modified to take into -// account spherical distortions. (It turns out that spherical distortions are -// beneficial in the case of E2, i.e. they only make its error estimates -// slightly more conservative.) To do this, we model E1 as the maximum error -// in a Plate Carree edge of length 90 degrees or less. This turns out to be -// an edge from 45:-90 to 45:90 (in lat:lng format). The corresponding error -// as a function of "x" in the range [-1, 1] can be computed as the distance -// between the Plate Caree edge point (45, 90 * x) and the geodesic -// edge point (90 - 45 * abs(x), 90 * sgn(x)). Using the Haversine formula, -// the corresponding function E1 (normalized to have a maximum value of 1) is: -// -// E1(x) = -// asin(sqrt(sin(Pi / 8 * (1 - x)) ^ 2 + -// sin(Pi / 4 * (1 - x)) ^ 2 * cos(Pi / 4) * sin(Pi / 4 * x))) / -// asin(sqrt((1 - 1 / sqrt(2)) / 2)) -// -// Note that this function does not need to be evaluated at runtime, it -// simply affects the calculation of the value x0 where E1(x0) = E2(x0) -// and the corresponding scaling factor C = 1 / E1(x0). -// -// ------------------------------------------------------------------ -// -// In the case of the Mercator and Plate Carree projections this strategy -// produces a conservative upper bound (verified using 10 million random -// edges). Furthermore the bound is nearly tight; the scaling constant is -// C = 1.19289, whereas the maximum observed value was 1.19254. -// -// Compared to the simpler midpoint evaluation method, this strategy requires -// more function evaluations (currently twice as many, but with a smarter -// tessellation algorithm it will only be 50% more). It also results in a -// small amount of additional tessellation (about 1.5%) compared to the -// midpoint method, but this is due almost entirely to the fact that the -// midpoint method does not yield conservative error estimates. -// -// For random edges with a tolerance of 1 meter, the expected amount of -// overtessellation is as follows: -// -// Midpoint Method Cubic Method -// Plate Carree 1.8% 3.0% -// Mercator 15.8% 17.4% - -const ( - // tessellationInterpolationFraction is the fraction at which the two edges - // are evaluated in order to measure the error between them. (Edges are - // evaluated at two points measured this fraction from either end.) - tessellationInterpolationFraction = 0.31215691082248312 - tessellationScaleFactor = 0.83829992569888509 - - // minTessellationTolerance is the minimum supported tolerance (which - // corresponds to a distance less than 1 micrometer on the Earth's - // surface, but is still much larger than the expected projection and - // interpolation errors). - minTessellationTolerance s1.Angle = 1e-13 -) - -// EdgeTessellator converts an edge in a given projection (e.g., Mercator) into -// a chain of spherical geodesic edges such that the maximum distance between -// the original edge and the geodesic edge chain is at most the requested -// tolerance. Similarly, it can convert a spherical geodesic edge into a chain -// of edges in a given 2D projection such that the maximum distance between the -// geodesic edge and the chain of projected edges is at most the requested tolerance. -// -// Method | Input | Output -// ------------|------------------------|----------------------- -// Projected | S2 geodesics | Planar projected edges -// Unprojected | Planar projected edges | S2 geodesics -type EdgeTessellator struct { - projection Projection - - // The given tolerance scaled by a constant fraction so that it can be - // compared against the result returned by estimateMaxError. - scaledTolerance s1.ChordAngle -} - -// NewEdgeTessellator creates a new edge tessellator for the given projection and tolerance. -func NewEdgeTessellator(p Projection, tolerance s1.Angle) *EdgeTessellator { - return &EdgeTessellator{ - projection: p, - scaledTolerance: s1.ChordAngleFromAngle(maxAngle(tolerance, minTessellationTolerance)), - } -} - -// AppendProjected converts the spherical geodesic edge AB to a chain of planar edges -// in the given projection and returns the corresponding vertices. -// -// If the given projection has one or more coordinate axes that wrap, then -// every vertex's coordinates will be as close as possible to the previous -// vertex's coordinates. Note that this may yield vertices whose -// coordinates are outside the usual range. For example, tessellating the -// edge (0:170, 0:-170) (in lat:lng notation) yields (0:170, 0:190). -func (e *EdgeTessellator) AppendProjected(a, b Point, vertices []r2.Point) []r2.Point { - pa := e.projection.Project(a) - if len(vertices) == 0 { - vertices = []r2.Point{pa} - } else { - pa = e.projection.WrapDestination(vertices[len(vertices)-1], pa) - } - - pb := e.projection.Project(b) - return e.appendProjected(pa, a, pb, b, vertices) -} - -// appendProjected splits a geodesic edge AB as necessary and returns the -// projected vertices appended to the given vertices. -// -// The maximum recursion depth is (math.Pi / minTessellationTolerance) < 45 -func (e *EdgeTessellator) appendProjected(pa r2.Point, a Point, pbIn r2.Point, b Point, vertices []r2.Point) []r2.Point { - pb := e.projection.WrapDestination(pa, pbIn) - if e.estimateMaxError(pa, a, pb, b) <= e.scaledTolerance { - return append(vertices, pb) - } - - mid := Point{a.Add(b.Vector).Normalize()} - pmid := e.projection.WrapDestination(pa, e.projection.Project(mid)) - vertices = e.appendProjected(pa, a, pmid, mid, vertices) - return e.appendProjected(pmid, mid, pb, b, vertices) -} - -// AppendUnprojected converts the planar edge AB in the given projection to a chain of -// spherical geodesic edges and returns the vertices. -// -// Note that to construct a Loop, you must eliminate the duplicate first and last -// vertex. Note also that if the given projection involves coordinate wrapping -// (e.g. across the 180 degree meridian) then the first and last vertices may not -// be exactly the same. -func (e *EdgeTessellator) AppendUnprojected(pa, pb r2.Point, vertices []Point) []Point { - a := e.projection.Unproject(pa) - b := e.projection.Unproject(pb) - - if len(vertices) == 0 { - vertices = []Point{a} - } - - // Note that coordinate wrapping can create a small amount of error. For - // example in the edge chain "0:-175, 0:179, 0:-177", the first edge is - // transformed into "0:-175, 0:-181" while the second is transformed into - // "0:179, 0:183". The two coordinate pairs for the middle vertex - // ("0:-181" and "0:179") may not yield exactly the same S2Point. - return e.appendUnprojected(pa, a, pb, b, vertices) -} - -// appendUnprojected interpolates a projected edge and appends the corresponding -// points on the sphere. -func (e *EdgeTessellator) appendUnprojected(pa r2.Point, a Point, pbIn r2.Point, b Point, vertices []Point) []Point { - pb := e.projection.WrapDestination(pa, pbIn) - if e.estimateMaxError(pa, a, pb, b) <= e.scaledTolerance { - return append(vertices, b) - } - - pmid := e.projection.Interpolate(0.5, pa, pb) - mid := e.projection.Unproject(pmid) - - vertices = e.appendUnprojected(pa, a, pmid, mid, vertices) - return e.appendUnprojected(pmid, mid, pb, b, vertices) -} - -func (e *EdgeTessellator) estimateMaxError(pa r2.Point, a Point, pb r2.Point, b Point) s1.ChordAngle { - // See the algorithm description at the top of this file. - // We always tessellate edges longer than 90 degrees on the sphere, since the - // approximation below is not robust enough to handle such edges. - if a.Dot(b.Vector) < -1e-14 { - return s1.InfChordAngle() - } - t1 := tessellationInterpolationFraction - t2 := 1 - tessellationInterpolationFraction - mid1 := Interpolate(t1, a, b) - mid2 := Interpolate(t2, a, b) - pmid1 := e.projection.Unproject(e.projection.Interpolate(t1, pa, pb)) - pmid2 := e.projection.Unproject(e.projection.Interpolate(t2, pa, pb)) - return maxChordAngle(ChordAngleBetweenPoints(mid1, pmid1), ChordAngleBetweenPoints(mid2, pmid2)) -} diff --git a/vendor/github.com/golang/geo/s2/encode.go b/vendor/github.com/golang/geo/s2/encode.go deleted file mode 100644 index 00d0adc71..000000000 --- a/vendor/github.com/golang/geo/s2/encode.go +++ /dev/null @@ -1,224 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "encoding/binary" - "io" - "math" -) - -const ( - // encodingVersion is the current version of the encoding - // format that is compatible with C++ and other S2 libraries. - encodingVersion = int8(1) - - // encodingCompressedVersion is the current version of the - // compressed format. - encodingCompressedVersion = int8(4) -) - -// encoder handles the specifics of encoding for S2 types. -type encoder struct { - w io.Writer // the real writer passed to Encode - err error -} - -func (e *encoder) writeUvarint(x uint64) { - if e.err != nil { - return - } - var buf [binary.MaxVarintLen64]byte - n := binary.PutUvarint(buf[:], x) - _, e.err = e.w.Write(buf[:n]) -} - -func (e *encoder) writeBool(x bool) { - if e.err != nil { - return - } - var val int8 - if x { - val = 1 - } - e.err = binary.Write(e.w, binary.LittleEndian, val) -} - -func (e *encoder) writeInt8(x int8) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeInt16(x int16) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeInt32(x int32) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeInt64(x int64) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeUint8(x uint8) { - if e.err != nil { - return - } - _, e.err = e.w.Write([]byte{x}) -} - -func (e *encoder) writeUint32(x uint32) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeUint64(x uint64) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeFloat32(x float32) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -func (e *encoder) writeFloat64(x float64) { - if e.err != nil { - return - } - e.err = binary.Write(e.w, binary.LittleEndian, x) -} - -type byteReader interface { - io.Reader - io.ByteReader -} - -// byteReaderAdapter embellishes an io.Reader with a ReadByte method, -// so that it implements the io.ByteReader interface. -type byteReaderAdapter struct { - io.Reader -} - -func (b byteReaderAdapter) ReadByte() (byte, error) { - buf := []byte{0} - _, err := io.ReadFull(b, buf) - return buf[0], err -} - -func asByteReader(r io.Reader) byteReader { - if br, ok := r.(byteReader); ok { - return br - } - return byteReaderAdapter{r} -} - -type decoder struct { - r byteReader // the real reader passed to Decode - err error - buf []byte -} - -// Get a buffer of size 8, to avoid allocating over and over. -func (d *decoder) buffer() []byte { - if d.buf == nil { - d.buf = make([]byte, 8) - } - return d.buf -} - -func (d *decoder) readBool() (x bool) { - if d.err != nil { - return - } - var val int8 - d.err = binary.Read(d.r, binary.LittleEndian, &val) - return val == 1 -} - -func (d *decoder) readInt8() (x int8) { - if d.err != nil { - return - } - d.err = binary.Read(d.r, binary.LittleEndian, &x) - return -} - -func (d *decoder) readInt64() (x int64) { - if d.err != nil { - return - } - d.err = binary.Read(d.r, binary.LittleEndian, &x) - return -} - -func (d *decoder) readUint8() (x uint8) { - if d.err != nil { - return - } - x, d.err = d.r.ReadByte() - return -} - -func (d *decoder) readUint32() (x uint32) { - if d.err != nil { - return - } - d.err = binary.Read(d.r, binary.LittleEndian, &x) - return -} - -func (d *decoder) readUint64() (x uint64) { - if d.err != nil { - return - } - d.err = binary.Read(d.r, binary.LittleEndian, &x) - return -} - -func (d *decoder) readFloat64() float64 { - if d.err != nil { - return 0 - } - buf := d.buffer() - _, d.err = io.ReadFull(d.r, buf) - return math.Float64frombits(binary.LittleEndian.Uint64(buf)) -} - -func (d *decoder) readUvarint() (x uint64) { - if d.err != nil { - return - } - x, d.err = binary.ReadUvarint(d.r) - return -} diff --git a/vendor/github.com/golang/geo/s2/interleave.go b/vendor/github.com/golang/geo/s2/interleave.go deleted file mode 100644 index 6ac6ef58d..000000000 --- a/vendor/github.com/golang/geo/s2/interleave.go +++ /dev/null @@ -1,143 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -/* -The lookup table below can convert a sequence of interleaved 8 bits into -non-interleaved 4 bits. The table can convert both odd and even bits at the -same time, and lut[x & 0x55] converts the even bits (bits 0, 2, 4 and 6), -while lut[x & 0xaa] converts the odd bits (bits 1, 3, 5 and 7). - -The lookup table below was generated using the following python code: - - def deinterleave(bits): - if bits == 0: return 0 - if bits < 4: return 1 - return deinterleave(bits / 4) * 2 + deinterleave(bits & 3) - - for i in range(256): print "0x%x," % deinterleave(i), -*/ -var deinterleaveLookup = [256]uint32{ - 0x0, 0x1, 0x1, 0x1, 0x2, 0x3, 0x3, 0x3, - 0x2, 0x3, 0x3, 0x3, 0x2, 0x3, 0x3, 0x3, - 0x4, 0x5, 0x5, 0x5, 0x6, 0x7, 0x7, 0x7, - 0x6, 0x7, 0x7, 0x7, 0x6, 0x7, 0x7, 0x7, - 0x4, 0x5, 0x5, 0x5, 0x6, 0x7, 0x7, 0x7, - 0x6, 0x7, 0x7, 0x7, 0x6, 0x7, 0x7, 0x7, - 0x4, 0x5, 0x5, 0x5, 0x6, 0x7, 0x7, 0x7, - 0x6, 0x7, 0x7, 0x7, 0x6, 0x7, 0x7, 0x7, - - 0x8, 0x9, 0x9, 0x9, 0xa, 0xb, 0xb, 0xb, - 0xa, 0xb, 0xb, 0xb, 0xa, 0xb, 0xb, 0xb, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - - 0x8, 0x9, 0x9, 0x9, 0xa, 0xb, 0xb, 0xb, - 0xa, 0xb, 0xb, 0xb, 0xa, 0xb, 0xb, 0xb, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - - 0x8, 0x9, 0x9, 0x9, 0xa, 0xb, 0xb, 0xb, - 0xa, 0xb, 0xb, 0xb, 0xa, 0xb, 0xb, 0xb, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, - 0xc, 0xd, 0xd, 0xd, 0xe, 0xf, 0xf, 0xf, - 0xe, 0xf, 0xf, 0xf, 0xe, 0xf, 0xf, 0xf, -} - -// deinterleaveUint32 decodes the interleaved values. -func deinterleaveUint32(code uint64) (uint32, uint32) { - x := (deinterleaveLookup[code&0x55]) | - (deinterleaveLookup[(code>>8)&0x55] << 4) | - (deinterleaveLookup[(code>>16)&0x55] << 8) | - (deinterleaveLookup[(code>>24)&0x55] << 12) | - (deinterleaveLookup[(code>>32)&0x55] << 16) | - (deinterleaveLookup[(code>>40)&0x55] << 20) | - (deinterleaveLookup[(code>>48)&0x55] << 24) | - (deinterleaveLookup[(code>>56)&0x55] << 28) - y := (deinterleaveLookup[code&0xaa]) | - (deinterleaveLookup[(code>>8)&0xaa] << 4) | - (deinterleaveLookup[(code>>16)&0xaa] << 8) | - (deinterleaveLookup[(code>>24)&0xaa] << 12) | - (deinterleaveLookup[(code>>32)&0xaa] << 16) | - (deinterleaveLookup[(code>>40)&0xaa] << 20) | - (deinterleaveLookup[(code>>48)&0xaa] << 24) | - (deinterleaveLookup[(code>>56)&0xaa] << 28) - return x, y -} - -var interleaveLookup = [256]uint64{ - 0x0000, 0x0001, 0x0004, 0x0005, 0x0010, 0x0011, 0x0014, 0x0015, - 0x0040, 0x0041, 0x0044, 0x0045, 0x0050, 0x0051, 0x0054, 0x0055, - 0x0100, 0x0101, 0x0104, 0x0105, 0x0110, 0x0111, 0x0114, 0x0115, - 0x0140, 0x0141, 0x0144, 0x0145, 0x0150, 0x0151, 0x0154, 0x0155, - 0x0400, 0x0401, 0x0404, 0x0405, 0x0410, 0x0411, 0x0414, 0x0415, - 0x0440, 0x0441, 0x0444, 0x0445, 0x0450, 0x0451, 0x0454, 0x0455, - 0x0500, 0x0501, 0x0504, 0x0505, 0x0510, 0x0511, 0x0514, 0x0515, - 0x0540, 0x0541, 0x0544, 0x0545, 0x0550, 0x0551, 0x0554, 0x0555, - - 0x1000, 0x1001, 0x1004, 0x1005, 0x1010, 0x1011, 0x1014, 0x1015, - 0x1040, 0x1041, 0x1044, 0x1045, 0x1050, 0x1051, 0x1054, 0x1055, - 0x1100, 0x1101, 0x1104, 0x1105, 0x1110, 0x1111, 0x1114, 0x1115, - 0x1140, 0x1141, 0x1144, 0x1145, 0x1150, 0x1151, 0x1154, 0x1155, - 0x1400, 0x1401, 0x1404, 0x1405, 0x1410, 0x1411, 0x1414, 0x1415, - 0x1440, 0x1441, 0x1444, 0x1445, 0x1450, 0x1451, 0x1454, 0x1455, - 0x1500, 0x1501, 0x1504, 0x1505, 0x1510, 0x1511, 0x1514, 0x1515, - 0x1540, 0x1541, 0x1544, 0x1545, 0x1550, 0x1551, 0x1554, 0x1555, - - 0x4000, 0x4001, 0x4004, 0x4005, 0x4010, 0x4011, 0x4014, 0x4015, - 0x4040, 0x4041, 0x4044, 0x4045, 0x4050, 0x4051, 0x4054, 0x4055, - 0x4100, 0x4101, 0x4104, 0x4105, 0x4110, 0x4111, 0x4114, 0x4115, - 0x4140, 0x4141, 0x4144, 0x4145, 0x4150, 0x4151, 0x4154, 0x4155, - 0x4400, 0x4401, 0x4404, 0x4405, 0x4410, 0x4411, 0x4414, 0x4415, - 0x4440, 0x4441, 0x4444, 0x4445, 0x4450, 0x4451, 0x4454, 0x4455, - 0x4500, 0x4501, 0x4504, 0x4505, 0x4510, 0x4511, 0x4514, 0x4515, - 0x4540, 0x4541, 0x4544, 0x4545, 0x4550, 0x4551, 0x4554, 0x4555, - - 0x5000, 0x5001, 0x5004, 0x5005, 0x5010, 0x5011, 0x5014, 0x5015, - 0x5040, 0x5041, 0x5044, 0x5045, 0x5050, 0x5051, 0x5054, 0x5055, - 0x5100, 0x5101, 0x5104, 0x5105, 0x5110, 0x5111, 0x5114, 0x5115, - 0x5140, 0x5141, 0x5144, 0x5145, 0x5150, 0x5151, 0x5154, 0x5155, - 0x5400, 0x5401, 0x5404, 0x5405, 0x5410, 0x5411, 0x5414, 0x5415, - 0x5440, 0x5441, 0x5444, 0x5445, 0x5450, 0x5451, 0x5454, 0x5455, - 0x5500, 0x5501, 0x5504, 0x5505, 0x5510, 0x5511, 0x5514, 0x5515, - 0x5540, 0x5541, 0x5544, 0x5545, 0x5550, 0x5551, 0x5554, 0x5555, -} - -// interleaveUint32 interleaves the given arguments into the return value. -// -// The 0-bit in val0 will be the 0-bit in the return value. -// The 0-bit in val1 will be the 1-bit in the return value. -// The 1-bit of val0 will be the 2-bit in the return value, and so on. -func interleaveUint32(x, y uint32) uint64 { - return (interleaveLookup[x&0xff]) | - (interleaveLookup[(x>>8)&0xff] << 16) | - (interleaveLookup[(x>>16)&0xff] << 32) | - (interleaveLookup[x>>24] << 48) | - (interleaveLookup[y&0xff] << 1) | - (interleaveLookup[(y>>8)&0xff] << 17) | - (interleaveLookup[(y>>16)&0xff] << 33) | - (interleaveLookup[y>>24] << 49) -} diff --git a/vendor/github.com/golang/geo/s2/latlng.go b/vendor/github.com/golang/geo/s2/latlng.go deleted file mode 100644 index a750304ab..000000000 --- a/vendor/github.com/golang/geo/s2/latlng.go +++ /dev/null @@ -1,101 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "math" - - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -const ( - northPoleLat = s1.Angle(math.Pi/2) * s1.Radian - southPoleLat = -northPoleLat -) - -// LatLng represents a point on the unit sphere as a pair of angles. -type LatLng struct { - Lat, Lng s1.Angle -} - -// LatLngFromDegrees returns a LatLng for the coordinates given in degrees. -func LatLngFromDegrees(lat, lng float64) LatLng { - return LatLng{s1.Angle(lat) * s1.Degree, s1.Angle(lng) * s1.Degree} -} - -// IsValid returns true iff the LatLng is normalized, with Lat ∈ [-π/2,π/2] and Lng ∈ [-π,π]. -func (ll LatLng) IsValid() bool { - return math.Abs(ll.Lat.Radians()) <= math.Pi/2 && math.Abs(ll.Lng.Radians()) <= math.Pi -} - -// Normalized returns the normalized version of the LatLng, -// with Lat clamped to [-π/2,π/2] and Lng wrapped in [-π,π]. -func (ll LatLng) Normalized() LatLng { - lat := ll.Lat - if lat > northPoleLat { - lat = northPoleLat - } else if lat < southPoleLat { - lat = southPoleLat - } - lng := s1.Angle(math.Remainder(ll.Lng.Radians(), 2*math.Pi)) * s1.Radian - return LatLng{lat, lng} -} - -func (ll LatLng) String() string { return fmt.Sprintf("[%v, %v]", ll.Lat, ll.Lng) } - -// Distance returns the angle between two LatLngs. -func (ll LatLng) Distance(ll2 LatLng) s1.Angle { - // Haversine formula, as used in C++ S2LatLng::GetDistance. - lat1, lat2 := ll.Lat.Radians(), ll2.Lat.Radians() - lng1, lng2 := ll.Lng.Radians(), ll2.Lng.Radians() - dlat := math.Sin(0.5 * (lat2 - lat1)) - dlng := math.Sin(0.5 * (lng2 - lng1)) - x := dlat*dlat + dlng*dlng*math.Cos(lat1)*math.Cos(lat2) - return s1.Angle(2*math.Atan2(math.Sqrt(x), math.Sqrt(math.Max(0, 1-x)))) * s1.Radian -} - -// NOTE(mikeperrow): The C++ implementation publicly exposes latitude/longitude -// functions. Let's see if that's really necessary before exposing the same functionality. - -func latitude(p Point) s1.Angle { - return s1.Angle(math.Atan2(p.Z, math.Sqrt(p.X*p.X+p.Y*p.Y))) * s1.Radian -} - -func longitude(p Point) s1.Angle { - return s1.Angle(math.Atan2(p.Y, p.X)) * s1.Radian -} - -// PointFromLatLng returns an Point for the given LatLng. -// The maximum error in the result is 1.5 * dblEpsilon. (This does not -// include the error of converting degrees, E5, E6, or E7 into radians.) -func PointFromLatLng(ll LatLng) Point { - phi := ll.Lat.Radians() - theta := ll.Lng.Radians() - cosphi := math.Cos(phi) - return Point{r3.Vector{math.Cos(theta) * cosphi, math.Sin(theta) * cosphi, math.Sin(phi)}} -} - -// LatLngFromPoint returns an LatLng for a given Point. -func LatLngFromPoint(p Point) LatLng { - return LatLng{latitude(p), longitude(p)} -} - -// ApproxEqual reports whether the latitude and longitude of the two LatLngs -// are the same up to a small tolerance. -func (ll LatLng) ApproxEqual(other LatLng) bool { - return ll.Lat.ApproxEqual(other.Lat) && ll.Lng.ApproxEqual(other.Lng) -} diff --git a/vendor/github.com/golang/geo/s2/lexicon.go b/vendor/github.com/golang/geo/s2/lexicon.go deleted file mode 100644 index 41cbffdc2..000000000 --- a/vendor/github.com/golang/geo/s2/lexicon.go +++ /dev/null @@ -1,175 +0,0 @@ -// Copyright 2020 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "encoding/binary" - "hash/adler32" - "math" - "sort" -) - -// TODO(roberts): If any of these are worth making public, change the -// method signatures and type names. - -// emptySetID represents the last ID that will ever be generated. -// (Non-negative IDs are reserved for singleton sets.) -var emptySetID = int32(math.MinInt32) - -// idSetLexicon compactly represents a set of non-negative -// integers such as array indices ("ID sets"). It is especially suitable when -// either (1) there are many duplicate sets, or (2) there are many singleton -// or empty sets. See also sequenceLexicon. -// -// Each distinct ID set is mapped to a 32-bit integer. Empty and singleton -// sets take up no additional space; the set itself is represented -// by the unique ID assigned to the set. Duplicate sets are automatically -// eliminated. Note also that ID sets are referred to using 32-bit integers -// rather than pointers. -type idSetLexicon struct { - idSets *sequenceLexicon -} - -func newIDSetLexicon() *idSetLexicon { - return &idSetLexicon{ - idSets: newSequenceLexicon(), - } -} - -// add adds the given set of integers to the lexicon if it is not already -// present, and return the unique ID for this set. The values are automatically -// sorted and duplicates are removed. -// -// The primary difference between this and sequenceLexicon are: -// 1. Empty and singleton sets are represented implicitly; they use no space. -// 2. Sets are represented rather than sequences; the ordering of values is -// not important and duplicates are removed. -// 3. The values must be 32-bit non-negative integers only. -func (l *idSetLexicon) add(ids ...int32) int32 { - // Empty sets have a special ID chosen not to conflict with other IDs. - if len(ids) == 0 { - return emptySetID - } - - // Singleton sets are represented by their element. - if len(ids) == 1 { - return ids[0] - } - - // Canonicalize the set by sorting and removing duplicates. - // - // Creates a new slice in order to not alter the supplied values. - set := uniqueInt32s(ids) - - // Non-singleton sets are represented by the bitwise complement of the ID - // returned by the sequenceLexicon - return ^l.idSets.add(set) -} - -// idSet returns the set of integers corresponding to an ID returned by add. -func (l *idSetLexicon) idSet(setID int32) []int32 { - if setID >= 0 { - return []int32{setID} - } - if setID == emptySetID { - return []int32{} - } - - return l.idSets.sequence(^setID) -} - -func (l *idSetLexicon) clear() { - l.idSets.clear() -} - -// sequenceLexicon compactly represents a sequence of values (e.g., tuples). -// It automatically eliminates duplicates slices, and maps the remaining -// sequences to sequentially increasing integer IDs. See also idSetLexicon. -// -// Each distinct sequence is mapped to a 32-bit integer. -type sequenceLexicon struct { - values []int32 - begins []uint32 - - // idSet is a mapping of a sequence hash to sequence index in the lexicon. - idSet map[uint32]int32 -} - -func newSequenceLexicon() *sequenceLexicon { - return &sequenceLexicon{ - begins: []uint32{0}, - idSet: make(map[uint32]int32), - } -} - -// clears all data from the lexicon. -func (l *sequenceLexicon) clear() { - l.values = nil - l.begins = []uint32{0} - l.idSet = make(map[uint32]int32) -} - -// add adds the given value to the lexicon if it is not already present, and -// returns its ID. IDs are assigned sequentially starting from zero. -func (l *sequenceLexicon) add(ids []int32) int32 { - if id, ok := l.idSet[hashSet(ids)]; ok { - return id - } - for _, v := range ids { - l.values = append(l.values, v) - } - l.begins = append(l.begins, uint32(len(l.values))) - - id := int32(len(l.begins)) - 2 - l.idSet[hashSet(ids)] = id - - return id -} - -// sequence returns the original sequence of values for the given ID. -func (l *sequenceLexicon) sequence(id int32) []int32 { - return l.values[l.begins[id]:l.begins[id+1]] -} - -// size reports the number of value sequences in the lexicon. -func (l *sequenceLexicon) size() int { - // Subtract one because the list of begins starts out with the first element set to 0. - return len(l.begins) - 1 -} - -// hash returns a hash of this sequence of int32s. -func hashSet(s []int32) uint32 { - // TODO(roberts): We just need a way to nicely hash all the values down to - // a 32-bit value. To ensure no unnecessary dependencies we use the core - // library types available to do this. Is there a better option? - a := adler32.New() - binary.Write(a, binary.LittleEndian, s) - return a.Sum32() -} - -// uniqueInt32s returns the sorted and uniqued set of int32s from the input. -func uniqueInt32s(in []int32) []int32 { - var vals []int32 - m := make(map[int32]bool) - for _, i := range in { - if m[i] { - continue - } - m[i] = true - vals = append(vals, i) - } - sort.Slice(vals, func(i, j int) bool { return vals[i] < vals[j] }) - return vals -} diff --git a/vendor/github.com/golang/geo/s2/loop.go b/vendor/github.com/golang/geo/s2/loop.go deleted file mode 100644 index bfb55ec1d..000000000 --- a/vendor/github.com/golang/geo/s2/loop.go +++ /dev/null @@ -1,1833 +0,0 @@ -// Copyright 2015 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "math" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// Loop represents a simple spherical polygon. It consists of a sequence -// of vertices where the first vertex is implicitly connected to the -// last. All loops are defined to have a CCW orientation, i.e. the interior of -// the loop is on the left side of the edges. This implies that a clockwise -// loop enclosing a small area is interpreted to be a CCW loop enclosing a -// very large area. -// -// Loops are not allowed to have any duplicate vertices (whether adjacent or -// not). Non-adjacent edges are not allowed to intersect, and furthermore edges -// of length 180 degrees are not allowed (i.e., adjacent vertices cannot be -// antipodal). Loops must have at least 3 vertices (except for the "empty" and -// "full" loops discussed below). -// -// There are two special loops: the "empty" loop contains no points and the -// "full" loop contains all points. These loops do not have any edges, but to -// preserve the invariant that every loop can be represented as a vertex -// chain, they are defined as having exactly one vertex each (see EmptyLoop -// and FullLoop). -type Loop struct { - vertices []Point - - // originInside keeps a precomputed value whether this loop contains the origin - // versus computing from the set of vertices every time. - originInside bool - - // depth is the nesting depth of this Loop if it is contained by a Polygon - // or other shape and is used to determine if this loop represents a hole - // or a filled in portion. - depth int - - // bound is a conservative bound on all points contained by this loop. - // If l.ContainsPoint(P), then l.bound.ContainsPoint(P). - bound Rect - - // Since bound is not exact, it is possible that a loop A contains - // another loop B whose bounds are slightly larger. subregionBound - // has been expanded sufficiently to account for this error, i.e. - // if A.Contains(B), then A.subregionBound.Contains(B.bound). - subregionBound Rect - - // index is the spatial index for this Loop. - index *ShapeIndex -} - -// LoopFromPoints constructs a loop from the given points. -func LoopFromPoints(pts []Point) *Loop { - l := &Loop{ - vertices: pts, - index: NewShapeIndex(), - } - - l.initOriginAndBound() - return l -} - -// LoopFromCell constructs a loop corresponding to the given cell. -// -// Note that the loop and cell *do not* contain exactly the same set of -// points, because Loop and Cell have slightly different definitions of -// point containment. For example, a Cell vertex is contained by all -// four neighboring Cells, but it is contained by exactly one of four -// Loops constructed from those cells. As another example, the cell -// coverings of cell and LoopFromCell(cell) will be different, because the -// loop contains points on its boundary that actually belong to other cells -// (i.e., the covering will include a layer of neighboring cells). -func LoopFromCell(c Cell) *Loop { - l := &Loop{ - vertices: []Point{ - c.Vertex(0), - c.Vertex(1), - c.Vertex(2), - c.Vertex(3), - }, - index: NewShapeIndex(), - } - - l.initOriginAndBound() - return l -} - -// These two points are used for the special Empty and Full loops. -var ( - emptyLoopPoint = Point{r3.Vector{X: 0, Y: 0, Z: 1}} - fullLoopPoint = Point{r3.Vector{X: 0, Y: 0, Z: -1}} -) - -// EmptyLoop returns a special "empty" loop. -func EmptyLoop() *Loop { - return LoopFromPoints([]Point{emptyLoopPoint}) -} - -// FullLoop returns a special "full" loop. -func FullLoop() *Loop { - return LoopFromPoints([]Point{fullLoopPoint}) -} - -// initOriginAndBound sets the origin containment for the given point and then calls -// the initialization for the bounds objects and the internal index. -func (l *Loop) initOriginAndBound() { - if len(l.vertices) < 3 { - // Check for the special "empty" and "full" loops (which have one vertex). - if !l.isEmptyOrFull() { - l.originInside = false - return - } - - // This is the special empty or full loop, so the origin depends on if - // the vertex is in the southern hemisphere or not. - l.originInside = l.vertices[0].Z < 0 - } else { - // Point containment testing is done by counting edge crossings starting - // at a fixed point on the sphere (OriginPoint). We need to know whether - // the reference point (OriginPoint) is inside or outside the loop before - // we can construct the ShapeIndex. We do this by first guessing that - // it is outside, and then seeing whether we get the correct containment - // result for vertex 1. If the result is incorrect, the origin must be - // inside the loop. - // - // A loop with consecutive vertices A,B,C contains vertex B if and only if - // the fixed vector R = B.Ortho is contained by the wedge ABC. The - // wedge is closed at A and open at C, i.e. the point B is inside the loop - // if A = R but not if C = R. This convention is required for compatibility - // with VertexCrossing. (Note that we can't use OriginPoint - // as the fixed vector because of the possibility that B == OriginPoint.) - l.originInside = false - v1Inside := OrderedCCW(Point{l.vertices[1].Ortho()}, l.vertices[0], l.vertices[2], l.vertices[1]) - if v1Inside != l.ContainsPoint(l.vertices[1]) { - l.originInside = true - } - } - - // We *must* call initBound before initializing the index, because - // initBound calls ContainsPoint which does a bounds check before using - // the index. - l.initBound() - - // Create a new index and add us to it. - l.index = NewShapeIndex() - l.index.Add(l) -} - -// initBound sets up the approximate bounding Rects for this loop. -func (l *Loop) initBound() { - if len(l.vertices) == 0 { - *l = *EmptyLoop() - return - } - // Check for the special "empty" and "full" loops. - if l.isEmptyOrFull() { - if l.IsEmpty() { - l.bound = EmptyRect() - } else { - l.bound = FullRect() - } - l.subregionBound = l.bound - return - } - - // The bounding rectangle of a loop is not necessarily the same as the - // bounding rectangle of its vertices. First, the maximal latitude may be - // attained along the interior of an edge. Second, the loop may wrap - // entirely around the sphere (e.g. a loop that defines two revolutions of a - // candy-cane stripe). Third, the loop may include one or both poles. - // Note that a small clockwise loop near the equator contains both poles. - bounder := NewRectBounder() - for i := 0; i <= len(l.vertices); i++ { // add vertex 0 twice - bounder.AddPoint(l.Vertex(i)) - } - b := bounder.RectBound() - - if l.ContainsPoint(Point{r3.Vector{0, 0, 1}}) { - b = Rect{r1.Interval{b.Lat.Lo, math.Pi / 2}, s1.FullInterval()} - } - // If a loop contains the south pole, then either it wraps entirely - // around the sphere (full longitude range), or it also contains the - // north pole in which case b.Lng.IsFull() due to the test above. - // Either way, we only need to do the south pole containment test if - // b.Lng.IsFull(). - if b.Lng.IsFull() && l.ContainsPoint(Point{r3.Vector{0, 0, -1}}) { - b.Lat.Lo = -math.Pi / 2 - } - l.bound = b - l.subregionBound = ExpandForSubregions(l.bound) -} - -// Validate checks whether this is a valid loop. -func (l *Loop) Validate() error { - if err := l.findValidationErrorNoIndex(); err != nil { - return err - } - - // Check for intersections between non-adjacent edges (including at vertices) - // TODO(roberts): Once shapeutil gets findAnyCrossing uncomment this. - // return findAnyCrossing(l.index) - - return nil -} - -// findValidationErrorNoIndex reports whether this is not a valid loop, but -// skips checks that would require a ShapeIndex to be built for the loop. This -// is primarily used by Polygon to do validation so it doesn't trigger the -// creation of unneeded ShapeIndices. -func (l *Loop) findValidationErrorNoIndex() error { - // All vertices must be unit length. - for i, v := range l.vertices { - if !v.IsUnit() { - return fmt.Errorf("vertex %d is not unit length", i) - } - } - - // Loops must have at least 3 vertices (except for empty and full). - if len(l.vertices) < 3 { - if l.isEmptyOrFull() { - return nil // Skip remaining tests. - } - return fmt.Errorf("non-empty, non-full loops must have at least 3 vertices") - } - - // Loops are not allowed to have any duplicate vertices or edge crossings. - // We split this check into two parts. First we check that no edge is - // degenerate (identical endpoints). Then we check that there are no - // intersections between non-adjacent edges (including at vertices). The - // second check needs the ShapeIndex, so it does not fall within the scope - // of this method. - for i, v := range l.vertices { - if v == l.Vertex(i+1) { - return fmt.Errorf("edge %d is degenerate (duplicate vertex)", i) - } - - // Antipodal vertices are not allowed. - if other := (Point{l.Vertex(i + 1).Mul(-1)}); v == other { - return fmt.Errorf("vertices %d and %d are antipodal", i, - (i+1)%len(l.vertices)) - } - } - - return nil -} - -// Contains reports whether the region contained by this loop is a superset of the -// region contained by the given other loop. -func (l *Loop) Contains(o *Loop) bool { - // For a loop A to contain the loop B, all of the following must - // be true: - // - // (1) There are no edge crossings between A and B except at vertices. - // - // (2) At every vertex that is shared between A and B, the local edge - // ordering implies that A contains B. - // - // (3) If there are no shared vertices, then A must contain a vertex of B - // and B must not contain a vertex of A. (An arbitrary vertex may be - // chosen in each case.) - // - // The second part of (3) is necessary to detect the case of two loops whose - // union is the entire sphere, i.e. two loops that contains each other's - // boundaries but not each other's interiors. - if !l.subregionBound.Contains(o.bound) { - return false - } - - // Special cases to handle either loop being empty or full. - if l.isEmptyOrFull() || o.isEmptyOrFull() { - return l.IsFull() || o.IsEmpty() - } - - // Check whether there are any edge crossings, and also check the loop - // relationship at any shared vertices. - relation := &containsRelation{} - if hasCrossingRelation(l, o, relation) { - return false - } - - // There are no crossings, and if there are any shared vertices then A - // contains B locally at each shared vertex. - if relation.foundSharedVertex { - return true - } - - // Since there are no edge intersections or shared vertices, we just need to - // test condition (3) above. We can skip this test if we discovered that A - // contains at least one point of B while checking for edge crossings. - if !l.ContainsPoint(o.Vertex(0)) { - return false - } - - // We still need to check whether (A union B) is the entire sphere. - // Normally this check is very cheap due to the bounding box precondition. - if (o.subregionBound.Contains(l.bound) || o.bound.Union(l.bound).IsFull()) && - o.ContainsPoint(l.Vertex(0)) { - return false - } - return true -} - -// Intersects reports whether the region contained by this loop intersects the region -// contained by the other loop. -func (l *Loop) Intersects(o *Loop) bool { - // Given two loops, A and B, A.Intersects(B) if and only if !A.Complement().Contains(B). - // - // This code is similar to Contains, but is optimized for the case - // where both loops enclose less than half of the sphere. - if !l.bound.Intersects(o.bound) { - return false - } - - // Check whether there are any edge crossings, and also check the loop - // relationship at any shared vertices. - relation := &intersectsRelation{} - if hasCrossingRelation(l, o, relation) { - return true - } - if relation.foundSharedVertex { - return false - } - - // Since there are no edge intersections or shared vertices, the loops - // intersect only if A contains B, B contains A, or the two loops contain - // each other's boundaries. These checks are usually cheap because of the - // bounding box preconditions. Note that neither loop is empty (because of - // the bounding box check above), so it is safe to access vertex(0). - - // Check whether A contains B, or A and B contain each other's boundaries. - // (Note that A contains all the vertices of B in either case.) - if l.subregionBound.Contains(o.bound) || l.bound.Union(o.bound).IsFull() { - if l.ContainsPoint(o.Vertex(0)) { - return true - } - } - // Check whether B contains A. - if o.subregionBound.Contains(l.bound) { - if o.ContainsPoint(l.Vertex(0)) { - return true - } - } - return false -} - -// Equal reports whether two loops have the same vertices in the same linear order -// (i.e., cyclic rotations are not allowed). -func (l *Loop) Equal(other *Loop) bool { - if len(l.vertices) != len(other.vertices) { - return false - } - - for i, v := range l.vertices { - if v != other.Vertex(i) { - return false - } - } - return true -} - -// BoundaryEqual reports whether the two loops have the same boundary. This is -// true if and only if the loops have the same vertices in the same cyclic order -// (i.e., the vertices may be cyclically rotated). The empty and full loops are -// considered to have different boundaries. -func (l *Loop) BoundaryEqual(o *Loop) bool { - if len(l.vertices) != len(o.vertices) { - return false - } - - // Special case to handle empty or full loops. Since they have the same - // number of vertices, if one loop is empty/full then so is the other. - if l.isEmptyOrFull() { - return l.IsEmpty() == o.IsEmpty() - } - - // Loop through the vertices to find the first of ours that matches the - // starting vertex of the other loop. Use that offset to then 'align' the - // vertices for comparison. - for offset, vertex := range l.vertices { - if vertex == o.Vertex(0) { - // There is at most one starting offset since loop vertices are unique. - for i := 0; i < len(l.vertices); i++ { - if l.Vertex(i+offset) != o.Vertex(i) { - return false - } - } - return true - } - } - return false -} - -// compareBoundary returns +1 if this loop contains the boundary of the other loop, -// -1 if it excludes the boundary of the other, and 0 if the boundaries of the two -// loops cross. Shared edges are handled as follows: -// -// If XY is a shared edge, define Reversed(XY) to be true if XY -// appears in opposite directions in both loops. -// Then this loop contains XY if and only if Reversed(XY) == the other loop is a hole. -// (Intuitively, this checks whether this loop contains a vanishingly small region -// extending from the boundary of the other toward the interior of the polygon to -// which the other belongs.) -// -// This function is used for testing containment and intersection of -// multi-loop polygons. Note that this method is not symmetric, since the -// result depends on the direction of this loop but not on the direction of -// the other loop (in the absence of shared edges). -// -// This requires that neither loop is empty, and if other loop IsFull, then it must not -// be a hole. -func (l *Loop) compareBoundary(o *Loop) int { - // The bounds must intersect for containment or crossing. - if !l.bound.Intersects(o.bound) { - return -1 - } - - // Full loops are handled as though the loop surrounded the entire sphere. - if l.IsFull() { - return 1 - } - if o.IsFull() { - return -1 - } - - // Check whether there are any edge crossings, and also check the loop - // relationship at any shared vertices. - relation := newCompareBoundaryRelation(o.IsHole()) - if hasCrossingRelation(l, o, relation) { - return 0 - } - if relation.foundSharedVertex { - if relation.containsEdge { - return 1 - } - return -1 - } - - // There are no edge intersections or shared vertices, so we can check - // whether A contains an arbitrary vertex of B. - if l.ContainsPoint(o.Vertex(0)) { - return 1 - } - return -1 -} - -// ContainsOrigin reports true if this loop contains s2.OriginPoint(). -func (l *Loop) ContainsOrigin() bool { - return l.originInside -} - -// ReferencePoint returns the reference point for this loop. -func (l *Loop) ReferencePoint() ReferencePoint { - return OriginReferencePoint(l.originInside) -} - -// NumEdges returns the number of edges in this shape. -func (l *Loop) NumEdges() int { - if l.isEmptyOrFull() { - return 0 - } - return len(l.vertices) -} - -// Edge returns the endpoints for the given edge index. -func (l *Loop) Edge(i int) Edge { - return Edge{l.Vertex(i), l.Vertex(i + 1)} -} - -// NumChains reports the number of contiguous edge chains in the Loop. -func (l *Loop) NumChains() int { - if l.IsEmpty() { - return 0 - } - return 1 -} - -// Chain returns the i-th edge chain in the Shape. -func (l *Loop) Chain(chainID int) Chain { - return Chain{0, l.NumEdges()} -} - -// ChainEdge returns the j-th edge of the i-th edge chain. -func (l *Loop) ChainEdge(chainID, offset int) Edge { - return Edge{l.Vertex(offset), l.Vertex(offset + 1)} -} - -// ChainPosition returns a ChainPosition pair (i, j) such that edgeID is the -// j-th edge of the Loop. -func (l *Loop) ChainPosition(edgeID int) ChainPosition { - return ChainPosition{0, edgeID} -} - -// Dimension returns the dimension of the geometry represented by this Loop. -func (l *Loop) Dimension() int { return 2 } - -func (l *Loop) typeTag() typeTag { return typeTagNone } - -func (l *Loop) privateInterface() {} - -// IsEmpty reports true if this is the special empty loop that contains no points. -func (l *Loop) IsEmpty() bool { - return l.isEmptyOrFull() && !l.ContainsOrigin() -} - -// IsFull reports true if this is the special full loop that contains all points. -func (l *Loop) IsFull() bool { - return l.isEmptyOrFull() && l.ContainsOrigin() -} - -// isEmptyOrFull reports true if this loop is either the "empty" or "full" special loops. -func (l *Loop) isEmptyOrFull() bool { - return len(l.vertices) == 1 -} - -// Vertices returns the vertices in the loop. -func (l *Loop) Vertices() []Point { - return l.vertices -} - -// RectBound returns a tight bounding rectangle. If the loop contains the point, -// the bound also contains it. -func (l *Loop) RectBound() Rect { - return l.bound -} - -// CapBound returns a bounding cap that may have more padding than the corresponding -// RectBound. The bound is conservative such that if the loop contains a point P, -// the bound also contains it. -func (l *Loop) CapBound() Cap { - return l.bound.CapBound() -} - -// Vertex returns the vertex for the given index. For convenience, the vertex indices -// wrap automatically for methods that do index math such as Edge. -// i.e., Vertex(NumEdges() + n) is the same as Vertex(n). -func (l *Loop) Vertex(i int) Point { - return l.vertices[i%len(l.vertices)] -} - -// OrientedVertex returns the vertex in reverse order if the loop represents a polygon -// hole. For example, arguments 0, 1, 2 are mapped to vertices n-1, n-2, n-3, where -// n == len(vertices). This ensures that the interior of the polygon is always to -// the left of the vertex chain. -// -// This requires: 0 <= i < 2 * len(vertices) -func (l *Loop) OrientedVertex(i int) Point { - j := i - len(l.vertices) - if j < 0 { - j = i - } - if l.IsHole() { - j = len(l.vertices) - 1 - j - } - return l.Vertex(j) -} - -// NumVertices returns the number of vertices in this loop. -func (l *Loop) NumVertices() int { - return len(l.vertices) -} - -// bruteForceContainsPoint reports if the given point is contained by this loop. -// This method does not use the ShapeIndex, so it is only preferable below a certain -// size of loop. -func (l *Loop) bruteForceContainsPoint(p Point) bool { - origin := OriginPoint() - inside := l.originInside - crosser := NewChainEdgeCrosser(origin, p, l.Vertex(0)) - for i := 1; i <= len(l.vertices); i++ { // add vertex 0 twice - inside = inside != crosser.EdgeOrVertexChainCrossing(l.Vertex(i)) - } - return inside -} - -// ContainsPoint returns true if the loop contains the point. -func (l *Loop) ContainsPoint(p Point) bool { - if !l.index.IsFresh() && !l.bound.ContainsPoint(p) { - return false - } - - // For small loops it is faster to just check all the crossings. We also - // use this method during loop initialization because InitOriginAndBound() - // calls Contains() before InitIndex(). Otherwise, we keep track of the - // number of calls to Contains() and only build the index when enough calls - // have been made so that we think it is worth the effort. Note that the - // code below is structured so that if many calls are made in parallel only - // one thread builds the index, while the rest continue using brute force - // until the index is actually available. - - const maxBruteForceVertices = 32 - // TODO(roberts): add unindexed contains calls tracking - - if len(l.index.shapes) == 0 || // Index has not been initialized yet. - len(l.vertices) <= maxBruteForceVertices { - return l.bruteForceContainsPoint(p) - } - - // Otherwise, look up the point in the index. - it := l.index.Iterator() - if !it.LocatePoint(p) { - return false - } - return l.iteratorContainsPoint(it, p) -} - -// ContainsCell reports whether the given Cell is contained by this Loop. -func (l *Loop) ContainsCell(target Cell) bool { - it := l.index.Iterator() - relation := it.LocateCellID(target.ID()) - - // If "target" is disjoint from all index cells, it is not contained. - // Similarly, if "target" is subdivided into one or more index cells then it - // is not contained, since index cells are subdivided only if they (nearly) - // intersect a sufficient number of edges. (But note that if "target" itself - // is an index cell then it may be contained, since it could be a cell with - // no edges in the loop interior.) - if relation != Indexed { - return false - } - - // Otherwise check if any edges intersect "target". - if l.boundaryApproxIntersects(it, target) { - return false - } - - // Otherwise check if the loop contains the center of "target". - return l.iteratorContainsPoint(it, target.Center()) -} - -// IntersectsCell reports whether this Loop intersects the given cell. -func (l *Loop) IntersectsCell(target Cell) bool { - it := l.index.Iterator() - relation := it.LocateCellID(target.ID()) - - // If target does not overlap any index cell, there is no intersection. - if relation == Disjoint { - return false - } - // If target is subdivided into one or more index cells, there is an - // intersection to within the ShapeIndex error bound (see Contains). - if relation == Subdivided { - return true - } - // If target is an index cell, there is an intersection because index cells - // are created only if they have at least one edge or they are entirely - // contained by the loop. - if it.CellID() == target.id { - return true - } - // Otherwise check if any edges intersect target. - if l.boundaryApproxIntersects(it, target) { - return true - } - // Otherwise check if the loop contains the center of target. - return l.iteratorContainsPoint(it, target.Center()) -} - -// CellUnionBound computes a covering of the Loop. -func (l *Loop) CellUnionBound() []CellID { - return l.CapBound().CellUnionBound() -} - -// boundaryApproxIntersects reports if the loop's boundary intersects target. -// It may also return true when the loop boundary does not intersect target but -// some edge comes within the worst-case error tolerance. -// -// This requires that it.Locate(target) returned Indexed. -func (l *Loop) boundaryApproxIntersects(it *ShapeIndexIterator, target Cell) bool { - aClipped := it.IndexCell().findByShapeID(0) - - // If there are no edges, there is no intersection. - if len(aClipped.edges) == 0 { - return false - } - - // We can save some work if target is the index cell itself. - if it.CellID() == target.ID() { - return true - } - - // Otherwise check whether any of the edges intersect target. - maxError := (faceClipErrorUVCoord + intersectsRectErrorUVDist) - bound := target.BoundUV().ExpandedByMargin(maxError) - for _, ai := range aClipped.edges { - v0, v1, ok := ClipToPaddedFace(l.Vertex(ai), l.Vertex(ai+1), target.Face(), maxError) - if ok && edgeIntersectsRect(v0, v1, bound) { - return true - } - } - return false -} - -// iteratorContainsPoint reports if the iterator that is positioned at the ShapeIndexCell -// that may contain p, contains the point p. -func (l *Loop) iteratorContainsPoint(it *ShapeIndexIterator, p Point) bool { - // Test containment by drawing a line segment from the cell center to the - // given point and counting edge crossings. - aClipped := it.IndexCell().findByShapeID(0) - inside := aClipped.containsCenter - if len(aClipped.edges) > 0 { - center := it.Center() - crosser := NewEdgeCrosser(center, p) - aiPrev := -2 - for _, ai := range aClipped.edges { - if ai != aiPrev+1 { - crosser.RestartAt(l.Vertex(ai)) - } - aiPrev = ai - inside = inside != crosser.EdgeOrVertexChainCrossing(l.Vertex(ai+1)) - } - } - return inside -} - -// RegularLoop creates a loop with the given number of vertices, all -// located on a circle of the specified radius around the given center. -func RegularLoop(center Point, radius s1.Angle, numVertices int) *Loop { - return RegularLoopForFrame(getFrame(center), radius, numVertices) -} - -// RegularLoopForFrame creates a loop centered around the z-axis of the given -// coordinate frame, with the first vertex in the direction of the positive x-axis. -func RegularLoopForFrame(frame matrix3x3, radius s1.Angle, numVertices int) *Loop { - return LoopFromPoints(regularPointsForFrame(frame, radius, numVertices)) -} - -// CanonicalFirstVertex returns a first index and a direction (either +1 or -1) -// such that the vertex sequence (first, first+dir, ..., first+(n-1)*dir) does -// not change when the loop vertex order is rotated or inverted. This allows the -// loop vertices to be traversed in a canonical order. The return values are -// chosen such that (first, ..., first+n*dir) are in the range [0, 2*n-1] as -// expected by the Vertex method. -func (l *Loop) CanonicalFirstVertex() (firstIdx, direction int) { - firstIdx = 0 - n := len(l.vertices) - for i := 1; i < n; i++ { - if l.Vertex(i).Cmp(l.Vertex(firstIdx).Vector) == -1 { - firstIdx = i - } - } - - // 0 <= firstIdx <= n-1, so (firstIdx+n*dir) <= 2*n-1. - if l.Vertex(firstIdx+1).Cmp(l.Vertex(firstIdx+n-1).Vector) == -1 { - return firstIdx, 1 - } - - // n <= firstIdx <= 2*n-1, so (firstIdx+n*dir) >= 0. - firstIdx += n - return firstIdx, -1 -} - -// TurningAngle returns the sum of the turning angles at each vertex. The return -// value is positive if the loop is counter-clockwise, negative if the loop is -// clockwise, and zero if the loop is a great circle. Degenerate and -// nearly-degenerate loops are handled consistently with Sign. So for example, -// if a loop has zero area (i.e., it is a very small CCW loop) then the turning -// angle will always be negative. -// -// This quantity is also called the "geodesic curvature" of the loop. -func (l *Loop) TurningAngle() float64 { - // For empty and full loops, we return the limit value as the loop area - // approaches 0 or 4*Pi respectively. - if l.isEmptyOrFull() { - if l.ContainsOrigin() { - return -2 * math.Pi - } - return 2 * math.Pi - } - - // Don't crash even if the loop is not well-defined. - if len(l.vertices) < 3 { - return 0 - } - - // To ensure that we get the same result when the vertex order is rotated, - // and that the result is negated when the vertex order is reversed, we need - // to add up the individual turn angles in a consistent order. (In general, - // adding up a set of numbers in a different order can change the sum due to - // rounding errors.) - // - // Furthermore, if we just accumulate an ordinary sum then the worst-case - // error is quadratic in the number of vertices. (This can happen with - // spiral shapes, where the partial sum of the turning angles can be linear - // in the number of vertices.) To avoid this we use the Kahan summation - // algorithm (http://en.wikipedia.org/wiki/Kahan_summation_algorithm). - n := len(l.vertices) - i, dir := l.CanonicalFirstVertex() - sum := TurnAngle(l.Vertex((i+n-dir)%n), l.Vertex(i), l.Vertex((i+dir)%n)) - - compensation := s1.Angle(0) - for n-1 > 0 { - i += dir - angle := TurnAngle(l.Vertex(i-dir), l.Vertex(i), l.Vertex(i+dir)) - oldSum := sum - angle += compensation - sum += angle - compensation = (oldSum - sum) + angle - n-- - } - - const maxCurvature = 2*math.Pi - 4*dblEpsilon - - return math.Max(-maxCurvature, math.Min(maxCurvature, float64(dir)*float64(sum+compensation))) -} - -// turningAngleMaxError return the maximum error in TurningAngle. The value is not -// constant; it depends on the loop. -func (l *Loop) turningAngleMaxError() float64 { - // The maximum error can be bounded as follows: - // 3.00 * dblEpsilon for RobustCrossProd(b, a) - // 3.00 * dblEpsilon for RobustCrossProd(c, b) - // 3.25 * dblEpsilon for Angle() - // 2.00 * dblEpsilon for each addition in the Kahan summation - // ------------------ - // 11.25 * dblEpsilon - maxErrorPerVertex := 11.25 * dblEpsilon - return maxErrorPerVertex * float64(len(l.vertices)) -} - -// IsHole reports whether this loop represents a hole in its containing polygon. -func (l *Loop) IsHole() bool { return l.depth&1 != 0 } - -// Sign returns -1 if this Loop represents a hole in its containing polygon, and +1 otherwise. -func (l *Loop) Sign() int { - if l.IsHole() { - return -1 - } - return 1 -} - -// IsNormalized reports whether the loop area is at most 2*pi. Degenerate loops are -// handled consistently with Sign, i.e., if a loop can be -// expressed as the union of degenerate or nearly-degenerate CCW triangles, -// then it will always be considered normalized. -func (l *Loop) IsNormalized() bool { - // Optimization: if the longitude span is less than 180 degrees, then the - // loop covers less than half the sphere and is therefore normalized. - if l.bound.Lng.Length() < math.Pi { - return true - } - - // We allow some error so that hemispheres are always considered normalized. - // TODO(roberts): This is no longer required by the Polygon implementation, - // so alternatively we could create the invariant that a loop is normalized - // if and only if its complement is not normalized. - return l.TurningAngle() >= -l.turningAngleMaxError() -} - -// Normalize inverts the loop if necessary so that the area enclosed by the loop -// is at most 2*pi. -func (l *Loop) Normalize() { - if !l.IsNormalized() { - l.Invert() - } -} - -// Invert reverses the order of the loop vertices, effectively complementing the -// region represented by the loop. For example, the loop ABCD (with edges -// AB, BC, CD, DA) becomes the loop DCBA (with edges DC, CB, BA, AD). -// Notice that the last edge is the same in both cases except that its -// direction has been reversed. -func (l *Loop) Invert() { - l.index.Reset() - if l.isEmptyOrFull() { - if l.IsFull() { - l.vertices[0] = emptyLoopPoint - } else { - l.vertices[0] = fullLoopPoint - } - } else { - // For non-special loops, reverse the slice of vertices. - for i := len(l.vertices)/2 - 1; i >= 0; i-- { - opp := len(l.vertices) - 1 - i - l.vertices[i], l.vertices[opp] = l.vertices[opp], l.vertices[i] - } - } - - // originInside must be set correctly before building the ShapeIndex. - l.originInside = !l.originInside - if l.bound.Lat.Lo > -math.Pi/2 && l.bound.Lat.Hi < math.Pi/2 { - // The complement of this loop contains both poles. - l.bound = FullRect() - l.subregionBound = l.bound - } else { - l.initBound() - } - l.index.Add(l) -} - -// findVertex returns the index of the vertex at the given Point in the range -// 1..numVertices, and a boolean indicating if a vertex was found. -func (l *Loop) findVertex(p Point) (index int, ok bool) { - const notFound = 0 - if len(l.vertices) < 10 { - // Exhaustive search for loops below a small threshold. - for i := 1; i <= len(l.vertices); i++ { - if l.Vertex(i) == p { - return i, true - } - } - return notFound, false - } - - it := l.index.Iterator() - if !it.LocatePoint(p) { - return notFound, false - } - - aClipped := it.IndexCell().findByShapeID(0) - for i := aClipped.numEdges() - 1; i >= 0; i-- { - ai := aClipped.edges[i] - if l.Vertex(ai) == p { - if ai == 0 { - return len(l.vertices), true - } - return ai, true - } - - if l.Vertex(ai+1) == p { - return ai + 1, true - } - } - return notFound, false -} - -// ContainsNested reports whether the given loops is contained within this loop. -// This function does not test for edge intersections. The two loops must meet -// all of the Polygon requirements; for example this implies that their -// boundaries may not cross or have any shared edges (although they may have -// shared vertices). -func (l *Loop) ContainsNested(other *Loop) bool { - if !l.subregionBound.Contains(other.bound) { - return false - } - - // Special cases to handle either loop being empty or full. Also bail out - // when B has no vertices to avoid heap overflow on the vertex(1) call - // below. (This method is called during polygon initialization before the - // client has an opportunity to call IsValid().) - if l.isEmptyOrFull() || other.NumVertices() < 2 { - return l.IsFull() || other.IsEmpty() - } - - // We are given that A and B do not share any edges, and that either one - // loop contains the other or they do not intersect. - m, ok := l.findVertex(other.Vertex(1)) - if !ok { - // Since other.vertex(1) is not shared, we can check whether A contains it. - return l.ContainsPoint(other.Vertex(1)) - } - - // Check whether the edge order around other.Vertex(1) is compatible with - // A containing B. - return WedgeContains(l.Vertex(m-1), l.Vertex(m), l.Vertex(m+1), other.Vertex(0), other.Vertex(2)) -} - -// surfaceIntegralFloat64 computes the oriented surface integral of some quantity f(x) -// over the loop interior, given a function f(A,B,C) that returns the -// corresponding integral over the spherical triangle ABC. Here "oriented -// surface integral" means: -// -// (1) f(A,B,C) must be the integral of f if ABC is counterclockwise, -// and the integral of -f if ABC is clockwise. -// -// (2) The result of this function is *either* the integral of f over the -// loop interior, or the integral of (-f) over the loop exterior. -// -// Note that there are at least two common situations where it easy to work -// around property (2) above: -// -// - If the integral of f over the entire sphere is zero, then it doesn't -// matter which case is returned because they are always equal. -// -// - If f is non-negative, then it is easy to detect when the integral over -// the loop exterior has been returned, and the integral over the loop -// interior can be obtained by adding the integral of f over the entire -// unit sphere (a constant) to the result. -// -// Any changes to this method may need corresponding changes to surfaceIntegralPoint as well. -func (l *Loop) surfaceIntegralFloat64(f func(a, b, c Point) float64) float64 { - // We sum f over a collection T of oriented triangles, possibly - // overlapping. Let the sign of a triangle be +1 if it is CCW and -1 - // otherwise, and let the sign of a point x be the sum of the signs of the - // triangles containing x. Then the collection of triangles T is chosen - // such that either: - // - // (1) Each point in the loop interior has sign +1, and sign 0 otherwise; or - // (2) Each point in the loop exterior has sign -1, and sign 0 otherwise. - // - // The triangles basically consist of a fan from vertex 0 to every loop - // edge that does not include vertex 0. These triangles will always satisfy - // either (1) or (2). However, what makes this a bit tricky is that - // spherical edges become numerically unstable as their length approaches - // 180 degrees. Of course there is not much we can do if the loop itself - // contains such edges, but we would like to make sure that all the triangle - // edges under our control (i.e., the non-loop edges) are stable. For - // example, consider a loop around the equator consisting of four equally - // spaced points. This is a well-defined loop, but we cannot just split it - // into two triangles by connecting vertex 0 to vertex 2. - // - // We handle this type of situation by moving the origin of the triangle fan - // whenever we are about to create an unstable edge. We choose a new - // location for the origin such that all relevant edges are stable. We also - // create extra triangles with the appropriate orientation so that the sum - // of the triangle signs is still correct at every point. - - // The maximum length of an edge for it to be considered numerically stable. - // The exact value is fairly arbitrary since it depends on the stability of - // the function f. The value below is quite conservative but could be - // reduced further if desired. - const maxLength = math.Pi - 1e-5 - - var sum float64 - origin := l.Vertex(0) - for i := 1; i+1 < len(l.vertices); i++ { - // Let V_i be vertex(i), let O be the current origin, and let length(A,B) - // be the length of edge (A,B). At the start of each loop iteration, the - // "leading edge" of the triangle fan is (O,V_i), and we want to extend - // the triangle fan so that the leading edge is (O,V_i+1). - // - // Invariants: - // 1. length(O,V_i) < maxLength for all (i > 1). - // 2. Either O == V_0, or O is approximately perpendicular to V_0. - // 3. "sum" is the oriented integral of f over the area defined by - // (O, V_0, V_1, ..., V_i). - if l.Vertex(i+1).Angle(origin.Vector) > maxLength { - // We are about to create an unstable edge, so choose a new origin O' - // for the triangle fan. - oldOrigin := origin - if origin == l.Vertex(0) { - // The following point is well-separated from V_i and V_0 (and - // therefore V_i+1 as well). - origin = Point{l.Vertex(0).PointCross(l.Vertex(i)).Normalize()} - } else if l.Vertex(i).Angle(l.Vertex(0).Vector) < maxLength { - // All edges of the triangle (O, V_0, V_i) are stable, so we can - // revert to using V_0 as the origin. - origin = l.Vertex(0) - } else { - // (O, V_i+1) and (V_0, V_i) are antipodal pairs, and O and V_0 are - // perpendicular. Therefore V_0.CrossProd(O) is approximately - // perpendicular to all of {O, V_0, V_i, V_i+1}, and we can choose - // this point O' as the new origin. - origin = Point{l.Vertex(0).Cross(oldOrigin.Vector)} - - // Advance the edge (V_0,O) to (V_0,O'). - sum += f(l.Vertex(0), oldOrigin, origin) - } - // Advance the edge (O,V_i) to (O',V_i). - sum += f(oldOrigin, l.Vertex(i), origin) - } - // Advance the edge (O,V_i) to (O,V_i+1). - sum += f(origin, l.Vertex(i), l.Vertex(i+1)) - } - // If the origin is not V_0, we need to sum one more triangle. - if origin != l.Vertex(0) { - // Advance the edge (O,V_n-1) to (O,V_0). - sum += f(origin, l.Vertex(len(l.vertices)-1), l.Vertex(0)) - } - return sum -} - -// surfaceIntegralPoint mirrors the surfaceIntegralFloat64 method but over Points; -// see that method for commentary. The C++ version uses a templated method. -// Any changes to this method may need corresponding changes to surfaceIntegralFloat64 as well. -func (l *Loop) surfaceIntegralPoint(f func(a, b, c Point) Point) Point { - const maxLength = math.Pi - 1e-5 - var sum r3.Vector - - origin := l.Vertex(0) - for i := 1; i+1 < len(l.vertices); i++ { - if l.Vertex(i+1).Angle(origin.Vector) > maxLength { - oldOrigin := origin - if origin == l.Vertex(0) { - origin = Point{l.Vertex(0).PointCross(l.Vertex(i)).Normalize()} - } else if l.Vertex(i).Angle(l.Vertex(0).Vector) < maxLength { - origin = l.Vertex(0) - } else { - origin = Point{l.Vertex(0).Cross(oldOrigin.Vector)} - sum = sum.Add(f(l.Vertex(0), oldOrigin, origin).Vector) - } - sum = sum.Add(f(oldOrigin, l.Vertex(i), origin).Vector) - } - sum = sum.Add(f(origin, l.Vertex(i), l.Vertex(i+1)).Vector) - } - if origin != l.Vertex(0) { - sum = sum.Add(f(origin, l.Vertex(len(l.vertices)-1), l.Vertex(0)).Vector) - } - return Point{sum} -} - -// Area returns the area of the loop interior, i.e. the region on the left side of -// the loop. The return value is between 0 and 4*pi. (Note that the return -// value is not affected by whether this loop is a "hole" or a "shell".) -func (l *Loop) Area() float64 { - // It is surprisingly difficult to compute the area of a loop robustly. The - // main issues are (1) whether degenerate loops are considered to be CCW or - // not (i.e., whether their area is close to 0 or 4*pi), and (2) computing - // the areas of small loops with good relative accuracy. - // - // With respect to degeneracies, we would like Area to be consistent - // with ContainsPoint in that loops that contain many points - // should have large areas, and loops that contain few points should have - // small areas. For example, if a degenerate triangle is considered CCW - // according to s2predicates Sign, then it will contain very few points and - // its area should be approximately zero. On the other hand if it is - // considered clockwise, then it will contain virtually all points and so - // its area should be approximately 4*pi. - // - // More precisely, let U be the set of Points for which IsUnitLength - // is true, let P(U) be the projection of those points onto the mathematical - // unit sphere, and let V(P(U)) be the Voronoi diagram of the projected - // points. Then for every loop x, we would like Area to approximately - // equal the sum of the areas of the Voronoi regions of the points p for - // which x.ContainsPoint(p) is true. - // - // The second issue is that we want to compute the area of small loops - // accurately. This requires having good relative precision rather than - // good absolute precision. For example, if the area of a loop is 1e-12 and - // the error is 1e-15, then the area only has 3 digits of accuracy. (For - // reference, 1e-12 is about 40 square meters on the surface of the earth.) - // We would like to have good relative accuracy even for small loops. - // - // To achieve these goals, we combine two different methods of computing the - // area. This first method is based on the Gauss-Bonnet theorem, which says - // that the area enclosed by the loop equals 2*pi minus the total geodesic - // curvature of the loop (i.e., the sum of the "turning angles" at all the - // loop vertices). The big advantage of this method is that as long as we - // use Sign to compute the turning angle at each vertex, then - // degeneracies are always handled correctly. In other words, if a - // degenerate loop is CCW according to the symbolic perturbations used by - // Sign, then its turning angle will be approximately 2*pi. - // - // The disadvantage of the Gauss-Bonnet method is that its absolute error is - // about 2e-15 times the number of vertices (see turningAngleMaxError). - // So, it cannot compute the area of small loops accurately. - // - // The second method is based on splitting the loop into triangles and - // summing the area of each triangle. To avoid the difficulty and expense - // of decomposing the loop into a union of non-overlapping triangles, - // instead we compute a signed sum over triangles that may overlap (see the - // comments for surfaceIntegral). The advantage of this method - // is that the area of each triangle can be computed with much better - // relative accuracy (using l'Huilier's theorem). The disadvantage is that - // the result is a signed area: CCW loops may yield a small positive value, - // while CW loops may yield a small negative value (which is converted to a - // positive area by adding 4*pi). This means that small errors in computing - // the signed area may translate into a very large error in the result (if - // the sign of the sum is incorrect). - // - // So, our strategy is to combine these two methods as follows. First we - // compute the area using the "signed sum over triangles" approach (since it - // is generally more accurate). We also estimate the maximum error in this - // result. If the signed area is too close to zero (i.e., zero is within - // the error bounds), then we double-check the sign of the result using the - // Gauss-Bonnet method. (In fact we just call IsNormalized, which is - // based on this method.) If the two methods disagree, we return either 0 - // or 4*pi based on the result of IsNormalized. Otherwise we return the - // area that we computed originally. - if l.isEmptyOrFull() { - if l.ContainsOrigin() { - return 4 * math.Pi - } - return 0 - } - area := l.surfaceIntegralFloat64(SignedArea) - - // TODO(roberts): This error estimate is very approximate. There are two - // issues: (1) SignedArea needs some improvements to ensure that its error - // is actually never higher than GirardArea, and (2) although the number of - // triangles in the sum is typically N-2, in theory it could be as high as - // 2*N for pathological inputs. But in other respects this error bound is - // very conservative since it assumes that the maximum error is achieved on - // every triangle. - maxError := l.turningAngleMaxError() - - // The signed area should be between approximately -4*pi and 4*pi. - if area < 0 { - // We have computed the negative of the area of the loop exterior. - area += 4 * math.Pi - } - - if area > 4*math.Pi { - area = 4 * math.Pi - } - if area < 0 { - area = 0 - } - - // If the area is close enough to zero or 4*pi so that the loop orientation - // is ambiguous, then we compute the loop orientation explicitly. - if area < maxError && !l.IsNormalized() { - return 4 * math.Pi - } else if area > (4*math.Pi-maxError) && l.IsNormalized() { - return 0 - } - - return area -} - -// Centroid returns the true centroid of the loop multiplied by the area of the -// loop. The result is not unit length, so you may want to normalize it. Also -// note that in general, the centroid may not be contained by the loop. -// -// We prescale by the loop area for two reasons: (1) it is cheaper to -// compute this way, and (2) it makes it easier to compute the centroid of -// more complicated shapes (by splitting them into disjoint regions and -// adding their centroids). -// -// Note that the return value is not affected by whether this loop is a -// "hole" or a "shell". -func (l *Loop) Centroid() Point { - // surfaceIntegralPoint() returns either the integral of position over loop - // interior, or the negative of the integral of position over the loop - // exterior. But these two values are the same (!), because the integral of - // position over the entire sphere is (0, 0, 0). - return l.surfaceIntegralPoint(TrueCentroid) -} - -// Encode encodes the Loop. -func (l Loop) Encode(w io.Writer) error { - e := &encoder{w: w} - l.encode(e) - return e.err -} - -func (l Loop) encode(e *encoder) { - e.writeInt8(encodingVersion) - e.writeUint32(uint32(len(l.vertices))) - for _, v := range l.vertices { - e.writeFloat64(v.X) - e.writeFloat64(v.Y) - e.writeFloat64(v.Z) - } - - e.writeBool(l.originInside) - e.writeInt32(int32(l.depth)) - - // Encode the bound. - l.bound.encode(e) -} - -// Decode decodes a loop. -func (l *Loop) Decode(r io.Reader) error { - *l = Loop{} - d := &decoder{r: asByteReader(r)} - l.decode(d) - return d.err -} - -func (l *Loop) decode(d *decoder) { - version := int8(d.readUint8()) - if d.err != nil { - return - } - if version != encodingVersion { - d.err = fmt.Errorf("cannot decode version %d", version) - return - } - - // Empty loops are explicitly allowed here: a newly created loop has zero vertices - // and such loops encode and decode properly. - nvertices := d.readUint32() - if nvertices > maxEncodedVertices { - if d.err == nil { - d.err = fmt.Errorf("too many vertices (%d; max is %d)", nvertices, maxEncodedVertices) - - } - return - } - l.vertices = make([]Point, nvertices) - for i := range l.vertices { - l.vertices[i].X = d.readFloat64() - l.vertices[i].Y = d.readFloat64() - l.vertices[i].Z = d.readFloat64() - } - l.index = NewShapeIndex() - l.originInside = d.readBool() - l.depth = int(d.readUint32()) - l.bound.decode(d) - l.subregionBound = ExpandForSubregions(l.bound) - - l.index.Add(l) -} - -// Bitmasks to read from properties. -const ( - originInside = 1 << iota - boundEncoded -) - -func (l *Loop) xyzFaceSiTiVertices() []xyzFaceSiTi { - ret := make([]xyzFaceSiTi, len(l.vertices)) - for i, v := range l.vertices { - ret[i].xyz = v - ret[i].face, ret[i].si, ret[i].ti, ret[i].level = xyzToFaceSiTi(v) - } - return ret -} - -func (l *Loop) encodeCompressed(e *encoder, snapLevel int, vertices []xyzFaceSiTi) { - if len(l.vertices) != len(vertices) { - panic("encodeCompressed: vertices must be the same length as l.vertices") - } - if len(vertices) > maxEncodedVertices { - if e.err == nil { - e.err = fmt.Errorf("too many vertices (%d; max is %d)", len(vertices), maxEncodedVertices) - } - return - } - e.writeUvarint(uint64(len(vertices))) - encodePointsCompressed(e, vertices, snapLevel) - - props := l.compressedEncodingProperties() - e.writeUvarint(props) - e.writeUvarint(uint64(l.depth)) - if props&boundEncoded != 0 { - l.bound.encode(e) - } -} - -func (l *Loop) compressedEncodingProperties() uint64 { - var properties uint64 - if l.originInside { - properties |= originInside - } - - // Write whether there is a bound so we can change the threshold later. - // Recomputing the bound multiplies the decode time taken per vertex - // by a factor of about 3.5. Without recomputing the bound, decode - // takes approximately 125 ns / vertex. A loop with 63 vertices - // encoded without the bound will take ~30us to decode, which is - // acceptable. At ~3.5 bytes / vertex without the bound, adding - // the bound will increase the size by <15%, which is also acceptable. - const minVerticesForBound = 64 - if len(l.vertices) >= minVerticesForBound { - properties |= boundEncoded - } - - return properties -} - -func (l *Loop) decodeCompressed(d *decoder, snapLevel int) { - nvertices := d.readUvarint() - if d.err != nil { - return - } - if nvertices > maxEncodedVertices { - d.err = fmt.Errorf("too many vertices (%d; max is %d)", nvertices, maxEncodedVertices) - return - } - l.vertices = make([]Point, nvertices) - decodePointsCompressed(d, snapLevel, l.vertices) - properties := d.readUvarint() - - // Make sure values are valid before using. - if d.err != nil { - return - } - - l.index = NewShapeIndex() - l.originInside = (properties & originInside) != 0 - - l.depth = int(d.readUvarint()) - - if (properties & boundEncoded) != 0 { - l.bound.decode(d) - if d.err != nil { - return - } - l.subregionBound = ExpandForSubregions(l.bound) - } else { - l.initBound() - } - - l.index.Add(l) -} - -// crossingTarget is an enum representing the possible crossing target cases for relations. -type crossingTarget int - -const ( - crossingTargetDontCare crossingTarget = iota - crossingTargetDontCross - crossingTargetCross -) - -// loopRelation defines the interface for checking a type of relationship between two loops. -// Some examples of relations are Contains, Intersects, or CompareBoundary. -type loopRelation interface { - // Optionally, aCrossingTarget and bCrossingTarget can specify an early-exit - // condition for the loop relation. If any point P is found such that - // - // A.ContainsPoint(P) == aCrossingTarget() && - // B.ContainsPoint(P) == bCrossingTarget() - // - // then the loop relation is assumed to be the same as if a pair of crossing - // edges were found. For example, the ContainsPoint relation has - // - // aCrossingTarget() == crossingTargetDontCross - // bCrossingTarget() == crossingTargetCross - // - // because if A.ContainsPoint(P) == false and B.ContainsPoint(P) == true - // for any point P, then it is equivalent to finding an edge crossing (i.e., - // since Contains returns false in both cases). - // - // Loop relations that do not have an early-exit condition of this form - // should return crossingTargetDontCare for both crossing targets. - - // aCrossingTarget reports whether loop A crosses the target point with - // the given relation type. - aCrossingTarget() crossingTarget - // bCrossingTarget reports whether loop B crosses the target point with - // the given relation type. - bCrossingTarget() crossingTarget - - // wedgesCross reports if a shared vertex ab1 and the two associated wedges - // (a0, ab1, b2) and (b0, ab1, b2) are equivalent to an edge crossing. - // The loop relation is also allowed to maintain its own internal state, and - // can return true if it observes any sequence of wedges that are equivalent - // to an edge crossing. - wedgesCross(a0, ab1, a2, b0, b2 Point) bool -} - -// loopCrosser is a helper type for determining whether two loops cross. -// It is instantiated twice for each pair of loops to be tested, once for the -// pair (A,B) and once for the pair (B,A), in order to be able to process -// edges in either loop nesting order. -type loopCrosser struct { - a, b *Loop - relation loopRelation - swapped bool - aCrossingTarget crossingTarget - bCrossingTarget crossingTarget - - // state maintained by startEdge and edgeCrossesCell. - crosser *EdgeCrosser - aj, bjPrev int - - // temporary data declared here to avoid repeated memory allocations. - bQuery *CrossingEdgeQuery - bCells []*ShapeIndexCell -} - -// newLoopCrosser creates a loopCrosser from the given values. If swapped is true, -// the loops A and B have been swapped. This affects how arguments are passed to -// the given loop relation, since for example A.Contains(B) is not the same as -// B.Contains(A). -func newLoopCrosser(a, b *Loop, relation loopRelation, swapped bool) *loopCrosser { - l := &loopCrosser{ - a: a, - b: b, - relation: relation, - swapped: swapped, - aCrossingTarget: relation.aCrossingTarget(), - bCrossingTarget: relation.bCrossingTarget(), - bQuery: NewCrossingEdgeQuery(b.index), - } - if swapped { - l.aCrossingTarget, l.bCrossingTarget = l.bCrossingTarget, l.aCrossingTarget - } - - return l -} - -// startEdge sets the crossers state for checking the given edge of loop A. -func (l *loopCrosser) startEdge(aj int) { - l.crosser = NewEdgeCrosser(l.a.Vertex(aj), l.a.Vertex(aj+1)) - l.aj = aj - l.bjPrev = -2 -} - -// edgeCrossesCell reports whether the current edge of loop A has any crossings with -// edges of the index cell of loop B. -func (l *loopCrosser) edgeCrossesCell(bClipped *clippedShape) bool { - // Test the current edge of A against all edges of bClipped - bNumEdges := bClipped.numEdges() - for j := 0; j < bNumEdges; j++ { - bj := bClipped.edges[j] - if bj != l.bjPrev+1 { - l.crosser.RestartAt(l.b.Vertex(bj)) - } - l.bjPrev = bj - if crossing := l.crosser.ChainCrossingSign(l.b.Vertex(bj + 1)); crossing == DoNotCross { - continue - } else if crossing == Cross { - return true - } - - // We only need to check each shared vertex once, so we only - // consider the case where l.aVertex(l.aj+1) == l.b.Vertex(bj+1). - if l.a.Vertex(l.aj+1) == l.b.Vertex(bj+1) { - if l.swapped { - if l.relation.wedgesCross(l.b.Vertex(bj), l.b.Vertex(bj+1), l.b.Vertex(bj+2), l.a.Vertex(l.aj), l.a.Vertex(l.aj+2)) { - return true - } - } else { - if l.relation.wedgesCross(l.a.Vertex(l.aj), l.a.Vertex(l.aj+1), l.a.Vertex(l.aj+2), l.b.Vertex(bj), l.b.Vertex(bj+2)) { - return true - } - } - } - } - - return false -} - -// cellCrossesCell reports whether there are any edge crossings or wedge crossings -// within the two given cells. -func (l *loopCrosser) cellCrossesCell(aClipped, bClipped *clippedShape) bool { - // Test all edges of aClipped against all edges of bClipped. - for _, edge := range aClipped.edges { - l.startEdge(edge) - if l.edgeCrossesCell(bClipped) { - return true - } - } - - return false -} - -// cellCrossesAnySubcell reports whether given an index cell of A, if there are any -// edge or wedge crossings with any index cell of B contained within bID. -func (l *loopCrosser) cellCrossesAnySubcell(aClipped *clippedShape, bID CellID) bool { - // Test all edges of aClipped against all edges of B. The relevant B - // edges are guaranteed to be children of bID, which lets us find the - // correct index cells more efficiently. - bRoot := PaddedCellFromCellID(bID, 0) - for _, aj := range aClipped.edges { - // Use an CrossingEdgeQuery starting at bRoot to find the index cells - // of B that might contain crossing edges. - l.bCells = l.bQuery.getCells(l.a.Vertex(aj), l.a.Vertex(aj+1), bRoot) - if len(l.bCells) == 0 { - continue - } - l.startEdge(aj) - for c := 0; c < len(l.bCells); c++ { - if l.edgeCrossesCell(l.bCells[c].shapes[0]) { - return true - } - } - } - - return false -} - -// hasCrossing reports whether given two iterators positioned such that -// ai.cellID().ContainsCellID(bi.cellID()), there is an edge or wedge crossing -// anywhere within ai.cellID(). This function advances bi only past ai.cellID(). -func (l *loopCrosser) hasCrossing(ai, bi *rangeIterator) bool { - // If ai.CellID() intersects many edges of B, then it is faster to use - // CrossingEdgeQuery to narrow down the candidates. But if it intersects - // only a few edges, it is faster to check all the crossings directly. - // We handle this by advancing bi and keeping track of how many edges we - // would need to test. - const edgeQueryMinEdges = 20 // Tuned from benchmarks. - var totalEdges int - l.bCells = nil - - for { - if n := bi.it.IndexCell().shapes[0].numEdges(); n > 0 { - totalEdges += n - if totalEdges >= edgeQueryMinEdges { - // There are too many edges to test them directly, so use CrossingEdgeQuery. - if l.cellCrossesAnySubcell(ai.it.IndexCell().shapes[0], ai.cellID()) { - return true - } - bi.seekBeyond(ai) - return false - } - l.bCells = append(l.bCells, bi.indexCell()) - } - bi.next() - if bi.cellID() > ai.rangeMax { - break - } - } - - // Test all the edge crossings directly. - for _, c := range l.bCells { - if l.cellCrossesCell(ai.it.IndexCell().shapes[0], c.shapes[0]) { - return true - } - } - - return false -} - -// containsCenterMatches reports if the clippedShapes containsCenter boolean corresponds -// to the crossing target type given. (This is to work around C++ allowing false == 0, -// true == 1 type implicit conversions and comparisons) -func containsCenterMatches(a *clippedShape, target crossingTarget) bool { - return (!a.containsCenter && target == crossingTargetDontCross) || - (a.containsCenter && target == crossingTargetCross) -} - -// hasCrossingRelation reports whether given two iterators positioned such that -// ai.cellID().ContainsCellID(bi.cellID()), there is a crossing relationship -// anywhere within ai.cellID(). Specifically, this method returns true if there -// is an edge crossing, a wedge crossing, or a point P that matches both relations -// crossing targets. This function advances both iterators past ai.cellID. -func (l *loopCrosser) hasCrossingRelation(ai, bi *rangeIterator) bool { - aClipped := ai.it.IndexCell().shapes[0] - if aClipped.numEdges() != 0 { - // The current cell of A has at least one edge, so check for crossings. - if l.hasCrossing(ai, bi) { - return true - } - ai.next() - return false - } - - if containsCenterMatches(aClipped, l.aCrossingTarget) { - // The crossing target for A is not satisfied, so we skip over these cells of B. - bi.seekBeyond(ai) - ai.next() - return false - } - - // All points within ai.cellID() satisfy the crossing target for A, so it's - // worth iterating through the cells of B to see whether any cell - // centers also satisfy the crossing target for B. - for bi.cellID() <= ai.rangeMax { - bClipped := bi.it.IndexCell().shapes[0] - if containsCenterMatches(bClipped, l.bCrossingTarget) { - return true - } - bi.next() - } - ai.next() - return false -} - -// hasCrossingRelation checks all edges of loop A for intersection against all edges -// of loop B and reports if there are any that satisfy the given relation. If there -// is any shared vertex, the wedges centered at this vertex are sent to the given -// relation to be tested. -// -// If the two loop boundaries cross, this method is guaranteed to return -// true. It also returns true in certain cases if the loop relationship is -// equivalent to crossing. For example, if the relation is Contains and a -// point P is found such that B contains P but A does not contain P, this -// method will return true to indicate that the result is the same as though -// a pair of crossing edges were found (since Contains returns false in -// both cases). -// -// See Contains, Intersects and CompareBoundary for the three uses of this function. -func hasCrossingRelation(a, b *Loop, relation loopRelation) bool { - // We look for CellID ranges where the indexes of A and B overlap, and - // then test those edges for crossings. - ai := newRangeIterator(a.index) - bi := newRangeIterator(b.index) - - ab := newLoopCrosser(a, b, relation, false) // Tests edges of A against B - ba := newLoopCrosser(b, a, relation, true) // Tests edges of B against A - - for !ai.done() || !bi.done() { - if ai.rangeMax < bi.rangeMin { - // The A and B cells don't overlap, and A precedes B. - ai.seekTo(bi) - } else if bi.rangeMax < ai.rangeMin { - // The A and B cells don't overlap, and B precedes A. - bi.seekTo(ai) - } else { - // One cell contains the other. Determine which cell is larger. - abRelation := int64(ai.it.CellID().lsb() - bi.it.CellID().lsb()) - if abRelation > 0 { - // A's index cell is larger. - if ab.hasCrossingRelation(ai, bi) { - return true - } - } else if abRelation < 0 { - // B's index cell is larger. - if ba.hasCrossingRelation(bi, ai) { - return true - } - } else { - // The A and B cells are the same. Since the two cells - // have the same center point P, check whether P satisfies - // the crossing targets. - aClipped := ai.it.IndexCell().shapes[0] - bClipped := bi.it.IndexCell().shapes[0] - if containsCenterMatches(aClipped, ab.aCrossingTarget) && - containsCenterMatches(bClipped, ab.bCrossingTarget) { - return true - } - // Otherwise test all the edge crossings directly. - if aClipped.numEdges() > 0 && bClipped.numEdges() > 0 && ab.cellCrossesCell(aClipped, bClipped) { - return true - } - ai.next() - bi.next() - } - } - } - return false -} - -// containsRelation implements loopRelation for a contains operation. If -// A.ContainsPoint(P) == false && B.ContainsPoint(P) == true, it is equivalent -// to having an edge crossing (i.e., Contains returns false). -type containsRelation struct { - foundSharedVertex bool -} - -func (c *containsRelation) aCrossingTarget() crossingTarget { return crossingTargetDontCross } -func (c *containsRelation) bCrossingTarget() crossingTarget { return crossingTargetCross } -func (c *containsRelation) wedgesCross(a0, ab1, a2, b0, b2 Point) bool { - c.foundSharedVertex = true - return !WedgeContains(a0, ab1, a2, b0, b2) -} - -// intersectsRelation implements loopRelation for an intersects operation. Given -// two loops, A and B, if A.ContainsPoint(P) == true && B.ContainsPoint(P) == true, -// it is equivalent to having an edge crossing (i.e., Intersects returns true). -type intersectsRelation struct { - foundSharedVertex bool -} - -func (i *intersectsRelation) aCrossingTarget() crossingTarget { return crossingTargetCross } -func (i *intersectsRelation) bCrossingTarget() crossingTarget { return crossingTargetCross } -func (i *intersectsRelation) wedgesCross(a0, ab1, a2, b0, b2 Point) bool { - i.foundSharedVertex = true - return WedgeIntersects(a0, ab1, a2, b0, b2) -} - -// compareBoundaryRelation implements loopRelation for comparing boundaries. -// -// The compare boundary relation does not have a useful early-exit condition, -// so we return crossingTargetDontCare for both crossing targets. -// -// Aside: A possible early exit condition could be based on the following. -// If A contains a point of both B and ~B, then A intersects Boundary(B). -// If ~A contains a point of both B and ~B, then ~A intersects Boundary(B). -// So if the intersections of {A, ~A} with {B, ~B} are all non-empty, -// the return value is 0, i.e., Boundary(A) intersects Boundary(B). -// Unfortunately it isn't worth detecting this situation because by the -// time we have seen a point in all four intersection regions, we are also -// guaranteed to have seen at least one pair of crossing edges. -type compareBoundaryRelation struct { - reverse bool // True if the other loop should be reversed. - foundSharedVertex bool // True if any wedge was processed. - containsEdge bool // True if any edge of the other loop is contained by this loop. - excludesEdge bool // True if any edge of the other loop is excluded by this loop. -} - -func newCompareBoundaryRelation(reverse bool) *compareBoundaryRelation { - return &compareBoundaryRelation{reverse: reverse} -} - -func (c *compareBoundaryRelation) aCrossingTarget() crossingTarget { return crossingTargetDontCare } -func (c *compareBoundaryRelation) bCrossingTarget() crossingTarget { return crossingTargetDontCare } -func (c *compareBoundaryRelation) wedgesCross(a0, ab1, a2, b0, b2 Point) bool { - // Because we don't care about the interior of the other, only its boundary, - // it is sufficient to check whether this one contains the semiwedge (ab1, b2). - c.foundSharedVertex = true - if wedgeContainsSemiwedge(a0, ab1, a2, b2, c.reverse) { - c.containsEdge = true - } else { - c.excludesEdge = true - } - return c.containsEdge && c.excludesEdge -} - -// wedgeContainsSemiwedge reports whether the wedge (a0, ab1, a2) contains the -// "semiwedge" defined as any non-empty open set of rays immediately CCW from -// the edge (ab1, b2). If reverse is true, then substitute clockwise for CCW; -// this simulates what would happen if the direction of the other loop was reversed. -func wedgeContainsSemiwedge(a0, ab1, a2, b2 Point, reverse bool) bool { - if b2 == a0 || b2 == a2 { - // We have a shared or reversed edge. - return (b2 == a0) == reverse - } - return OrderedCCW(a0, a2, b2, ab1) -} - -// containsNonCrossingBoundary reports whether given two loops whose boundaries -// do not cross (see compareBoundary), if this loop contains the boundary of the -// other loop. If reverse is true, the boundary of the other loop is reversed -// first (which only affects the result when there are shared edges). This method -// is cheaper than compareBoundary because it does not test for edge intersections. -// -// This function requires that neither loop is empty, and that if the other is full, -// then reverse == false. -func (l *Loop) containsNonCrossingBoundary(other *Loop, reverseOther bool) bool { - // The bounds must intersect for containment. - if !l.bound.Intersects(other.bound) { - return false - } - - // Full loops are handled as though the loop surrounded the entire sphere. - if l.IsFull() { - return true - } - if other.IsFull() { - return false - } - - m, ok := l.findVertex(other.Vertex(0)) - if !ok { - // Since the other loops vertex 0 is not shared, we can check if this contains it. - return l.ContainsPoint(other.Vertex(0)) - } - // Otherwise check whether the edge (b0, b1) is contained by this loop. - return wedgeContainsSemiwedge(l.Vertex(m-1), l.Vertex(m), l.Vertex(m+1), - other.Vertex(1), reverseOther) -} - -// TODO(roberts): Differences from the C++ version: -// DistanceToPoint -// DistanceToBoundary -// Project -// ProjectToBoundary -// BoundaryApproxEqual -// BoundaryNear diff --git a/vendor/github.com/golang/geo/s2/matrix3x3.go b/vendor/github.com/golang/geo/s2/matrix3x3.go deleted file mode 100644 index 01696fe83..000000000 --- a/vendor/github.com/golang/geo/s2/matrix3x3.go +++ /dev/null @@ -1,127 +0,0 @@ -// Copyright 2015 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - - "github.com/golang/geo/r3" -) - -// matrix3x3 represents a traditional 3x3 matrix of floating point values. -// This is not a full fledged matrix. It only contains the pieces needed -// to satisfy the computations done within the s2 package. -type matrix3x3 [3][3]float64 - -// col returns the given column as a Point. -func (m *matrix3x3) col(col int) Point { - return Point{r3.Vector{m[0][col], m[1][col], m[2][col]}} -} - -// row returns the given row as a Point. -func (m *matrix3x3) row(row int) Point { - return Point{r3.Vector{m[row][0], m[row][1], m[row][2]}} -} - -// setCol sets the specified column to the value in the given Point. -func (m *matrix3x3) setCol(col int, p Point) *matrix3x3 { - m[0][col] = p.X - m[1][col] = p.Y - m[2][col] = p.Z - - return m -} - -// setRow sets the specified row to the value in the given Point. -func (m *matrix3x3) setRow(row int, p Point) *matrix3x3 { - m[row][0] = p.X - m[row][1] = p.Y - m[row][2] = p.Z - - return m -} - -// scale multiplies the matrix by the given value. -func (m *matrix3x3) scale(f float64) *matrix3x3 { - return &matrix3x3{ - [3]float64{f * m[0][0], f * m[0][1], f * m[0][2]}, - [3]float64{f * m[1][0], f * m[1][1], f * m[1][2]}, - [3]float64{f * m[2][0], f * m[2][1], f * m[2][2]}, - } -} - -// mul returns the multiplication of m by the Point p and converts the -// resulting 1x3 matrix into a Point. -func (m *matrix3x3) mul(p Point) Point { - return Point{r3.Vector{ - m[0][0]*p.X + m[0][1]*p.Y + m[0][2]*p.Z, - m[1][0]*p.X + m[1][1]*p.Y + m[1][2]*p.Z, - m[2][0]*p.X + m[2][1]*p.Y + m[2][2]*p.Z, - }} -} - -// det returns the determinant of this matrix. -func (m *matrix3x3) det() float64 { - // | a b c | - // det | d e f | = aei + bfg + cdh - ceg - bdi - afh - // | g h i | - return m[0][0]*m[1][1]*m[2][2] + m[0][1]*m[1][2]*m[2][0] + m[0][2]*m[1][0]*m[2][1] - - m[0][2]*m[1][1]*m[2][0] - m[0][1]*m[1][0]*m[2][2] - m[0][0]*m[1][2]*m[2][1] -} - -// transpose reflects the matrix along its diagonal and returns the result. -func (m *matrix3x3) transpose() *matrix3x3 { - m[0][1], m[1][0] = m[1][0], m[0][1] - m[0][2], m[2][0] = m[2][0], m[0][2] - m[1][2], m[2][1] = m[2][1], m[1][2] - - return m -} - -// String formats the matrix into an easier to read layout. -func (m *matrix3x3) String() string { - return fmt.Sprintf("[ %0.4f %0.4f %0.4f ] [ %0.4f %0.4f %0.4f ] [ %0.4f %0.4f %0.4f ]", - m[0][0], m[0][1], m[0][2], - m[1][0], m[1][1], m[1][2], - m[2][0], m[2][1], m[2][2], - ) -} - -// getFrame returns the orthonormal frame for the given point on the unit sphere. -func getFrame(p Point) matrix3x3 { - // Given the point p on the unit sphere, extend this into a right-handed - // coordinate frame of unit-length column vectors m = (x,y,z). Note that - // the vectors (x,y) are an orthonormal frame for the tangent space at point p, - // while p itself is an orthonormal frame for the normal space at p. - m := matrix3x3{} - m.setCol(2, p) - m.setCol(1, Point{p.Ortho()}) - m.setCol(0, Point{m.col(1).Cross(p.Vector)}) - return m -} - -// toFrame returns the coordinates of the given point with respect to its orthonormal basis m. -// The resulting point q satisfies the identity (m * q == p). -func toFrame(m matrix3x3, p Point) Point { - // The inverse of an orthonormal matrix is its transpose. - return m.transpose().mul(p) -} - -// fromFrame returns the coordinates of the given point in standard axis-aligned basis -// from its orthonormal basis m. -// The resulting point p satisfies the identity (p == m * q). -func fromFrame(m matrix3x3, q Point) Point { - return m.mul(q) -} diff --git a/vendor/github.com/golang/geo/s2/max_distance_targets.go b/vendor/github.com/golang/geo/s2/max_distance_targets.go deleted file mode 100644 index 92e916d98..000000000 --- a/vendor/github.com/golang/geo/s2/max_distance_targets.go +++ /dev/null @@ -1,306 +0,0 @@ -// Copyright 2019 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/s1" -) - -// maxDistance implements distance as the supplementary distance (Pi - x) to find -// results that are the furthest using the distance related algorithms. -type maxDistance s1.ChordAngle - -func (m maxDistance) chordAngle() s1.ChordAngle { return s1.ChordAngle(m) } -func (m maxDistance) zero() distance { return maxDistance(s1.StraightChordAngle) } -func (m maxDistance) negative() distance { return maxDistance(s1.InfChordAngle()) } -func (m maxDistance) infinity() distance { return maxDistance(s1.NegativeChordAngle) } -func (m maxDistance) less(other distance) bool { return m.chordAngle() > other.chordAngle() } -func (m maxDistance) sub(other distance) distance { - return maxDistance(m.chordAngle() + other.chordAngle()) -} -func (m maxDistance) chordAngleBound() s1.ChordAngle { - return s1.StraightChordAngle - m.chordAngle() -} -func (m maxDistance) updateDistance(dist distance) (distance, bool) { - if dist.less(m) { - m = maxDistance(dist.chordAngle()) - return m, true - } - return m, false -} - -func (m maxDistance) fromChordAngle(o s1.ChordAngle) distance { - return maxDistance(o) -} - -// MaxDistanceToPointTarget is used for computing the maximum distance to a Point. -type MaxDistanceToPointTarget struct { - point Point - dist distance -} - -// NewMaxDistanceToPointTarget returns a new target for the given Point. -func NewMaxDistanceToPointTarget(point Point) *MaxDistanceToPointTarget { - m := maxDistance(0) - return &MaxDistanceToPointTarget{point: point, dist: &m} -} - -func (m *MaxDistanceToPointTarget) capBound() Cap { - return CapFromCenterChordAngle(Point{m.point.Mul(-1)}, (s1.ChordAngle(0))) -} - -func (m *MaxDistanceToPointTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - return dist.updateDistance(maxDistance(ChordAngleBetweenPoints(p, m.point))) -} - -func (m *MaxDistanceToPointTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - if d, ok := UpdateMaxDistance(m.point, edge.V0, edge.V1, dist.chordAngle()); ok { - dist, _ = dist.updateDistance(maxDistance(d)) - return dist, true - } - return dist, false -} - -func (m *MaxDistanceToPointTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - return dist.updateDistance(maxDistance(cell.MaxDistance(m.point))) -} - -func (m *MaxDistanceToPointTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // For furthest points, we visit the polygons whose interior contains - // the antipode of the target point. These are the polygons whose - // distance to the target is maxDistance.zero() - q := NewContainsPointQuery(index, VertexModelSemiOpen) - return q.visitContainingShapes(Point{m.point.Mul(-1)}, func(shape Shape) bool { - return v(shape, m.point) - }) -} - -func (m *MaxDistanceToPointTarget) setMaxError(maxErr s1.ChordAngle) bool { return false } -func (m *MaxDistanceToPointTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MaxDistanceToPointTarget) distance() distance { return m.dist } - -// MaxDistanceToEdgeTarget is used for computing the maximum distance to an Edge. -type MaxDistanceToEdgeTarget struct { - e Edge - dist distance -} - -// NewMaxDistanceToEdgeTarget returns a new target for the given Edge. -func NewMaxDistanceToEdgeTarget(e Edge) *MaxDistanceToEdgeTarget { - m := maxDistance(0) - return &MaxDistanceToEdgeTarget{e: e, dist: m} -} - -// capBound returns a Cap that bounds the antipode of the target. (This -// is the set of points whose maxDistance to the target is maxDistance.zero) -func (m *MaxDistanceToEdgeTarget) capBound() Cap { - // The following computes a radius equal to half the edge length in an - // efficient and numerically stable way. - d2 := float64(ChordAngleBetweenPoints(m.e.V0, m.e.V1)) - r2 := (0.5 * d2) / (1 + math.Sqrt(1-0.25*d2)) - return CapFromCenterChordAngle(Point{m.e.V0.Add(m.e.V1.Vector).Mul(-1).Normalize()}, s1.ChordAngleFromSquaredLength(r2)) -} - -func (m *MaxDistanceToEdgeTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - if d, ok := UpdateMaxDistance(p, m.e.V0, m.e.V1, dist.chordAngle()); ok { - dist, _ = dist.updateDistance(maxDistance(d)) - return dist, true - } - return dist, false -} - -func (m *MaxDistanceToEdgeTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - if d, ok := updateEdgePairMaxDistance(m.e.V0, m.e.V1, edge.V0, edge.V1, dist.chordAngle()); ok { - dist, _ = dist.updateDistance(maxDistance(d)) - return dist, true - } - return dist, false -} - -func (m *MaxDistanceToEdgeTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - return dist.updateDistance(maxDistance(cell.MaxDistanceToEdge(m.e.V0, m.e.V1))) -} - -func (m *MaxDistanceToEdgeTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // We only need to test one edge point. That is because the method *must* - // visit a polygon if it fully contains the target, and *is allowed* to - // visit a polygon if it intersects the target. If the tested vertex is not - // contained, we know the full edge is not contained; if the tested vertex is - // contained, then the edge either is fully contained (must be visited) or it - // intersects (is allowed to be visited). We visit the center of the edge so - // that edge AB gives identical results to BA. - target := NewMaxDistanceToPointTarget(Point{m.e.V0.Add(m.e.V1.Vector).Normalize()}) - return target.visitContainingShapes(index, v) -} - -func (m *MaxDistanceToEdgeTarget) setMaxError(maxErr s1.ChordAngle) bool { return false } -func (m *MaxDistanceToEdgeTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MaxDistanceToEdgeTarget) distance() distance { return m.dist } - -// MaxDistanceToCellTarget is used for computing the maximum distance to a Cell. -type MaxDistanceToCellTarget struct { - cell Cell - dist distance -} - -// NewMaxDistanceToCellTarget returns a new target for the given Cell. -func NewMaxDistanceToCellTarget(cell Cell) *MaxDistanceToCellTarget { - m := maxDistance(0) - return &MaxDistanceToCellTarget{cell: cell, dist: m} -} - -func (m *MaxDistanceToCellTarget) capBound() Cap { - c := m.cell.CapBound() - return CapFromCenterAngle(Point{c.Center().Mul(-1)}, c.Radius()) -} - -func (m *MaxDistanceToCellTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - return dist.updateDistance(maxDistance(m.cell.MaxDistance(p))) -} - -func (m *MaxDistanceToCellTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - return dist.updateDistance(maxDistance(m.cell.MaxDistanceToEdge(edge.V0, edge.V1))) -} - -func (m *MaxDistanceToCellTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - return dist.updateDistance(maxDistance(m.cell.MaxDistanceToCell(cell))) -} - -func (m *MaxDistanceToCellTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // We only need to check one point here - cell center is simplest. - // See comment at MaxDistanceToEdgeTarget's visitContainingShapes. - target := NewMaxDistanceToPointTarget(m.cell.Center()) - return target.visitContainingShapes(index, v) -} - -func (m *MaxDistanceToCellTarget) setMaxError(maxErr s1.ChordAngle) bool { return false } -func (m *MaxDistanceToCellTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MaxDistanceToCellTarget) distance() distance { return m.dist } - -// MaxDistanceToShapeIndexTarget is used for computing the maximum distance to a ShapeIndex. -type MaxDistanceToShapeIndexTarget struct { - index *ShapeIndex - query *EdgeQuery - dist distance -} - -// NewMaxDistanceToShapeIndexTarget returns a new target for the given ShapeIndex. -func NewMaxDistanceToShapeIndexTarget(index *ShapeIndex) *MaxDistanceToShapeIndexTarget { - m := maxDistance(0) - return &MaxDistanceToShapeIndexTarget{ - index: index, - dist: m, - query: NewFurthestEdgeQuery(index, NewFurthestEdgeQueryOptions()), - } -} - -// capBound returns a Cap that bounds the antipode of the target. This -// is the set of points whose maxDistance to the target is maxDistance.zero() -func (m *MaxDistanceToShapeIndexTarget) capBound() Cap { - // TODO(roberts): Depends on ShapeIndexRegion - // c := makeShapeIndexRegion(m.index).CapBound() - // return CapFromCenterRadius(Point{c.Center.Mul(-1)}, c.Radius()) - panic("not implemented yet") -} - -func (m *MaxDistanceToShapeIndexTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - m.query.opts.distanceLimit = dist.chordAngle() - target := NewMaxDistanceToPointTarget(p) - r := m.query.findEdge(target, m.query.opts) - if r.shapeID < 0 { - return dist, false - } - return r.distance, true -} - -func (m *MaxDistanceToShapeIndexTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - m.query.opts.distanceLimit = dist.chordAngle() - target := NewMaxDistanceToEdgeTarget(edge) - r := m.query.findEdge(target, m.query.opts) - if r.shapeID < 0 { - return dist, false - } - return r.distance, true -} - -func (m *MaxDistanceToShapeIndexTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - m.query.opts.distanceLimit = dist.chordAngle() - target := NewMaxDistanceToCellTarget(cell) - r := m.query.findEdge(target, m.query.opts) - if r.shapeID < 0 { - return dist, false - } - return r.distance, true -} - -// visitContainingShapes returns the polygons containing the antipodal -// reflection of *any* connected component for target types consisting of -// multiple connected components. It is sufficient to test containment of -// one vertex per connected component, since this allows us to also return -// any polygon whose boundary has distance.zero() to the target. -func (m *MaxDistanceToShapeIndexTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // It is sufficient to find the set of chain starts in the target index - // (i.e., one vertex per connected component of edges) that are contained by - // the query index, except for one special case to handle full polygons. - // - // TODO(roberts): Do this by merge-joining the two ShapeIndexes and share - // the code with BooleanOperation. - for _, shape := range m.index.shapes { - numChains := shape.NumChains() - // Shapes that don't have any edges require a special case (below). - testedPoint := false - for c := 0; c < numChains; c++ { - chain := shape.Chain(c) - if chain.Length == 0 { - continue - } - testedPoint = true - target := NewMaxDistanceToPointTarget(shape.ChainEdge(c, 0).V0) - if !target.visitContainingShapes(index, v) { - return false - } - } - if !testedPoint { - // Special case to handle full polygons. - ref := shape.ReferencePoint() - if !ref.Contained { - continue - } - target := NewMaxDistanceToPointTarget(ref.Point) - if !target.visitContainingShapes(index, v) { - return false - } - } - } - return true -} - -func (m *MaxDistanceToShapeIndexTarget) setMaxError(maxErr s1.ChordAngle) bool { - m.query.opts.maxError = maxErr - return true -} -func (m *MaxDistanceToShapeIndexTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MaxDistanceToShapeIndexTarget) distance() distance { return m.dist } -func (m *MaxDistanceToShapeIndexTarget) setIncludeInteriors(b bool) { - m.query.opts.includeInteriors = b -} -func (m *MaxDistanceToShapeIndexTarget) setUseBruteForce(b bool) { m.query.opts.useBruteForce = b } - -// TODO(roberts): Remaining methods -// -// func (m *MaxDistanceToShapeIndexTarget) capBound() Cap { -// CellUnionTarget diff --git a/vendor/github.com/golang/geo/s2/metric.go b/vendor/github.com/golang/geo/s2/metric.go deleted file mode 100644 index 53db3d317..000000000 --- a/vendor/github.com/golang/geo/s2/metric.go +++ /dev/null @@ -1,164 +0,0 @@ -// Copyright 2015 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// This file implements functions for various S2 measurements. - -import "math" - -// A Metric is a measure for cells. It is used to describe the shape and size -// of cells. They are useful for deciding which cell level to use in order to -// satisfy a given condition (e.g. that cell vertices must be no further than -// "x" apart). You can use the Value(level) method to compute the corresponding -// length or area on the unit sphere for cells at a given level. The minimum -// and maximum bounds are valid for cells at all levels, but they may be -// somewhat conservative for very large cells (e.g. face cells). -type Metric struct { - // Dim is either 1 or 2, for a 1D or 2D metric respectively. - Dim int - // Deriv is the scaling factor for the metric. - Deriv float64 -} - -// Defined metrics. -// Of the projection methods defined in C++, Go only supports the quadratic projection. - -// Each cell is bounded by four planes passing through its four edges and -// the center of the sphere. These metrics relate to the angle between each -// pair of opposite bounding planes, or equivalently, between the planes -// corresponding to two different s-values or two different t-values. -var ( - MinAngleSpanMetric = Metric{1, 4.0 / 3} - AvgAngleSpanMetric = Metric{1, math.Pi / 2} - MaxAngleSpanMetric = Metric{1, 1.704897179199218452} -) - -// The width of geometric figure is defined as the distance between two -// parallel bounding lines in a given direction. For cells, the minimum -// width is always attained between two opposite edges, and the maximum -// width is attained between two opposite vertices. However, for our -// purposes we redefine the width of a cell as the perpendicular distance -// between a pair of opposite edges. A cell therefore has two widths, one -// in each direction. The minimum width according to this definition agrees -// with the classic geometric one, but the maximum width is different. (The -// maximum geometric width corresponds to MaxDiag defined below.) -// -// The average width in both directions for all cells at level k is approximately -// AvgWidthMetric.Value(k). -// -// The width is useful for bounding the minimum or maximum distance from a -// point on one edge of a cell to the closest point on the opposite edge. -// For example, this is useful when growing regions by a fixed distance. -var ( - MinWidthMetric = Metric{1, 2 * math.Sqrt2 / 3} - AvgWidthMetric = Metric{1, 1.434523672886099389} - MaxWidthMetric = Metric{1, MaxAngleSpanMetric.Deriv} -) - -// The edge length metrics can be used to bound the minimum, maximum, -// or average distance from the center of one cell to the center of one of -// its edge neighbors. In particular, it can be used to bound the distance -// between adjacent cell centers along the space-filling Hilbert curve for -// cells at any given level. -var ( - MinEdgeMetric = Metric{1, 2 * math.Sqrt2 / 3} - AvgEdgeMetric = Metric{1, 1.459213746386106062} - MaxEdgeMetric = Metric{1, MaxAngleSpanMetric.Deriv} - - // MaxEdgeAspect is the maximum edge aspect ratio over all cells at any level, - // where the edge aspect ratio of a cell is defined as the ratio of its longest - // edge length to its shortest edge length. - MaxEdgeAspect = 1.442615274452682920 - - MinAreaMetric = Metric{2, 8 * math.Sqrt2 / 9} - AvgAreaMetric = Metric{2, 4 * math.Pi / 6} - MaxAreaMetric = Metric{2, 2.635799256963161491} -) - -// The maximum diagonal is also the maximum diameter of any cell, -// and also the maximum geometric width (see the comment for widths). For -// example, the distance from an arbitrary point to the closest cell center -// at a given level is at most half the maximum diagonal length. -var ( - MinDiagMetric = Metric{1, 8 * math.Sqrt2 / 9} - AvgDiagMetric = Metric{1, 2.060422738998471683} - MaxDiagMetric = Metric{1, 2.438654594434021032} - - // MaxDiagAspect is the maximum diagonal aspect ratio over all cells at any - // level, where the diagonal aspect ratio of a cell is defined as the ratio - // of its longest diagonal length to its shortest diagonal length. - MaxDiagAspect = math.Sqrt(3) -) - -// Value returns the value of the metric at the given level. -func (m Metric) Value(level int) float64 { - return math.Ldexp(m.Deriv, -m.Dim*level) -} - -// MinLevel returns the minimum level such that the metric is at most -// the given value, or maxLevel (30) if there is no such level. -// -// For example, MinLevel(0.1) returns the minimum level such that all cell diagonal -// lengths are 0.1 or smaller. The returned value is always a valid level. -// -// In C++, this is called GetLevelForMaxValue. -func (m Metric) MinLevel(val float64) int { - if val < 0 { - return maxLevel - } - - level := -(math.Ilogb(val/m.Deriv) >> uint(m.Dim-1)) - if level > maxLevel { - level = maxLevel - } - if level < 0 { - level = 0 - } - return level -} - -// MaxLevel returns the maximum level such that the metric is at least -// the given value, or zero if there is no such level. -// -// For example, MaxLevel(0.1) returns the maximum level such that all cells have a -// minimum width of 0.1 or larger. The returned value is always a valid level. -// -// In C++, this is called GetLevelForMinValue. -func (m Metric) MaxLevel(val float64) int { - if val <= 0 { - return maxLevel - } - - level := math.Ilogb(m.Deriv/val) >> uint(m.Dim-1) - if level > maxLevel { - level = maxLevel - } - if level < 0 { - level = 0 - } - return level -} - -// ClosestLevel returns the level at which the metric has approximately the given -// value. The return value is always a valid level. For example, -// AvgEdgeMetric.ClosestLevel(0.1) returns the level at which the average cell edge -// length is approximately 0.1. -func (m Metric) ClosestLevel(val float64) int { - x := math.Sqrt2 - if m.Dim == 2 { - x = 2 - } - return m.MinLevel(x * val) -} diff --git a/vendor/github.com/golang/geo/s2/min_distance_targets.go b/vendor/github.com/golang/geo/s2/min_distance_targets.go deleted file mode 100644 index b4cbd43ef..000000000 --- a/vendor/github.com/golang/geo/s2/min_distance_targets.go +++ /dev/null @@ -1,362 +0,0 @@ -// Copyright 2019 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/s1" -) - -// minDistance implements distance interface to find closest distance types. -type minDistance s1.ChordAngle - -func (m minDistance) chordAngle() s1.ChordAngle { return s1.ChordAngle(m) } -func (m minDistance) zero() distance { return minDistance(0) } -func (m minDistance) negative() distance { return minDistance(s1.NegativeChordAngle) } -func (m minDistance) infinity() distance { return minDistance(s1.InfChordAngle()) } -func (m minDistance) less(other distance) bool { return m.chordAngle() < other.chordAngle() } -func (m minDistance) sub(other distance) distance { - return minDistance(m.chordAngle() - other.chordAngle()) -} -func (m minDistance) chordAngleBound() s1.ChordAngle { - return m.chordAngle().Expanded(m.chordAngle().MaxAngleError()) -} - -// updateDistance updates its own value if the other value is less() than it is, -// and reports if it updated. -func (m minDistance) updateDistance(dist distance) (distance, bool) { - if dist.less(m) { - m = minDistance(dist.chordAngle()) - return m, true - } - return m, false -} - -func (m minDistance) fromChordAngle(o s1.ChordAngle) distance { - return minDistance(o) -} - -// MinDistanceToPointTarget is a type for computing the minimum distance to a Point. -type MinDistanceToPointTarget struct { - point Point - dist distance -} - -// NewMinDistanceToPointTarget returns a new target for the given Point. -func NewMinDistanceToPointTarget(point Point) *MinDistanceToPointTarget { - m := minDistance(0) - return &MinDistanceToPointTarget{point: point, dist: &m} -} - -func (m *MinDistanceToPointTarget) capBound() Cap { - return CapFromCenterChordAngle(m.point, s1.ChordAngle(0)) -} - -func (m *MinDistanceToPointTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - var ok bool - dist, ok = dist.updateDistance(minDistance(ChordAngleBetweenPoints(p, m.point))) - return dist, ok -} - -func (m *MinDistanceToPointTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - if d, ok := UpdateMinDistance(m.point, edge.V0, edge.V1, dist.chordAngle()); ok { - dist, _ = dist.updateDistance(minDistance(d)) - return dist, true - } - return dist, false -} - -func (m *MinDistanceToPointTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - var ok bool - dist, ok = dist.updateDistance(minDistance(cell.Distance(m.point))) - return dist, ok -} - -func (m *MinDistanceToPointTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // For furthest points, we visit the polygons whose interior contains - // the antipode of the target point. These are the polygons whose - // distance to the target is maxDistance.zero() - q := NewContainsPointQuery(index, VertexModelSemiOpen) - return q.visitContainingShapes(m.point, func(shape Shape) bool { - return v(shape, m.point) - }) -} - -func (m *MinDistanceToPointTarget) setMaxError(maxErr s1.ChordAngle) bool { return false } -func (m *MinDistanceToPointTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MinDistanceToPointTarget) distance() distance { return m.dist } - -// ---------------------------------------------------------- - -// MinDistanceToEdgeTarget is a type for computing the minimum distance to an Edge. -type MinDistanceToEdgeTarget struct { - e Edge - dist distance -} - -// NewMinDistanceToEdgeTarget returns a new target for the given Edge. -func NewMinDistanceToEdgeTarget(e Edge) *MinDistanceToEdgeTarget { - m := minDistance(0) - return &MinDistanceToEdgeTarget{e: e, dist: m} -} - -// capBound returns a Cap that bounds the antipode of the target. (This -// is the set of points whose maxDistance to the target is maxDistance.zero) -func (m *MinDistanceToEdgeTarget) capBound() Cap { - // The following computes a radius equal to half the edge length in an - // efficient and numerically stable way. - d2 := float64(ChordAngleBetweenPoints(m.e.V0, m.e.V1)) - r2 := (0.5 * d2) / (1 + math.Sqrt(1-0.25*d2)) - return CapFromCenterChordAngle(Point{m.e.V0.Add(m.e.V1.Vector).Normalize()}, s1.ChordAngleFromSquaredLength(r2)) -} - -func (m *MinDistanceToEdgeTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - if d, ok := UpdateMinDistance(p, m.e.V0, m.e.V1, dist.chordAngle()); ok { - dist, _ = dist.updateDistance(minDistance(d)) - return dist, true - } - return dist, false -} - -func (m *MinDistanceToEdgeTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - if d, ok := updateEdgePairMinDistance(m.e.V0, m.e.V1, edge.V0, edge.V1, dist.chordAngle()); ok { - dist, _ = dist.updateDistance(minDistance(d)) - return dist, true - } - return dist, false -} - -func (m *MinDistanceToEdgeTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - return dist.updateDistance(minDistance(cell.DistanceToEdge(m.e.V0, m.e.V1))) -} - -func (m *MinDistanceToEdgeTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // We test the center of the edge in order to ensure that edge targets AB - // and BA yield identical results (which is not guaranteed by the API but - // users might expect). Other options would be to test both endpoints, or - // return different results for AB and BA in some cases. - target := NewMinDistanceToPointTarget(Point{m.e.V0.Add(m.e.V1.Vector).Normalize()}) - return target.visitContainingShapes(index, v) -} - -func (m *MinDistanceToEdgeTarget) setMaxError(maxErr s1.ChordAngle) bool { return false } -func (m *MinDistanceToEdgeTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MinDistanceToEdgeTarget) distance() distance { return m.dist } - -// ---------------------------------------------------------- - -// MinDistanceToCellTarget is a type for computing the minimum distance to a Cell. -type MinDistanceToCellTarget struct { - cell Cell - dist distance -} - -// NewMinDistanceToCellTarget returns a new target for the given Cell. -func NewMinDistanceToCellTarget(cell Cell) *MinDistanceToCellTarget { - m := minDistance(0) - return &MinDistanceToCellTarget{cell: cell, dist: m} -} - -func (m *MinDistanceToCellTarget) capBound() Cap { - return m.cell.CapBound() -} - -func (m *MinDistanceToCellTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - return dist.updateDistance(minDistance(m.cell.Distance(p))) -} - -func (m *MinDistanceToCellTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - return dist.updateDistance(minDistance(m.cell.DistanceToEdge(edge.V0, edge.V1))) -} - -func (m *MinDistanceToCellTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - return dist.updateDistance(minDistance(m.cell.DistanceToCell(cell))) -} - -func (m *MinDistanceToCellTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // The simplest approach is simply to return the polygons that contain the - // cell center. Alternatively, if the index cell is smaller than the target - // cell then we could return all polygons that are present in the - // shapeIndexCell, but since the index is built conservatively this may - // include some polygons that don't quite intersect the cell. So we would - // either need to recheck for intersection more accurately, or weaken the - // VisitContainingShapes contract so that it only guarantees approximate - // intersection, neither of which seems like a good tradeoff. - target := NewMinDistanceToPointTarget(m.cell.Center()) - return target.visitContainingShapes(index, v) -} -func (m *MinDistanceToCellTarget) setMaxError(maxErr s1.ChordAngle) bool { return false } -func (m *MinDistanceToCellTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MinDistanceToCellTarget) distance() distance { return m.dist } - -// ---------------------------------------------------------- - -/* -// MinDistanceToCellUnionTarget is a type for computing the minimum distance to a CellUnion. -type MinDistanceToCellUnionTarget struct { - cu CellUnion - query *ClosestCellQuery - dist distance -} - -// NewMinDistanceToCellUnionTarget returns a new target for the given CellUnion. -func NewMinDistanceToCellUnionTarget(cu CellUnion) *MinDistanceToCellUnionTarget { - m := minDistance(0) - return &MinDistanceToCellUnionTarget{cu: cu, dist: m} -} - -func (m *MinDistanceToCellUnionTarget) capBound() Cap { - return m.cu.CapBound() -} - -func (m *MinDistanceToCellUnionTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - m.query.opts.DistanceLimit = dist.chordAngle() - target := NewMinDistanceToPointTarget(p) - r := m.query.findEdge(target) - if r.ShapeID < 0 { - return dist, false - } - return minDistance(r.Distance), true -} - -func (m *MinDistanceToCellUnionTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // We test the center of the edge in order to ensure that edge targets AB - // and BA yield identical results (which is not guaranteed by the API but - // users might expect). Other options would be to test both endpoints, or - // return different results for AB and BA in some cases. - target := NewMinDistanceToPointTarget(Point{m.e.V0.Add(m.e.V1.Vector).Normalize()}) - return target.visitContainingShapes(index, v) -} -func (m *MinDistanceToCellUnionTarget) setMaxError(maxErr s1.ChordAngle) bool { - m.query.opts.MaxError = maxErr - return true -} -func (m *MinDistanceToCellUnionTarget) maxBruteForceIndexSize() int { return 30 } -func (m *MinDistanceToCellUnionTarget) distance() distance { return m.dist } -*/ - -// ---------------------------------------------------------- - -// MinDistanceToShapeIndexTarget is a type for computing the minimum distance to a ShapeIndex. -type MinDistanceToShapeIndexTarget struct { - index *ShapeIndex - query *EdgeQuery - dist distance -} - -// NewMinDistanceToShapeIndexTarget returns a new target for the given ShapeIndex. -func NewMinDistanceToShapeIndexTarget(index *ShapeIndex) *MinDistanceToShapeIndexTarget { - m := minDistance(0) - return &MinDistanceToShapeIndexTarget{ - index: index, - dist: m, - query: NewClosestEdgeQuery(index, NewClosestEdgeQueryOptions()), - } -} - -func (m *MinDistanceToShapeIndexTarget) capBound() Cap { - // TODO(roberts): Depends on ShapeIndexRegion existing. - // c := makeS2ShapeIndexRegion(m.index).CapBound() - // return CapFromCenterRadius(Point{c.Center.Mul(-1)}, c.Radius()) - panic("not implemented yet") -} - -func (m *MinDistanceToShapeIndexTarget) updateDistanceToPoint(p Point, dist distance) (distance, bool) { - m.query.opts.distanceLimit = dist.chordAngle() - target := NewMinDistanceToPointTarget(p) - r := m.query.findEdge(target, m.query.opts) - if r.shapeID < 0 { - return dist, false - } - return r.distance, true -} - -func (m *MinDistanceToShapeIndexTarget) updateDistanceToEdge(edge Edge, dist distance) (distance, bool) { - m.query.opts.distanceLimit = dist.chordAngle() - target := NewMinDistanceToEdgeTarget(edge) - r := m.query.findEdge(target, m.query.opts) - if r.shapeID < 0 { - return dist, false - } - return r.distance, true -} - -func (m *MinDistanceToShapeIndexTarget) updateDistanceToCell(cell Cell, dist distance) (distance, bool) { - m.query.opts.distanceLimit = dist.chordAngle() - target := NewMinDistanceToCellTarget(cell) - r := m.query.findEdge(target, m.query.opts) - if r.shapeID < 0 { - return dist, false - } - return r.distance, true -} - -// For target types consisting of multiple connected components (such as this one), -// this method should return the polygons containing the antipodal reflection of -// *any* connected component. (It is sufficient to test containment of one vertex per -// connected component, since this allows us to also return any polygon whose -// boundary has distance.zero() to the target.) -func (m *MinDistanceToShapeIndexTarget) visitContainingShapes(index *ShapeIndex, v shapePointVisitorFunc) bool { - // It is sufficient to find the set of chain starts in the target index - // (i.e., one vertex per connected component of edges) that are contained by - // the query index, except for one special case to handle full polygons. - // - // TODO(roberts): Do this by merge-joining the two ShapeIndexes. - for _, shape := range m.index.shapes { - numChains := shape.NumChains() - // Shapes that don't have any edges require a special case (below). - testedPoint := false - for c := 0; c < numChains; c++ { - chain := shape.Chain(c) - if chain.Length == 0 { - continue - } - testedPoint = true - target := NewMinDistanceToPointTarget(shape.ChainEdge(c, 0).V0) - if !target.visitContainingShapes(index, v) { - return false - } - } - if !testedPoint { - // Special case to handle full polygons. - ref := shape.ReferencePoint() - if !ref.Contained { - continue - } - target := NewMinDistanceToPointTarget(ref.Point) - if !target.visitContainingShapes(index, v) { - return false - } - } - } - return true -} - -func (m *MinDistanceToShapeIndexTarget) setMaxError(maxErr s1.ChordAngle) bool { - m.query.opts.maxError = maxErr - return true -} -func (m *MinDistanceToShapeIndexTarget) maxBruteForceIndexSize() int { return 25 } -func (m *MinDistanceToShapeIndexTarget) distance() distance { return m.dist } -func (m *MinDistanceToShapeIndexTarget) setIncludeInteriors(b bool) { - m.query.opts.includeInteriors = b -} -func (m *MinDistanceToShapeIndexTarget) setUseBruteForce(b bool) { m.query.opts.useBruteForce = b } - -// TODO(roberts): Remaining methods -// -// func (m *MinDistanceToShapeIndexTarget) capBound() Cap { -// CellUnionTarget diff --git a/vendor/github.com/golang/geo/s2/nthderivative.go b/vendor/github.com/golang/geo/s2/nthderivative.go deleted file mode 100644 index 73445d6c9..000000000 --- a/vendor/github.com/golang/geo/s2/nthderivative.go +++ /dev/null @@ -1,88 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// nthDerivativeCoder provides Nth Derivative Coding. -// (In signal processing disciplines, this is known as N-th Delta Coding.) -// -// Good for varint coding integer sequences with polynomial trends. -// -// Instead of coding a sequence of values directly, code its nth-order discrete -// derivative. Overflow in integer addition and subtraction makes this a -// lossless transform. -// -// constant linear quadratic -// trend trend trend -// / \ / \ / \_ -// input |0 0 0 0 1 2 3 4 9 16 25 36 -// 0th derivative(identity) |0 0 0 0 1 2 3 4 9 16 25 36 -// 1st derivative(delta coding) | 0 0 0 1 1 1 1 5 7 9 11 -// 2nd derivative(linear prediction) | 0 0 1 0 0 0 4 2 2 2 -// ------------------------------------- -// 0 1 2 3 4 5 6 7 8 9 10 11 -// n in sequence -// -// Higher-order codings can break even or be detrimental on other sequences. -// -// random oscillating -// / \ / \_ -// input |5 9 6 1 8 8 2 -2 4 -4 6 -6 -// 0th derivative(identity) |5 9 6 1 8 8 2 -2 4 -4 6 -6 -// 1st derivative(delta coding) | 4 -3 -5 7 0 -6 -4 6 -8 10 -12 -// 2nd derivative(linear prediction) | -7 -2 12 -7 -6 2 10 -14 18 -22 -// --------------------------------------- -// 0 1 2 3 4 5 6 7 8 9 10 11 -// n in sequence -// -// Note that the nth derivative isn't available until sequence item n. Earlier -// values are coded at lower order. For the above table, read 5 4 -7 -2 12 ... -type nthDerivativeCoder struct { - n, m int - memory [10]int32 -} - -// newNthDerivativeCoder returns a new coder, where n is the derivative order of the encoder (the N in NthDerivative). -// n must be within [0,10]. -func newNthDerivativeCoder(n int) *nthDerivativeCoder { - c := &nthDerivativeCoder{n: n} - if n < 0 || n > len(c.memory) { - panic("unsupported n. Must be within [0,10].") - } - return c -} - -func (c *nthDerivativeCoder) encode(k int32) int32 { - for i := 0; i < c.m; i++ { - delta := k - c.memory[i] - c.memory[i] = k - k = delta - } - if c.m < c.n { - c.memory[c.m] = k - c.m++ - } - return k -} - -func (c *nthDerivativeCoder) decode(k int32) int32 { - if c.m < c.n { - c.m++ - } - for i := c.m - 1; i >= 0; i-- { - c.memory[i] += k - k = c.memory[i] - } - return k -} diff --git a/vendor/github.com/golang/geo/s2/paddedcell.go b/vendor/github.com/golang/geo/s2/paddedcell.go deleted file mode 100644 index ac304a6cc..000000000 --- a/vendor/github.com/golang/geo/s2/paddedcell.go +++ /dev/null @@ -1,252 +0,0 @@ -// Copyright 2016 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "github.com/golang/geo/r1" - "github.com/golang/geo/r2" -) - -// PaddedCell represents a Cell whose (u,v)-range has been expanded on -// all sides by a given amount of "padding". Unlike Cell, its methods and -// representation are optimized for clipping edges against Cell boundaries -// to determine which cells are intersected by a given set of edges. -type PaddedCell struct { - id CellID - padding float64 - bound r2.Rect - middle r2.Rect // A rect in (u, v)-space that belongs to all four children. - iLo, jLo int // Minimum (i,j)-coordinates of this cell before padding - orientation int // Hilbert curve orientation of this cell. - level int -} - -// PaddedCellFromCellID constructs a padded cell with the given padding. -func PaddedCellFromCellID(id CellID, padding float64) *PaddedCell { - p := &PaddedCell{ - id: id, - padding: padding, - middle: r2.EmptyRect(), - } - - // Fast path for constructing a top-level face (the most common case). - if id.isFace() { - limit := padding + 1 - p.bound = r2.Rect{r1.Interval{-limit, limit}, r1.Interval{-limit, limit}} - p.middle = r2.Rect{r1.Interval{-padding, padding}, r1.Interval{-padding, padding}} - p.orientation = id.Face() & 1 - return p - } - - _, p.iLo, p.jLo, p.orientation = id.faceIJOrientation() - p.level = id.Level() - p.bound = ijLevelToBoundUV(p.iLo, p.jLo, p.level).ExpandedByMargin(padding) - ijSize := sizeIJ(p.level) - p.iLo &= -ijSize - p.jLo &= -ijSize - - return p -} - -// PaddedCellFromParentIJ constructs the child of parent with the given (i,j) index. -// The four child cells have indices of (0,0), (0,1), (1,0), (1,1), where the i and j -// indices correspond to increasing u- and v-values respectively. -func PaddedCellFromParentIJ(parent *PaddedCell, i, j int) *PaddedCell { - // Compute the position and orientation of the child incrementally from the - // orientation of the parent. - pos := ijToPos[parent.orientation][2*i+j] - - p := &PaddedCell{ - id: parent.id.Children()[pos], - padding: parent.padding, - bound: parent.bound, - orientation: parent.orientation ^ posToOrientation[pos], - level: parent.level + 1, - middle: r2.EmptyRect(), - } - - ijSize := sizeIJ(p.level) - p.iLo = parent.iLo + i*ijSize - p.jLo = parent.jLo + j*ijSize - - // For each child, one corner of the bound is taken directly from the parent - // while the diagonally opposite corner is taken from middle(). - middle := parent.Middle() - if i == 1 { - p.bound.X.Lo = middle.X.Lo - } else { - p.bound.X.Hi = middle.X.Hi - } - if j == 1 { - p.bound.Y.Lo = middle.Y.Lo - } else { - p.bound.Y.Hi = middle.Y.Hi - } - - return p -} - -// CellID returns the CellID this padded cell represents. -func (p PaddedCell) CellID() CellID { - return p.id -} - -// Padding returns the amount of padding on this cell. -func (p PaddedCell) Padding() float64 { - return p.padding -} - -// Level returns the level this cell is at. -func (p PaddedCell) Level() int { - return p.level -} - -// Center returns the center of this cell. -func (p PaddedCell) Center() Point { - ijSize := sizeIJ(p.level) - si := uint32(2*p.iLo + ijSize) - ti := uint32(2*p.jLo + ijSize) - return Point{faceSiTiToXYZ(p.id.Face(), si, ti).Normalize()} -} - -// Middle returns the rectangle in the middle of this cell that belongs to -// all four of its children in (u,v)-space. -func (p *PaddedCell) Middle() r2.Rect { - // We compute this field lazily because it is not needed the majority of the - // time (i.e., for cells where the recursion terminates). - if p.middle.IsEmpty() { - ijSize := sizeIJ(p.level) - u := stToUV(siTiToST(uint32(2*p.iLo + ijSize))) - v := stToUV(siTiToST(uint32(2*p.jLo + ijSize))) - p.middle = r2.Rect{ - r1.Interval{u - p.padding, u + p.padding}, - r1.Interval{v - p.padding, v + p.padding}, - } - } - return p.middle -} - -// Bound returns the bounds for this cell in (u,v)-space including padding. -func (p PaddedCell) Bound() r2.Rect { - return p.bound -} - -// ChildIJ returns the (i,j) coordinates for the child cell at the given traversal -// position. The traversal position corresponds to the order in which child -// cells are visited by the Hilbert curve. -func (p PaddedCell) ChildIJ(pos int) (i, j int) { - ij := posToIJ[p.orientation][pos] - return ij >> 1, ij & 1 -} - -// EntryVertex return the vertex where the space-filling curve enters this cell. -func (p PaddedCell) EntryVertex() Point { - // The curve enters at the (0,0) vertex unless the axis directions are - // reversed, in which case it enters at the (1,1) vertex. - i := p.iLo - j := p.jLo - if p.orientation&invertMask != 0 { - ijSize := sizeIJ(p.level) - i += ijSize - j += ijSize - } - return Point{faceSiTiToXYZ(p.id.Face(), uint32(2*i), uint32(2*j)).Normalize()} -} - -// ExitVertex returns the vertex where the space-filling curve exits this cell. -func (p PaddedCell) ExitVertex() Point { - // The curve exits at the (1,0) vertex unless the axes are swapped or - // inverted but not both, in which case it exits at the (0,1) vertex. - i := p.iLo - j := p.jLo - ijSize := sizeIJ(p.level) - if p.orientation == 0 || p.orientation == swapMask+invertMask { - i += ijSize - } else { - j += ijSize - } - return Point{faceSiTiToXYZ(p.id.Face(), uint32(2*i), uint32(2*j)).Normalize()} -} - -// ShrinkToFit returns the smallest CellID that contains all descendants of this -// padded cell whose bounds intersect the given rect. For algorithms that use -// recursive subdivision to find the cells that intersect a particular object, this -// method can be used to skip all of the initial subdivision steps where only -// one child needs to be expanded. -// -// Note that this method is not the same as returning the smallest cell that contains -// the intersection of this cell with rect. Because of the padding, even if one child -// completely contains rect it is still possible that a neighboring child may also -// intersect the given rect. -// -// The provided Rect must intersect the bounds of this cell. -func (p *PaddedCell) ShrinkToFit(rect r2.Rect) CellID { - // Quick rejection test: if rect contains the center of this cell along - // either axis, then no further shrinking is possible. - if p.level == 0 { - // Fast path (most calls to this function start with a face cell). - if rect.X.Contains(0) || rect.Y.Contains(0) { - return p.id - } - } - - ijSize := sizeIJ(p.level) - if rect.X.Contains(stToUV(siTiToST(uint32(2*p.iLo+ijSize)))) || - rect.Y.Contains(stToUV(siTiToST(uint32(2*p.jLo+ijSize)))) { - return p.id - } - - // Otherwise we expand rect by the given padding on all sides and find - // the range of coordinates that it spans along the i- and j-axes. We then - // compute the highest bit position at which the min and max coordinates - // differ. This corresponds to the first cell level at which at least two - // children intersect rect. - - // Increase the padding to compensate for the error in uvToST. - // (The constant below is a provable upper bound on the additional error.) - padded := rect.ExpandedByMargin(p.padding + 1.5*dblEpsilon) - iMin, jMin := p.iLo, p.jLo // Min i- or j- coordinate spanned by padded - var iXor, jXor int // XOR of the min and max i- or j-coordinates - - if iMin < stToIJ(uvToST(padded.X.Lo)) { - iMin = stToIJ(uvToST(padded.X.Lo)) - } - if a, b := p.iLo+ijSize-1, stToIJ(uvToST(padded.X.Hi)); a <= b { - iXor = iMin ^ a - } else { - iXor = iMin ^ b - } - - if jMin < stToIJ(uvToST(padded.Y.Lo)) { - jMin = stToIJ(uvToST(padded.Y.Lo)) - } - if a, b := p.jLo+ijSize-1, stToIJ(uvToST(padded.Y.Hi)); a <= b { - jXor = jMin ^ a - } else { - jXor = jMin ^ b - } - - // Compute the highest bit position where the two i- or j-endpoints differ, - // and then choose the cell level that includes both of these endpoints. So - // if both pairs of endpoints are equal we choose maxLevel; if they differ - // only at bit 0, we choose (maxLevel - 1), and so on. - levelMSB := uint64(((iXor | jXor) << 1) + 1) - level := maxLevel - findMSBSetNonZero64(levelMSB) - if level <= p.level { - return p.id - } - - return cellIDFromFaceIJ(p.id.Face(), iMin, jMin).Parent(level) -} diff --git a/vendor/github.com/golang/geo/s2/point.go b/vendor/github.com/golang/geo/s2/point.go deleted file mode 100644 index 89e7ae0ed..000000000 --- a/vendor/github.com/golang/geo/s2/point.go +++ /dev/null @@ -1,258 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "math" - "sort" - - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// Point represents a point on the unit sphere as a normalized 3D vector. -// Fields should be treated as read-only. Use one of the factory methods for creation. -type Point struct { - r3.Vector -} - -// sortPoints sorts the slice of Points in place. -func sortPoints(e []Point) { - sort.Sort(points(e)) -} - -// points implements the Sort interface for slices of Point. -type points []Point - -func (p points) Len() int { return len(p) } -func (p points) Swap(i, j int) { p[i], p[j] = p[j], p[i] } -func (p points) Less(i, j int) bool { return p[i].Cmp(p[j].Vector) == -1 } - -// PointFromCoords creates a new normalized point from coordinates. -// -// This always returns a valid point. If the given coordinates can not be normalized -// the origin point will be returned. -// -// This behavior is different from the C++ construction of a S2Point from coordinates -// (i.e. S2Point(x, y, z)) in that in C++ they do not Normalize. -func PointFromCoords(x, y, z float64) Point { - if x == 0 && y == 0 && z == 0 { - return OriginPoint() - } - return Point{r3.Vector{x, y, z}.Normalize()} -} - -// OriginPoint returns a unique "origin" on the sphere for operations that need a fixed -// reference point. In particular, this is the "point at infinity" used for -// point-in-polygon testing (by counting the number of edge crossings). -// -// It should *not* be a point that is commonly used in edge tests in order -// to avoid triggering code to handle degenerate cases (this rules out the -// north and south poles). It should also not be on the boundary of any -// low-level S2Cell for the same reason. -func OriginPoint() Point { - return Point{r3.Vector{-0.0099994664350250197, 0.0025924542609324121, 0.99994664350250195}} -} - -// PointCross returns a Point that is orthogonal to both p and op. This is similar to -// p.Cross(op) (the true cross product) except that it does a better job of -// ensuring orthogonality when the Point is nearly parallel to op, it returns -// a non-zero result even when p == op or p == -op and the result is a Point. -// -// It satisfies the following properties (f == PointCross): -// -// (1) f(p, op) != 0 for all p, op -// (2) f(op,p) == -f(p,op) unless p == op or p == -op -// (3) f(-p,op) == -f(p,op) unless p == op or p == -op -// (4) f(p,-op) == -f(p,op) unless p == op or p == -op -func (p Point) PointCross(op Point) Point { - // NOTE(dnadasi): In the C++ API the equivalent method here was known as "RobustCrossProd", - // but PointCross more accurately describes how this method is used. - x := p.Add(op.Vector).Cross(op.Sub(p.Vector)) - - // Compare exactly to the 0 vector. - if x == (r3.Vector{}) { - // The only result that makes sense mathematically is to return zero, but - // we find it more convenient to return an arbitrary orthogonal vector. - return Point{p.Ortho()} - } - - return Point{x} -} - -// OrderedCCW returns true if the edges OA, OB, and OC are encountered in that -// order while sweeping CCW around the point O. -// -// You can think of this as testing whether A <= B <= C with respect to the -// CCW ordering around O that starts at A, or equivalently, whether B is -// contained in the range of angles (inclusive) that starts at A and extends -// CCW to C. Properties: -// -// (1) If OrderedCCW(a,b,c,o) && OrderedCCW(b,a,c,o), then a == b -// (2) If OrderedCCW(a,b,c,o) && OrderedCCW(a,c,b,o), then b == c -// (3) If OrderedCCW(a,b,c,o) && OrderedCCW(c,b,a,o), then a == b == c -// (4) If a == b or b == c, then OrderedCCW(a,b,c,o) is true -// (5) Otherwise if a == c, then OrderedCCW(a,b,c,o) is false -func OrderedCCW(a, b, c, o Point) bool { - sum := 0 - if RobustSign(b, o, a) != Clockwise { - sum++ - } - if RobustSign(c, o, b) != Clockwise { - sum++ - } - if RobustSign(a, o, c) == CounterClockwise { - sum++ - } - return sum >= 2 -} - -// Distance returns the angle between two points. -func (p Point) Distance(b Point) s1.Angle { - return p.Vector.Angle(b.Vector) -} - -// ApproxEqual reports whether the two points are similar enough to be equal. -func (p Point) ApproxEqual(other Point) bool { - return p.approxEqual(other, s1.Angle(epsilon)) -} - -// approxEqual reports whether the two points are within the given epsilon. -func (p Point) approxEqual(other Point, eps s1.Angle) bool { - return p.Vector.Angle(other.Vector) <= eps -} - -// ChordAngleBetweenPoints constructs a ChordAngle corresponding to the distance -// between the two given points. The points must be unit length. -func ChordAngleBetweenPoints(x, y Point) s1.ChordAngle { - return s1.ChordAngle(math.Min(4.0, x.Sub(y.Vector).Norm2())) -} - -// regularPoints generates a slice of points shaped as a regular polygon with -// the numVertices vertices, all located on a circle of the specified angular radius -// around the center. The radius is the actual distance from center to each vertex. -func regularPoints(center Point, radius s1.Angle, numVertices int) []Point { - return regularPointsForFrame(getFrame(center), radius, numVertices) -} - -// regularPointsForFrame generates a slice of points shaped as a regular polygon -// with numVertices vertices, all on a circle of the specified angular radius around -// the center. The radius is the actual distance from the center to each vertex. -func regularPointsForFrame(frame matrix3x3, radius s1.Angle, numVertices int) []Point { - // We construct the loop in the given frame coordinates, with the center at - // (0, 0, 1). For a loop of radius r, the loop vertices have the form - // (x, y, z) where x^2 + y^2 = sin(r) and z = cos(r). The distance on the - // sphere (arc length) from each vertex to the center is acos(cos(r)) = r. - z := math.Cos(radius.Radians()) - r := math.Sin(radius.Radians()) - radianStep := 2 * math.Pi / float64(numVertices) - var vertices []Point - - for i := 0; i < numVertices; i++ { - angle := float64(i) * radianStep - p := Point{r3.Vector{r * math.Cos(angle), r * math.Sin(angle), z}} - vertices = append(vertices, Point{fromFrame(frame, p).Normalize()}) - } - - return vertices -} - -// CapBound returns a bounding cap for this point. -func (p Point) CapBound() Cap { - return CapFromPoint(p) -} - -// RectBound returns a bounding latitude-longitude rectangle from this point. -func (p Point) RectBound() Rect { - return RectFromLatLng(LatLngFromPoint(p)) -} - -// ContainsCell returns false as Points do not contain any other S2 types. -func (p Point) ContainsCell(c Cell) bool { return false } - -// IntersectsCell reports whether this Point intersects the given cell. -func (p Point) IntersectsCell(c Cell) bool { - return c.ContainsPoint(p) -} - -// ContainsPoint reports if this Point contains the other Point. -// (This method is named to satisfy the Region interface.) -func (p Point) ContainsPoint(other Point) bool { - return p.Contains(other) -} - -// CellUnionBound computes a covering of the Point. -func (p Point) CellUnionBound() []CellID { - return p.CapBound().CellUnionBound() -} - -// Contains reports if this Point contains the other Point. -// (This method matches all other s2 types where the reflexive Contains -// method does not contain the type's name.) -func (p Point) Contains(other Point) bool { return p == other } - -// Encode encodes the Point. -func (p Point) Encode(w io.Writer) error { - e := &encoder{w: w} - p.encode(e) - return e.err -} - -func (p Point) encode(e *encoder) { - e.writeInt8(encodingVersion) - e.writeFloat64(p.X) - e.writeFloat64(p.Y) - e.writeFloat64(p.Z) -} - -// Decode decodes the Point. -func (p *Point) Decode(r io.Reader) error { - d := &decoder{r: asByteReader(r)} - p.decode(d) - return d.err -} - -func (p *Point) decode(d *decoder) { - version := d.readInt8() - if d.err != nil { - return - } - if version != encodingVersion { - d.err = fmt.Errorf("only version %d is supported", encodingVersion) - return - } - p.X = d.readFloat64() - p.Y = d.readFloat64() - p.Z = d.readFloat64() -} - -// Rotate the given point about the given axis by the given angle. p and -// axis must be unit length; angle has no restrictions (e.g., it can be -// positive, negative, greater than 360 degrees, etc). -func Rotate(p, axis Point, angle s1.Angle) Point { - // Let M be the plane through P that is perpendicular to axis, and let - // center be the point where M intersects axis. We construct a - // right-handed orthogonal frame (dx, dy, center) such that dx is the - // vector from center to P, and dy has the same length as dx. The - // result can then be expressed as (cos(angle)*dx + sin(angle)*dy + center). - center := axis.Mul(p.Dot(axis.Vector)) - dx := p.Sub(center) - dy := axis.Cross(p.Vector) - // Mathematically the result is unit length, but normalization is necessary - // to ensure that numerical errors don't accumulate. - return Point{dx.Mul(math.Cos(angle.Radians())).Add(dy.Mul(math.Sin(angle.Radians()))).Add(center).Normalize()} -} diff --git a/vendor/github.com/golang/geo/s2/point_measures.go b/vendor/github.com/golang/geo/s2/point_measures.go deleted file mode 100644 index 6fa9b7ae4..000000000 --- a/vendor/github.com/golang/geo/s2/point_measures.go +++ /dev/null @@ -1,149 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/s1" -) - -// PointArea returns the area of triangle ABC. This method combines two different -// algorithms to get accurate results for both large and small triangles. -// The maximum error is about 5e-15 (about 0.25 square meters on the Earth's -// surface), the same as GirardArea below, but unlike that method it is -// also accurate for small triangles. Example: when the true area is 100 -// square meters, PointArea yields an error about 1 trillion times smaller than -// GirardArea. -// -// All points should be unit length, and no two points should be antipodal. -// The area is always positive. -func PointArea(a, b, c Point) float64 { - // This method is based on l'Huilier's theorem, - // - // tan(E/4) = sqrt(tan(s/2) tan((s-a)/2) tan((s-b)/2) tan((s-c)/2)) - // - // where E is the spherical excess of the triangle (i.e. its area), - // a, b, c are the side lengths, and - // s is the semiperimeter (a + b + c) / 2. - // - // The only significant source of error using l'Huilier's method is the - // cancellation error of the terms (s-a), (s-b), (s-c). This leads to a - // *relative* error of about 1e-16 * s / min(s-a, s-b, s-c). This compares - // to a relative error of about 1e-15 / E using Girard's formula, where E is - // the true area of the triangle. Girard's formula can be even worse than - // this for very small triangles, e.g. a triangle with a true area of 1e-30 - // might evaluate to 1e-5. - // - // So, we prefer l'Huilier's formula unless dmin < s * (0.1 * E), where - // dmin = min(s-a, s-b, s-c). This basically includes all triangles - // except for extremely long and skinny ones. - // - // Since we don't know E, we would like a conservative upper bound on - // the triangle area in terms of s and dmin. It's possible to show that - // E <= k1 * s * sqrt(s * dmin), where k1 = 2*sqrt(3)/Pi (about 1). - // Using this, it's easy to show that we should always use l'Huilier's - // method if dmin >= k2 * s^5, where k2 is about 1e-2. Furthermore, - // if dmin < k2 * s^5, the triangle area is at most k3 * s^4, where - // k3 is about 0.1. Since the best case error using Girard's formula - // is about 1e-15, this means that we shouldn't even consider it unless - // s >= 3e-4 or so. - sa := float64(b.Angle(c.Vector)) - sb := float64(c.Angle(a.Vector)) - sc := float64(a.Angle(b.Vector)) - s := 0.5 * (sa + sb + sc) - if s >= 3e-4 { - // Consider whether Girard's formula might be more accurate. - dmin := s - math.Max(sa, math.Max(sb, sc)) - if dmin < 1e-2*s*s*s*s*s { - // This triangle is skinny enough to use Girard's formula. - area := GirardArea(a, b, c) - if dmin < s*0.1*area { - return area - } - } - } - - // Use l'Huilier's formula. - return 4 * math.Atan(math.Sqrt(math.Max(0.0, math.Tan(0.5*s)*math.Tan(0.5*(s-sa))* - math.Tan(0.5*(s-sb))*math.Tan(0.5*(s-sc))))) -} - -// GirardArea returns the area of the triangle computed using Girard's formula. -// All points should be unit length, and no two points should be antipodal. -// -// This method is about twice as fast as PointArea() but has poor relative -// accuracy for small triangles. The maximum error is about 5e-15 (about -// 0.25 square meters on the Earth's surface) and the average error is about -// 1e-15. These bounds apply to triangles of any size, even as the maximum -// edge length of the triangle approaches 180 degrees. But note that for -// such triangles, tiny perturbations of the input points can change the -// true mathematical area dramatically. -func GirardArea(a, b, c Point) float64 { - // This is equivalent to the usual Girard's formula but is slightly more - // accurate, faster to compute, and handles a == b == c without a special - // case. PointCross is necessary to get good accuracy when two of - // the input points are very close together. - ab := a.PointCross(b) - bc := b.PointCross(c) - ac := a.PointCross(c) - - area := float64(ab.Angle(ac.Vector) - ab.Angle(bc.Vector) + bc.Angle(ac.Vector)) - if area < 0 { - area = 0 - } - return area -} - -// SignedArea returns a positive value for counterclockwise triangles and a negative -// value otherwise (similar to PointArea). -func SignedArea(a, b, c Point) float64 { - return float64(RobustSign(a, b, c)) * PointArea(a, b, c) -} - -// Angle returns the interior angle at the vertex B in the triangle ABC. The -// return value is always in the range [0, pi]. All points should be -// normalized. Ensures that Angle(a,b,c) == Angle(c,b,a) for all a,b,c. -// -// The angle is undefined if A or C is diametrically opposite from B, and -// becomes numerically unstable as the length of edge AB or BC approaches -// 180 degrees. -func Angle(a, b, c Point) s1.Angle { - // PointCross is necessary to get good accuracy when two of the input - // points are very close together. - return a.PointCross(b).Angle(c.PointCross(b).Vector) -} - -// TurnAngle returns the exterior angle at vertex B in the triangle ABC. The -// return value is positive if ABC is counterclockwise and negative otherwise. -// If you imagine an ant walking from A to B to C, this is the angle that the -// ant turns at vertex B (positive = left = CCW, negative = right = CW). -// This quantity is also known as the "geodesic curvature" at B. -// -// Ensures that TurnAngle(a,b,c) == -TurnAngle(c,b,a) for all distinct -// a,b,c. The result is undefined if (a == b || b == c), but is either -// -Pi or Pi if (a == c). All points should be normalized. -func TurnAngle(a, b, c Point) s1.Angle { - // We use PointCross to get good accuracy when two points are very - // close together, and RobustSign to ensure that the sign is correct for - // turns that are close to 180 degrees. - angle := a.PointCross(b).Angle(b.PointCross(c).Vector) - - // Don't return RobustSign * angle because it is legal to have (a == c). - if RobustSign(a, b, c) == CounterClockwise { - return angle - } - return -angle -} diff --git a/vendor/github.com/golang/geo/s2/point_vector.go b/vendor/github.com/golang/geo/s2/point_vector.go deleted file mode 100644 index f8e6f65b5..000000000 --- a/vendor/github.com/golang/geo/s2/point_vector.go +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// Shape interface enforcement -var ( - _ Shape = (*PointVector)(nil) -) - -// PointVector is a Shape representing a set of Points. Each point -// is represented as a degenerate edge with the same starting and ending -// vertices. -// -// This type is useful for adding a collection of points to an ShapeIndex. -// -// Its methods are on *PointVector due to implementation details of ShapeIndex. -type PointVector []Point - -func (p *PointVector) NumEdges() int { return len(*p) } -func (p *PointVector) Edge(i int) Edge { return Edge{(*p)[i], (*p)[i]} } -func (p *PointVector) ReferencePoint() ReferencePoint { return OriginReferencePoint(false) } -func (p *PointVector) NumChains() int { return len(*p) } -func (p *PointVector) Chain(i int) Chain { return Chain{i, 1} } -func (p *PointVector) ChainEdge(i, j int) Edge { return Edge{(*p)[i], (*p)[j]} } -func (p *PointVector) ChainPosition(e int) ChainPosition { return ChainPosition{e, 0} } -func (p *PointVector) Dimension() int { return 0 } -func (p *PointVector) IsEmpty() bool { return defaultShapeIsEmpty(p) } -func (p *PointVector) IsFull() bool { return defaultShapeIsFull(p) } -func (p *PointVector) typeTag() typeTag { return typeTagPointVector } -func (p *PointVector) privateInterface() {} diff --git a/vendor/github.com/golang/geo/s2/pointcompression.go b/vendor/github.com/golang/geo/s2/pointcompression.go deleted file mode 100644 index 018381799..000000000 --- a/vendor/github.com/golang/geo/s2/pointcompression.go +++ /dev/null @@ -1,319 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "errors" - "fmt" - - "github.com/golang/geo/r3" -) - -// maxEncodedVertices is the maximum number of vertices, in a row, to be encoded or decoded. -// On decode, this defends against malicious encodings that try and have us exceed RAM. -const maxEncodedVertices = 50000000 - -// xyzFaceSiTi represents the The XYZ and face,si,ti coordinates of a Point -// and, if this point is equal to the center of a Cell, the level of this cell -// (-1 otherwise). This is used for Loops and Polygons to store data in a more -// compressed format. -type xyzFaceSiTi struct { - xyz Point - face int - si, ti uint32 - level int -} - -const derivativeEncodingOrder = 2 - -func appendFace(faces []faceRun, face int) []faceRun { - if len(faces) == 0 || faces[len(faces)-1].face != face { - return append(faces, faceRun{face, 1}) - } - faces[len(faces)-1].count++ - return faces -} - -// encodePointsCompressed uses an optimized compressed format to encode the given values. -func encodePointsCompressed(e *encoder, vertices []xyzFaceSiTi, level int) { - var faces []faceRun - for _, v := range vertices { - faces = appendFace(faces, v.face) - } - encodeFaces(e, faces) - - type piQi struct { - pi, qi uint32 - } - verticesPiQi := make([]piQi, len(vertices)) - for i, v := range vertices { - verticesPiQi[i] = piQi{siTitoPiQi(v.si, level), siTitoPiQi(v.ti, level)} - } - piCoder, qiCoder := newNthDerivativeCoder(derivativeEncodingOrder), newNthDerivativeCoder(derivativeEncodingOrder) - for i, v := range verticesPiQi { - f := encodePointCompressed - if i == 0 { - // The first point will be just the (pi, qi) coordinates - // of the Point. NthDerivativeCoder will not save anything - // in that case, so we encode in fixed format rather than varint - // to avoid the varint overhead. - f = encodeFirstPointFixedLength - } - f(e, v.pi, v.qi, level, piCoder, qiCoder) - } - - var offCenter []int - for i, v := range vertices { - if v.level != level { - offCenter = append(offCenter, i) - } - } - e.writeUvarint(uint64(len(offCenter))) - for _, idx := range offCenter { - e.writeUvarint(uint64(idx)) - e.writeFloat64(vertices[idx].xyz.X) - e.writeFloat64(vertices[idx].xyz.Y) - e.writeFloat64(vertices[idx].xyz.Z) - } -} - -func encodeFirstPointFixedLength(e *encoder, pi, qi uint32, level int, piCoder, qiCoder *nthDerivativeCoder) { - // Do not ZigZagEncode the first point, since it cannot be negative. - codedPi, codedQi := piCoder.encode(int32(pi)), qiCoder.encode(int32(qi)) - // Interleave to reduce overhead from two partial bytes to one. - interleaved := interleaveUint32(uint32(codedPi), uint32(codedQi)) - - // Write as little endian. - bytesRequired := (level + 7) / 8 * 2 - for i := 0; i < bytesRequired; i++ { - e.writeUint8(uint8(interleaved)) - interleaved >>= 8 - } -} - -// encodePointCompressed encodes points into e. -// Given a sequence of Points assumed to be the center of level-k cells, -// compresses it into a stream using the following method: -// - decompose the points into (face, si, ti) tuples. -// - run-length encode the faces, combining face number and count into a -// varint32. See the faceRun struct. -// - right shift the (si, ti) to remove the part that's constant for all cells -// of level-k. The result is called the (pi, qi) space. -// - 2nd derivative encode the pi and qi sequences (linear prediction) -// - zig-zag encode all derivative values but the first, which cannot be -// negative -// - interleave the zig-zag encoded values -// - encode the first interleaved value in a fixed length encoding -// (varint would make this value larger) -// - encode the remaining interleaved values as varint64s, as the -// derivative encoding should make the values small. -// In addition, provides a lossless method to compress a sequence of points even -// if some points are not the center of level-k cells. These points are stored -// exactly, using 3 double precision values, after the above encoded string, -// together with their index in the sequence (this leads to some redundancy - it -// is expected that only a small fraction of the points are not cell centers). -// -// To encode leaf cells, this requires 8 bytes for the first vertex plus -// an average of 3.8 bytes for each additional vertex, when computed on -// Google's geographic repository. -func encodePointCompressed(e *encoder, pi, qi uint32, level int, piCoder, qiCoder *nthDerivativeCoder) { - // ZigZagEncode, as varint requires the maximum number of bytes for - // negative numbers. - zzPi := zigzagEncode(piCoder.encode(int32(pi))) - zzQi := zigzagEncode(qiCoder.encode(int32(qi))) - // Interleave to reduce overhead from two partial bytes to one. - interleaved := interleaveUint32(zzPi, zzQi) - e.writeUvarint(interleaved) -} - -type faceRun struct { - face, count int -} - -func decodeFaceRun(d *decoder) faceRun { - faceAndCount := d.readUvarint() - ret := faceRun{ - face: int(faceAndCount % numFaces), - count: int(faceAndCount / numFaces), - } - if ret.count <= 0 && d.err == nil { - d.err = errors.New("non-positive count for face run") - } - return ret -} - -func decodeFaces(numVertices int, d *decoder) []faceRun { - var frs []faceRun - for nparsed := 0; nparsed < numVertices; { - fr := decodeFaceRun(d) - if d.err != nil { - return nil - } - frs = append(frs, fr) - nparsed += fr.count - } - return frs -} - -// encodeFaceRun encodes each faceRun as a varint64 with value numFaces * count + face. -func encodeFaceRun(e *encoder, fr faceRun) { - // It isn't necessary to encode the number of faces left for the last run, - // but since this would only help if there were more than 21 faces, it will - // be a small overall savings, much smaller than the bound encoding. - coded := numFaces*uint64(fr.count) + uint64(fr.face) - e.writeUvarint(coded) -} - -func encodeFaces(e *encoder, frs []faceRun) { - for _, fr := range frs { - encodeFaceRun(e, fr) - } -} - -type facesIterator struct { - faces []faceRun - // How often have we yet shown the current face? - numCurrentFaceShown int - curFace int -} - -func (fi *facesIterator) next() (ok bool) { - if len(fi.faces) == 0 { - return false - } - fi.curFace = fi.faces[0].face - fi.numCurrentFaceShown++ - - // Advance fs if needed. - if fi.faces[0].count <= fi.numCurrentFaceShown { - fi.faces = fi.faces[1:] - fi.numCurrentFaceShown = 0 - } - - return true -} - -func decodePointsCompressed(d *decoder, level int, target []Point) { - faces := decodeFaces(len(target), d) - - piCoder := newNthDerivativeCoder(derivativeEncodingOrder) - qiCoder := newNthDerivativeCoder(derivativeEncodingOrder) - - iter := facesIterator{faces: faces} - for i := range target { - decodeFn := decodePointCompressed - if i == 0 { - decodeFn = decodeFirstPointFixedLength - } - pi, qi := decodeFn(d, level, piCoder, qiCoder) - if ok := iter.next(); !ok && d.err == nil { - d.err = fmt.Errorf("ran out of faces at target %d", i) - return - } - target[i] = Point{facePiQitoXYZ(iter.curFace, pi, qi, level)} - } - - numOffCenter := int(d.readUvarint()) - if d.err != nil { - return - } - if numOffCenter > len(target) { - d.err = fmt.Errorf("numOffCenter = %d, should be at most len(target) = %d", numOffCenter, len(target)) - return - } - for i := 0; i < numOffCenter; i++ { - idx := int(d.readUvarint()) - if d.err != nil { - return - } - if idx >= len(target) { - d.err = fmt.Errorf("off center index = %d, should be < len(target) = %d", idx, len(target)) - return - } - target[idx].X = d.readFloat64() - target[idx].Y = d.readFloat64() - target[idx].Z = d.readFloat64() - } -} - -func decodeFirstPointFixedLength(d *decoder, level int, piCoder, qiCoder *nthDerivativeCoder) (pi, qi uint32) { - bytesToRead := (level + 7) / 8 * 2 - var interleaved uint64 - for i := 0; i < bytesToRead; i++ { - rr := d.readUint8() - interleaved |= (uint64(rr) << uint(i*8)) - } - - piCoded, qiCoded := deinterleaveUint32(interleaved) - - return uint32(piCoder.decode(int32(piCoded))), uint32(qiCoder.decode(int32(qiCoded))) -} - -func zigzagEncode(x int32) uint32 { - return (uint32(x) << 1) ^ uint32(x>>31) -} - -func zigzagDecode(x uint32) int32 { - return int32((x >> 1) ^ uint32((int32(x&1)<<31)>>31)) -} - -func decodePointCompressed(d *decoder, level int, piCoder, qiCoder *nthDerivativeCoder) (pi, qi uint32) { - interleavedZigZagEncodedDerivPiQi := d.readUvarint() - piZigzag, qiZigzag := deinterleaveUint32(interleavedZigZagEncodedDerivPiQi) - return uint32(piCoder.decode(zigzagDecode(piZigzag))), uint32(qiCoder.decode(zigzagDecode(qiZigzag))) -} - -// We introduce a new coordinate system (pi, qi), which is (si, ti) -// with the bits that are constant for cells of that level shifted -// off to the right. -// si = round(s * 2^31) -// pi = si >> (31 - level) -// = floor(s * 2^level) -// If the point has been snapped to the level, the bits that are -// shifted off will be a 1 in the msb, then 0s after that, so the -// fractional part discarded by the cast is (close to) 0.5. - -// stToPiQi returns the value transformed to the PiQi coordinate space. -func stToPiQi(s float64, level uint) uint32 { - return uint32(s * float64(int(1)<<level)) -} - -// siTiToPiQi returns the value transformed into the PiQi coordinate spade. -// encodeFirstPointFixedLength encodes the return value using level bits, -// so we clamp si to the range [0, 2**level - 1] before trying to encode -// it. This is okay because if si == maxSiTi, then it is not a cell center -// anyway and will be encoded separately as an off-center point. -func siTitoPiQi(siTi uint32, level int) uint32 { - s := uint(siTi) - const max = maxSiTi - 1 - if s > max { - s = max - } - - return uint32(s >> (maxLevel + 1 - uint(level))) -} - -// piQiToST returns the value transformed to ST space. -func piQiToST(pi uint32, level int) float64 { - // We want to recover the position at the center of the cell. If the point - // was snapped to the center of the cell, then math.Modf(s * 2^level) == 0.5. - // Inverting STtoPiQi gives: - // s = (pi + 0.5) / 2^level. - return (float64(pi) + 0.5) / float64(int(1)<<uint(level)) -} - -func facePiQitoXYZ(face int, pi, qi uint32, level int) r3.Vector { - return faceUVToXYZ(face, stToUV(piQiToST(pi, level)), stToUV(piQiToST(qi, level))).Normalize() -} diff --git a/vendor/github.com/golang/geo/s2/polygon.go b/vendor/github.com/golang/geo/s2/polygon.go deleted file mode 100644 index c691ec083..000000000 --- a/vendor/github.com/golang/geo/s2/polygon.go +++ /dev/null @@ -1,1213 +0,0 @@ -// Copyright 2015 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "math" -) - -// Polygon represents a sequence of zero or more loops; recall that the -// interior of a loop is defined to be its left-hand side (see Loop). -// -// When the polygon is initialized, the given loops are automatically converted -// into a canonical form consisting of "shells" and "holes". Shells and holes -// are both oriented CCW, and are nested hierarchically. The loops are -// reordered to correspond to a pre-order traversal of the nesting hierarchy. -// -// Polygons may represent any region of the sphere with a polygonal boundary, -// including the entire sphere (known as the "full" polygon). The full polygon -// consists of a single full loop (see Loop), whereas the empty polygon has no -// loops at all. -// -// Use FullPolygon() to construct a full polygon. The zero value of Polygon is -// treated as the empty polygon. -// -// Polygons have the following restrictions: -// -// - Loops may not cross, i.e. the boundary of a loop may not intersect -// both the interior and exterior of any other loop. -// -// - Loops may not share edges, i.e. if a loop contains an edge AB, then -// no other loop may contain AB or BA. -// -// - Loops may share vertices, however no vertex may appear twice in a -// single loop (see Loop). -// -// - No loop may be empty. The full loop may appear only in the full polygon. -type Polygon struct { - loops []*Loop - - // index is a spatial index of all the polygon loops. - index *ShapeIndex - - // hasHoles tracks if this polygon has at least one hole. - hasHoles bool - - // numVertices keeps the running total of all of the vertices of the contained loops. - numVertices int - - // numEdges tracks the total number of edges in all the loops in this polygon. - numEdges int - - // bound is a conservative bound on all points contained by this loop. - // If l.ContainsPoint(P), then l.bound.ContainsPoint(P). - bound Rect - - // Since bound is not exact, it is possible that a loop A contains - // another loop B whose bounds are slightly larger. subregionBound - // has been expanded sufficiently to account for this error, i.e. - // if A.Contains(B), then A.subregionBound.Contains(B.bound). - subregionBound Rect - - // A slice where element i is the cumulative number of edges in the - // preceding loops in the polygon. This field is used for polygons that - // have a large number of loops, and may be empty for polygons with few loops. - cumulativeEdges []int -} - -// PolygonFromLoops constructs a polygon from the given set of loops. The polygon -// interior consists of the points contained by an odd number of loops. (Recall -// that a loop contains the set of points on its left-hand side.) -// -// This method determines the loop nesting hierarchy and assigns every loop a -// depth. Shells have even depths, and holes have odd depths. -// -// Note: The given set of loops are reordered by this method so that the hierarchy -// can be traversed using Parent, LastDescendant and the loops depths. -func PolygonFromLoops(loops []*Loop) *Polygon { - p := &Polygon{} - // Empty polygons do not contain any loops, even the Empty loop. - if len(loops) == 1 && loops[0].IsEmpty() { - p.initLoopProperties() - return p - } - p.loops = loops - p.initNested() - return p -} - -// PolygonFromOrientedLoops returns a Polygon from the given set of loops, -// like PolygonFromLoops. It expects loops to be oriented such that the polygon -// interior is on the left-hand side of all loops. This implies that shells -// and holes should have opposite orientations in the input to this method. -// (During initialization, loops representing holes will automatically be -// inverted.) -func PolygonFromOrientedLoops(loops []*Loop) *Polygon { - // Here is the algorithm: - // - // 1. Remember which of the given loops contain OriginPoint. - // - // 2. Invert loops as necessary to ensure that they are nestable (i.e., no - // loop contains the complement of any other loop). This may result in a - // set of loops corresponding to the complement of the given polygon, but - // we will fix that problem later. - // - // We make the loops nestable by first normalizing all the loops (i.e., - // inverting any loops whose turning angle is negative). This handles - // all loops except those whose turning angle is very close to zero - // (within the maximum error tolerance). Any such loops are inverted if - // and only if they contain OriginPoint(). (In theory this step is only - // necessary if there are at least two such loops.) The resulting set of - // loops is guaranteed to be nestable. - // - // 3. Build the polygon. This yields either the desired polygon or its - // complement. - // - // 4. If there is at least one loop, we find a loop L that is adjacent to - // OriginPoint() (where "adjacent" means that there exists a path - // connecting OriginPoint() to some vertex of L such that the path does - // not cross any loop). There may be a single such adjacent loop, or - // there may be several (in which case they should all have the same - // contains_origin() value). We choose L to be the loop containing the - // origin whose depth is greatest, or loop(0) (a top-level shell) if no - // such loop exists. - // - // 5. If (L originally contained origin) != (polygon contains origin), we - // invert the polygon. This is done by inverting a top-level shell whose - // turning angle is minimal and then fixing the nesting hierarchy. Note - // that because we normalized all the loops initially, this step is only - // necessary if the polygon requires at least one non-normalized loop to - // represent it. - - containedOrigin := make(map[*Loop]bool) - for _, l := range loops { - containedOrigin[l] = l.ContainsOrigin() - } - - for _, l := range loops { - angle := l.TurningAngle() - if math.Abs(angle) > l.turningAngleMaxError() { - // Normalize the loop. - if angle < 0 { - l.Invert() - } - } else { - // Ensure that the loop does not contain the origin. - if l.ContainsOrigin() { - l.Invert() - } - } - } - - p := PolygonFromLoops(loops) - - if p.NumLoops() > 0 { - originLoop := p.Loop(0) - polygonContainsOrigin := false - for _, l := range p.Loops() { - if l.ContainsOrigin() { - polygonContainsOrigin = !polygonContainsOrigin - - originLoop = l - } - } - if containedOrigin[originLoop] != polygonContainsOrigin { - p.Invert() - } - } - - return p -} - -// Invert inverts the polygon (replaces it by its complement). -func (p *Polygon) Invert() { - // Inverting any one loop will invert the polygon. The best loop to invert - // is the one whose area is largest, since this yields the smallest area - // after inversion. The loop with the largest area is always at depth 0. - // The descendents of this loop all have their depth reduced by 1, while the - // former siblings of this loop all have their depth increased by 1. - - // The empty and full polygons are handled specially. - if p.IsEmpty() { - *p = *FullPolygon() - p.initLoopProperties() - return - } - if p.IsFull() { - *p = Polygon{} - p.initLoopProperties() - return - } - - // Find the loop whose area is largest (i.e., whose turning angle is - // smallest), minimizing calls to TurningAngle(). In particular, for - // polygons with a single shell at level 0 there is no need to call - // TurningAngle() at all. (This method is relatively expensive.) - best := 0 - const none = 10.0 // Flag that means "not computed yet" - bestAngle := none - for i := 1; i < p.NumLoops(); i++ { - if p.Loop(i).depth != 0 { - continue - } - // We defer computing the turning angle of loop 0 until we discover - // that the polygon has another top-level shell. - if bestAngle == none { - bestAngle = p.Loop(best).TurningAngle() - } - angle := p.Loop(i).TurningAngle() - // We break ties deterministically in order to avoid having the output - // depend on the input order of the loops. - if angle < bestAngle || (angle == bestAngle && compareLoops(p.Loop(i), p.Loop(best)) < 0) { - best = i - bestAngle = angle - } - } - // Build the new loops vector, starting with the inverted loop. - p.Loop(best).Invert() - newLoops := make([]*Loop, 0, p.NumLoops()) - // Add the former siblings of this loop as descendants. - lastBest := p.LastDescendant(best) - newLoops = append(newLoops, p.Loop(best)) - for i, l := range p.Loops() { - if i < best || i > lastBest { - l.depth++ - newLoops = append(newLoops, l) - } - } - // Add the former children of this loop as siblings. - for i, l := range p.Loops() { - if i > best && i <= lastBest { - l.depth-- - newLoops = append(newLoops, l) - } - } - - p.loops = newLoops - p.initLoopProperties() -} - -// Defines a total ordering on Loops that does not depend on the cyclic -// order of loop vertices. This function is used to choose which loop to -// invert in the case where several loops have exactly the same area. -func compareLoops(a, b *Loop) int { - if na, nb := a.NumVertices(), b.NumVertices(); na != nb { - return na - nb - } - ai, aDir := a.CanonicalFirstVertex() - bi, bDir := b.CanonicalFirstVertex() - if aDir != bDir { - return aDir - bDir - } - for n := a.NumVertices() - 1; n >= 0; n, ai, bi = n-1, ai+aDir, bi+bDir { - if cmp := a.Vertex(ai).Cmp(b.Vertex(bi).Vector); cmp != 0 { - return cmp - } - } - return 0 -} - -// PolygonFromCell returns a Polygon from a single loop created from the given Cell. -func PolygonFromCell(cell Cell) *Polygon { - return PolygonFromLoops([]*Loop{LoopFromCell(cell)}) -} - -// initNested takes the set of loops in this polygon and performs the nesting -// computations to set the proper nesting and parent/child relationships. -func (p *Polygon) initNested() { - if len(p.loops) == 1 { - p.initOneLoop() - return - } - - lm := make(loopMap) - - for _, l := range p.loops { - lm.insertLoop(l, nil) - } - // The loops have all been added to the loopMap for ordering. Clear the - // loops slice because we add all the loops in-order in initLoops. - p.loops = nil - - // Reorder the loops in depth-first traversal order. - p.initLoops(lm) - p.initLoopProperties() -} - -// loopMap is a map of a loop to its immediate children with respect to nesting. -// It is used to determine which loops are shells and which are holes. -type loopMap map[*Loop][]*Loop - -// insertLoop adds the given loop to the loop map under the specified parent. -// All children of the new entry are checked to see if the need to move up to -// a different level. -func (lm loopMap) insertLoop(newLoop, parent *Loop) { - var children []*Loop - for done := false; !done; { - children = lm[parent] - done = true - for _, child := range children { - if child.ContainsNested(newLoop) { - parent = child - done = false - break - } - } - } - - // Now, we have found a parent for this loop, it may be that some of the - // children of the parent of this loop may now be children of the new loop. - newChildren := lm[newLoop] - for i := 0; i < len(children); { - child := children[i] - if newLoop.ContainsNested(child) { - newChildren = append(newChildren, child) - children = append(children[0:i], children[i+1:]...) - } else { - i++ - } - } - - lm[newLoop] = newChildren - lm[parent] = append(children, newLoop) -} - -// loopStack simplifies access to the loops while being initialized. -type loopStack []*Loop - -func (s *loopStack) push(v *Loop) { - *s = append(*s, v) -} -func (s *loopStack) pop() *Loop { - l := len(*s) - r := (*s)[l-1] - *s = (*s)[:l-1] - return r -} - -// initLoops walks the mapping of loops to all of their children, and adds them in -// order into to the polygons set of loops. -func (p *Polygon) initLoops(lm loopMap) { - var stack loopStack - stack.push(nil) - depth := -1 - - for len(stack) > 0 { - loop := stack.pop() - if loop != nil { - depth = loop.depth - p.loops = append(p.loops, loop) - } - children := lm[loop] - for i := len(children) - 1; i >= 0; i-- { - child := children[i] - child.depth = depth + 1 - stack.push(child) - } - } -} - -// initOneLoop set the properties for a polygon made of a single loop. -// TODO(roberts): Can this be merged with initLoopProperties -func (p *Polygon) initOneLoop() { - p.hasHoles = false - p.numVertices = len(p.loops[0].vertices) - p.bound = p.loops[0].RectBound() - p.subregionBound = ExpandForSubregions(p.bound) - // Ensure the loops depth is set correctly. - p.loops[0].depth = 0 - - p.initEdgesAndIndex() -} - -// initLoopProperties sets the properties for polygons with multiple loops. -func (p *Polygon) initLoopProperties() { - p.numVertices = 0 - // the loops depths are set by initNested/initOriented prior to this. - p.bound = EmptyRect() - p.hasHoles = false - for _, l := range p.loops { - if l.IsHole() { - p.hasHoles = true - } else { - p.bound = p.bound.Union(l.RectBound()) - } - p.numVertices += l.NumVertices() - } - p.subregionBound = ExpandForSubregions(p.bound) - - p.initEdgesAndIndex() -} - -// initEdgesAndIndex performs the shape related initializations and adds the final -// polygon to the index. -func (p *Polygon) initEdgesAndIndex() { - p.numEdges = 0 - p.cumulativeEdges = nil - if p.IsFull() { - return - } - const maxLinearSearchLoops = 12 // Based on benchmarks. - if len(p.loops) > maxLinearSearchLoops { - p.cumulativeEdges = make([]int, 0, len(p.loops)) - } - - for _, l := range p.loops { - if p.cumulativeEdges != nil { - p.cumulativeEdges = append(p.cumulativeEdges, p.numEdges) - } - p.numEdges += len(l.vertices) - } - - p.index = NewShapeIndex() - p.index.Add(p) -} - -// FullPolygon returns a special "full" polygon. -func FullPolygon() *Polygon { - ret := &Polygon{ - loops: []*Loop{ - FullLoop(), - }, - numVertices: len(FullLoop().Vertices()), - bound: FullRect(), - subregionBound: FullRect(), - } - ret.initEdgesAndIndex() - return ret -} - -// Validate checks whether this is a valid polygon, -// including checking whether all the loops are themselves valid. -func (p *Polygon) Validate() error { - for i, l := range p.loops { - // Check for loop errors that don't require building a ShapeIndex. - if err := l.findValidationErrorNoIndex(); err != nil { - return fmt.Errorf("loop %d: %v", i, err) - } - // Check that no loop is empty, and that the full loop only appears in the - // full polygon. - if l.IsEmpty() { - return fmt.Errorf("loop %d: empty loops are not allowed", i) - } - if l.IsFull() && len(p.loops) > 1 { - return fmt.Errorf("loop %d: full loop appears in non-full polygon", i) - } - } - - // TODO(roberts): Uncomment the remaining checks when they are completed. - - // Check for loop self-intersections and loop pairs that cross - // (including duplicate edges and vertices). - // if findSelfIntersection(p.index) { - // return fmt.Errorf("polygon has loop pairs that cross") - // } - - // Check whether initOriented detected inconsistent loop orientations. - // if p.hasInconsistentLoopOrientations { - // return fmt.Errorf("inconsistent loop orientations detected") - // } - - // Finally, verify the loop nesting hierarchy. - return p.findLoopNestingError() -} - -// findLoopNestingError reports if there is an error in the loop nesting hierarchy. -func (p *Polygon) findLoopNestingError() error { - // First check that the loop depths make sense. - lastDepth := -1 - for i, l := range p.loops { - depth := l.depth - if depth < 0 || depth > lastDepth+1 { - return fmt.Errorf("loop %d: invalid loop depth (%d)", i, depth) - } - lastDepth = depth - } - // Then check that they correspond to the actual loop nesting. This test - // is quadratic in the number of loops but the cost per iteration is small. - for i, l := range p.loops { - last := p.LastDescendant(i) - for j, l2 := range p.loops { - if i == j { - continue - } - nested := (j >= i+1) && (j <= last) - const reverseB = false - - if l.containsNonCrossingBoundary(l2, reverseB) != nested { - nestedStr := "" - if !nested { - nestedStr = "not " - } - return fmt.Errorf("invalid nesting: loop %d should %scontain loop %d", i, nestedStr, j) - } - } - } - return nil -} - -// IsEmpty reports whether this is the special "empty" polygon (consisting of no loops). -func (p *Polygon) IsEmpty() bool { - return len(p.loops) == 0 -} - -// IsFull reports whether this is the special "full" polygon (consisting of a -// single loop that encompasses the entire sphere). -func (p *Polygon) IsFull() bool { - return len(p.loops) == 1 && p.loops[0].IsFull() -} - -// NumLoops returns the number of loops in this polygon. -func (p *Polygon) NumLoops() int { - return len(p.loops) -} - -// Loops returns the loops in this polygon. -func (p *Polygon) Loops() []*Loop { - return p.loops -} - -// Loop returns the loop at the given index. Note that during initialization, -// the given loops are reordered according to a pre-order traversal of the loop -// nesting hierarchy. This implies that every loop is immediately followed by -// its descendants. This hierarchy can be traversed using the methods Parent, -// LastDescendant, and Loop.depth. -func (p *Polygon) Loop(k int) *Loop { - return p.loops[k] -} - -// Parent returns the index of the parent of loop k. -// If the loop does not have a parent, ok=false is returned. -func (p *Polygon) Parent(k int) (index int, ok bool) { - // See where we are on the depth hierarchy. - depth := p.loops[k].depth - if depth == 0 { - return -1, false - } - - // There may be several loops at the same nesting level as us that share a - // parent loop with us. (Imagine a slice of swiss cheese, of which we are one loop. - // we don't know how many may be next to us before we get back to our parent loop.) - // Move up one position from us, and then begin traversing back through the set of loops - // until we find the one that is our parent or we get to the top of the polygon. - for k--; k >= 0 && p.loops[k].depth <= depth; k-- { - } - return k, true -} - -// LastDescendant returns the index of the last loop that is contained within loop k. -// If k is negative, it returns the last loop in the polygon. -// Note that loops are indexed according to a pre-order traversal of the nesting -// hierarchy, so the immediate children of loop k can be found by iterating over -// the loops (k+1)..LastDescendant(k) and selecting those whose depth is equal -// to Loop(k).depth+1. -func (p *Polygon) LastDescendant(k int) int { - if k < 0 { - return len(p.loops) - 1 - } - - depth := p.loops[k].depth - - // Find the next loop immediately past us in the set of loops, and then start - // moving down the list until we either get to the end or find the next loop - // that is higher up the hierarchy than we are. - for k++; k < len(p.loops) && p.loops[k].depth > depth; k++ { - } - return k - 1 -} - -// CapBound returns a bounding spherical cap. -func (p *Polygon) CapBound() Cap { return p.bound.CapBound() } - -// RectBound returns a bounding latitude-longitude rectangle. -func (p *Polygon) RectBound() Rect { return p.bound } - -// ContainsPoint reports whether the polygon contains the point. -func (p *Polygon) ContainsPoint(point Point) bool { - // NOTE: A bounds check slows down this function by about 50%. It is - // worthwhile only when it might allow us to delay building the index. - if !p.index.IsFresh() && !p.bound.ContainsPoint(point) { - return false - } - - // For small polygons, and during initial construction, it is faster to just - // check all the crossing. - const maxBruteForceVertices = 32 - if p.numVertices < maxBruteForceVertices || p.index == nil { - inside := false - for _, l := range p.loops { - // use loops bruteforce to avoid building the index on each loop. - inside = inside != l.bruteForceContainsPoint(point) - } - return inside - } - - // Otherwise we look up the ShapeIndex cell containing this point. - return NewContainsPointQuery(p.index, VertexModelSemiOpen).Contains(point) -} - -// ContainsCell reports whether the polygon contains the given cell. -func (p *Polygon) ContainsCell(cell Cell) bool { - it := p.index.Iterator() - relation := it.LocateCellID(cell.ID()) - - // If "cell" is disjoint from all index cells, it is not contained. - // Similarly, if "cell" is subdivided into one or more index cells then it - // is not contained, since index cells are subdivided only if they (nearly) - // intersect a sufficient number of edges. (But note that if "cell" itself - // is an index cell then it may be contained, since it could be a cell with - // no edges in the loop interior.) - if relation != Indexed { - return false - } - - // Otherwise check if any edges intersect "cell". - if p.boundaryApproxIntersects(it, cell) { - return false - } - - // Otherwise check if the loop contains the center of "cell". - return p.iteratorContainsPoint(it, cell.Center()) -} - -// IntersectsCell reports whether the polygon intersects the given cell. -func (p *Polygon) IntersectsCell(cell Cell) bool { - it := p.index.Iterator() - relation := it.LocateCellID(cell.ID()) - - // If cell does not overlap any index cell, there is no intersection. - if relation == Disjoint { - return false - } - // If cell is subdivided into one or more index cells, there is an - // intersection to within the S2ShapeIndex error bound (see Contains). - if relation == Subdivided { - return true - } - // If cell is an index cell, there is an intersection because index cells - // are created only if they have at least one edge or they are entirely - // contained by the loop. - if it.CellID() == cell.id { - return true - } - // Otherwise check if any edges intersect cell. - if p.boundaryApproxIntersects(it, cell) { - return true - } - // Otherwise check if the loop contains the center of cell. - return p.iteratorContainsPoint(it, cell.Center()) -} - -// CellUnionBound computes a covering of the Polygon. -func (p *Polygon) CellUnionBound() []CellID { - // TODO(roberts): Use ShapeIndexRegion when it's available. - return p.CapBound().CellUnionBound() -} - -// boundaryApproxIntersects reports whether the loop's boundary intersects cell. -// It may also return true when the loop boundary does not intersect cell but -// some edge comes within the worst-case error tolerance. -// -// This requires that it.Locate(cell) returned Indexed. -func (p *Polygon) boundaryApproxIntersects(it *ShapeIndexIterator, cell Cell) bool { - aClipped := it.IndexCell().findByShapeID(0) - - // If there are no edges, there is no intersection. - if len(aClipped.edges) == 0 { - return false - } - - // We can save some work if cell is the index cell itself. - if it.CellID() == cell.ID() { - return true - } - - // Otherwise check whether any of the edges intersect cell. - maxError := (faceClipErrorUVCoord + intersectsRectErrorUVDist) - bound := cell.BoundUV().ExpandedByMargin(maxError) - for _, e := range aClipped.edges { - edge := p.index.Shape(0).Edge(e) - v0, v1, ok := ClipToPaddedFace(edge.V0, edge.V1, cell.Face(), maxError) - if ok && edgeIntersectsRect(v0, v1, bound) { - return true - } - } - - return false -} - -// iteratorContainsPoint reports whether the iterator that is positioned at the -// ShapeIndexCell that may contain p, contains the point p. -func (p *Polygon) iteratorContainsPoint(it *ShapeIndexIterator, point Point) bool { - // Test containment by drawing a line segment from the cell center to the - // given point and counting edge crossings. - aClipped := it.IndexCell().findByShapeID(0) - inside := aClipped.containsCenter - - if len(aClipped.edges) == 0 { - return inside - } - - // This block requires ShapeIndex. - crosser := NewEdgeCrosser(it.Center(), point) - shape := p.index.Shape(0) - for _, e := range aClipped.edges { - edge := shape.Edge(e) - inside = inside != crosser.EdgeOrVertexCrossing(edge.V0, edge.V1) - } - - return inside -} - -// Shape Interface - -// NumEdges returns the number of edges in this shape. -func (p *Polygon) NumEdges() int { - return p.numEdges -} - -// Edge returns endpoints for the given edge index. -func (p *Polygon) Edge(e int) Edge { - var i int - - if len(p.cumulativeEdges) > 0 { - for i = range p.cumulativeEdges { - if i+1 >= len(p.cumulativeEdges) || e < p.cumulativeEdges[i+1] { - e -= p.cumulativeEdges[i] - break - } - } - } else { - // When the number of loops is small, use linear search. Most often - // there is exactly one loop and the code below executes zero times. - for i = 0; e >= len(p.Loop(i).vertices); i++ { - e -= len(p.Loop(i).vertices) - } - } - - return Edge{p.Loop(i).OrientedVertex(e), p.Loop(i).OrientedVertex(e + 1)} -} - -// ReferencePoint returns the reference point for this polygon. -func (p *Polygon) ReferencePoint() ReferencePoint { - containsOrigin := false - for _, l := range p.loops { - containsOrigin = containsOrigin != l.ContainsOrigin() - } - return OriginReferencePoint(containsOrigin) -} - -// NumChains reports the number of contiguous edge chains in the Polygon. -func (p *Polygon) NumChains() int { - return p.NumLoops() -} - -// Chain returns the i-th edge Chain (loop) in the Shape. -func (p *Polygon) Chain(chainID int) Chain { - if p.cumulativeEdges != nil { - return Chain{p.cumulativeEdges[chainID], len(p.Loop(chainID).vertices)} - } - e := 0 - for j := 0; j < chainID; j++ { - e += len(p.Loop(j).vertices) - } - - // Polygon represents a full loop as a loop with one vertex, while - // Shape represents a full loop as a chain with no vertices. - if numVertices := p.Loop(chainID).NumVertices(); numVertices != 1 { - return Chain{e, numVertices} - } - return Chain{e, 0} -} - -// ChainEdge returns the j-th edge of the i-th edge Chain (loop). -func (p *Polygon) ChainEdge(i, j int) Edge { - return Edge{p.Loop(i).OrientedVertex(j), p.Loop(i).OrientedVertex(j + 1)} -} - -// ChainPosition returns a pair (i, j) such that edgeID is the j-th edge -// of the i-th edge Chain. -func (p *Polygon) ChainPosition(edgeID int) ChainPosition { - var i int - - if len(p.cumulativeEdges) > 0 { - for i = range p.cumulativeEdges { - if i+1 >= len(p.cumulativeEdges) || edgeID < p.cumulativeEdges[i+1] { - edgeID -= p.cumulativeEdges[i] - break - } - } - } else { - // When the number of loops is small, use linear search. Most often - // there is exactly one loop and the code below executes zero times. - for i = 0; edgeID >= len(p.Loop(i).vertices); i++ { - edgeID -= len(p.Loop(i).vertices) - } - } - // TODO(roberts): unify this and Edge since they are mostly identical. - return ChainPosition{i, edgeID} -} - -// Dimension returns the dimension of the geometry represented by this Polygon. -func (p *Polygon) Dimension() int { return 2 } - -func (p *Polygon) typeTag() typeTag { return typeTagPolygon } - -func (p *Polygon) privateInterface() {} - -// Contains reports whether this polygon contains the other polygon. -// Specifically, it reports whether all the points in the other polygon -// are also in this polygon. -func (p *Polygon) Contains(o *Polygon) bool { - // If both polygons have one loop, use the more efficient Loop method. - // Note that Loop's Contains does its own bounding rectangle check. - if len(p.loops) == 1 && len(o.loops) == 1 { - return p.loops[0].Contains(o.loops[0]) - } - - // Otherwise if neither polygon has holes, we can still use the more - // efficient Loop's Contains method (rather than compareBoundary), - // but it's worthwhile to do our own bounds check first. - if !p.subregionBound.Contains(o.bound) { - // Even though Bound(A) does not contain Bound(B), it is still possible - // that A contains B. This can only happen when union of the two bounds - // spans all longitudes. For example, suppose that B consists of two - // shells with a longitude gap between them, while A consists of one shell - // that surrounds both shells of B but goes the other way around the - // sphere (so that it does not intersect the longitude gap). - if !p.bound.Lng.Union(o.bound.Lng).IsFull() { - return false - } - } - - if !p.hasHoles && !o.hasHoles { - for _, l := range o.loops { - if !p.anyLoopContains(l) { - return false - } - } - return true - } - - // Polygon A contains B iff B does not intersect the complement of A. From - // the intersection algorithm below, this means that the complement of A - // must exclude the entire boundary of B, and B must exclude all shell - // boundaries of the complement of A. (It can be shown that B must then - // exclude the entire boundary of the complement of A.) The first call - // below returns false if the boundaries cross, therefore the second call - // does not need to check for any crossing edges (which makes it cheaper). - return p.containsBoundary(o) && o.excludesNonCrossingComplementShells(p) -} - -// Intersects reports whether this polygon intersects the other polygon, i.e. -// if there is a point that is contained by both polygons. -func (p *Polygon) Intersects(o *Polygon) bool { - // If both polygons have one loop, use the more efficient Loop method. - // Note that Loop Intersects does its own bounding rectangle check. - if len(p.loops) == 1 && len(o.loops) == 1 { - return p.loops[0].Intersects(o.loops[0]) - } - - // Otherwise if neither polygon has holes, we can still use the more - // efficient Loop.Intersects method. The polygons intersect if and - // only if some pair of loop regions intersect. - if !p.bound.Intersects(o.bound) { - return false - } - - if !p.hasHoles && !o.hasHoles { - for _, l := range o.loops { - if p.anyLoopIntersects(l) { - return true - } - } - return false - } - - // Polygon A is disjoint from B if A excludes the entire boundary of B and B - // excludes all shell boundaries of A. (It can be shown that B must then - // exclude the entire boundary of A.) The first call below returns false if - // the boundaries cross, therefore the second call does not need to check - // for crossing edges. - return !p.excludesBoundary(o) || !o.excludesNonCrossingShells(p) -} - -// compareBoundary returns +1 if this polygon contains the boundary of B, -1 if A -// excludes the boundary of B, and 0 if the boundaries of A and B cross. -func (p *Polygon) compareBoundary(o *Loop) int { - result := -1 - for i := 0; i < len(p.loops) && result != 0; i++ { - // If B crosses any loop of A, the result is 0. Otherwise the result - // changes sign each time B is contained by a loop of A. - result *= -p.loops[i].compareBoundary(o) - } - return result -} - -// containsBoundary reports whether this polygon contains the entire boundary of B. -func (p *Polygon) containsBoundary(o *Polygon) bool { - for _, l := range o.loops { - if p.compareBoundary(l) <= 0 { - return false - } - } - return true -} - -// excludesBoundary reports whether this polygon excludes the entire boundary of B. -func (p *Polygon) excludesBoundary(o *Polygon) bool { - for _, l := range o.loops { - if p.compareBoundary(l) >= 0 { - return false - } - } - return true -} - -// containsNonCrossingBoundary reports whether polygon A contains the boundary of -// loop B. Shared edges are handled according to the rule described in loops -// containsNonCrossingBoundary. -func (p *Polygon) containsNonCrossingBoundary(o *Loop, reverse bool) bool { - var inside bool - for _, l := range p.loops { - x := l.containsNonCrossingBoundary(o, reverse) - inside = (inside != x) - } - return inside -} - -// excludesNonCrossingShells reports wheterh given two polygons A and B such that the -// boundary of A does not cross any loop of B, if A excludes all shell boundaries of B. -func (p *Polygon) excludesNonCrossingShells(o *Polygon) bool { - for _, l := range o.loops { - if l.IsHole() { - continue - } - if p.containsNonCrossingBoundary(l, false) { - return false - } - } - return true -} - -// excludesNonCrossingComplementShells reports whether given two polygons A and B -// such that the boundary of A does not cross any loop of B, if A excludes all -// shell boundaries of the complement of B. -func (p *Polygon) excludesNonCrossingComplementShells(o *Polygon) bool { - // Special case to handle the complement of the empty or full polygons. - if o.IsEmpty() { - return !p.IsFull() - } - if o.IsFull() { - return true - } - - // Otherwise the complement of B may be obtained by inverting loop(0) and - // then swapping the shell/hole status of all other loops. This implies - // that the shells of the complement consist of loop 0 plus all the holes of - // the original polygon. - for j, l := range o.loops { - if j > 0 && !l.IsHole() { - continue - } - - // The interior of the complement is to the right of loop 0, and to the - // left of the loops that were originally holes. - if p.containsNonCrossingBoundary(l, j == 0) { - return false - } - } - return true -} - -// anyLoopContains reports whether any loop in this polygon contains the given loop. -func (p *Polygon) anyLoopContains(o *Loop) bool { - for _, l := range p.loops { - if l.Contains(o) { - return true - } - } - return false -} - -// anyLoopIntersects reports whether any loop in this polygon intersects the given loop. -func (p *Polygon) anyLoopIntersects(o *Loop) bool { - for _, l := range p.loops { - if l.Intersects(o) { - return true - } - } - return false -} - -// Area returns the area of the polygon interior, i.e. the region on the left side -// of an odd number of loops. The return value is between 0 and 4*Pi. -func (p *Polygon) Area() float64 { - var area float64 - for _, loop := range p.loops { - area += float64(loop.Sign()) * loop.Area() - } - return area -} - -// Encode encodes the Polygon -func (p *Polygon) Encode(w io.Writer) error { - e := &encoder{w: w} - p.encode(e) - return e.err -} - -// encode only supports lossless encoding and not compressed format. -func (p *Polygon) encode(e *encoder) { - if p.numVertices == 0 { - p.encodeCompressed(e, maxLevel, nil) - return - } - - // Convert all the polygon vertices to XYZFaceSiTi format. - vs := make([]xyzFaceSiTi, 0, p.numVertices) - for _, l := range p.loops { - vs = append(vs, l.xyzFaceSiTiVertices()...) - } - - // Computes a histogram of the cell levels at which the vertices are snapped. - // (histogram[0] is the number of unsnapped vertices, histogram[i] the number - // of vertices snapped at level i-1). - histogram := make([]int, maxLevel+2) - for _, v := range vs { - histogram[v.level+1]++ - } - - // Compute the level at which most of the vertices are snapped. - // If multiple levels have the same maximum number of vertices - // snapped to it, the first one (lowest level number / largest - // area / smallest encoding length) will be chosen, so this - // is desired. - var snapLevel, numSnapped int - for level, h := range histogram[1:] { - if h > numSnapped { - snapLevel, numSnapped = level, h - } - } - - // Choose an encoding format based on the number of unsnapped vertices and a - // rough estimate of the encoded sizes. - numUnsnapped := p.numVertices - numSnapped // Number of vertices that won't be snapped at snapLevel. - const pointSize = 3 * 8 // s2.Point is an r3.Vector, which is 3 float64s. That's 3*8 = 24 bytes. - compressedSize := 4*p.numVertices + (pointSize+2)*numUnsnapped - losslessSize := pointSize * p.numVertices - if compressedSize < losslessSize { - p.encodeCompressed(e, snapLevel, vs) - } else { - p.encodeLossless(e) - } -} - -// encodeLossless encodes the polygon's Points as float64s. -func (p *Polygon) encodeLossless(e *encoder) { - e.writeInt8(encodingVersion) - e.writeBool(true) // a legacy c++ value. must be true. - e.writeBool(p.hasHoles) - e.writeUint32(uint32(len(p.loops))) - - if e.err != nil { - return - } - if len(p.loops) > maxEncodedLoops { - e.err = fmt.Errorf("too many loops (%d; max is %d)", len(p.loops), maxEncodedLoops) - return - } - for _, l := range p.loops { - l.encode(e) - } - - // Encode the bound. - p.bound.encode(e) -} - -func (p *Polygon) encodeCompressed(e *encoder, snapLevel int, vertices []xyzFaceSiTi) { - e.writeUint8(uint8(encodingCompressedVersion)) - e.writeUint8(uint8(snapLevel)) - e.writeUvarint(uint64(len(p.loops))) - - if e.err != nil { - return - } - if l := len(p.loops); l > maxEncodedLoops { - e.err = fmt.Errorf("too many loops to encode: %d; max is %d", l, maxEncodedLoops) - return - } - - for _, l := range p.loops { - l.encodeCompressed(e, snapLevel, vertices[:len(l.vertices)]) - vertices = vertices[len(l.vertices):] - } - // Do not write the bound, num_vertices, or has_holes_ as they can be - // cheaply recomputed by decodeCompressed. Microbenchmarks show the - // speed difference is inconsequential. -} - -// Decode decodes the Polygon. -func (p *Polygon) Decode(r io.Reader) error { - d := &decoder{r: asByteReader(r)} - version := int8(d.readUint8()) - var dec func(*decoder) - switch version { - case encodingVersion: - dec = p.decode - case encodingCompressedVersion: - dec = p.decodeCompressed - default: - return fmt.Errorf("unsupported version %d", version) - } - dec(d) - return d.err -} - -// maxEncodedLoops is the biggest supported number of loops in a polygon during encoding. -// Setting a maximum guards an allocation: it prevents an attacker from easily pushing us OOM. -const maxEncodedLoops = 10000000 - -func (p *Polygon) decode(d *decoder) { - *p = Polygon{} - d.readUint8() // Ignore irrelevant serialized owns_loops_ value. - - p.hasHoles = d.readBool() - - // Polygons with no loops are explicitly allowed here: a newly created - // polygon has zero loops and such polygons encode and decode properly. - nloops := d.readUint32() - if d.err != nil { - return - } - if nloops > maxEncodedLoops { - d.err = fmt.Errorf("too many loops (%d; max is %d)", nloops, maxEncodedLoops) - return - } - p.loops = make([]*Loop, nloops) - for i := range p.loops { - p.loops[i] = new(Loop) - p.loops[i].decode(d) - p.numVertices += len(p.loops[i].vertices) - } - - p.bound.decode(d) - if d.err != nil { - return - } - p.subregionBound = ExpandForSubregions(p.bound) - p.initEdgesAndIndex() -} - -func (p *Polygon) decodeCompressed(d *decoder) { - snapLevel := int(d.readUint8()) - - if snapLevel > maxLevel { - d.err = fmt.Errorf("snaplevel too big: %d", snapLevel) - return - } - // Polygons with no loops are explicitly allowed here: a newly created - // polygon has zero loops and such polygons encode and decode properly. - nloops := int(d.readUvarint()) - if nloops > maxEncodedLoops { - d.err = fmt.Errorf("too many loops (%d; max is %d)", nloops, maxEncodedLoops) - } - p.loops = make([]*Loop, nloops) - for i := range p.loops { - p.loops[i] = new(Loop) - p.loops[i].decodeCompressed(d, snapLevel) - } - p.initLoopProperties() -} - -// TODO(roberts): Differences from C++ -// Centroid -// SnapLevel -// DistanceToPoint -// DistanceToBoundary -// Project -// ProjectToBoundary -// ApproxContains/ApproxDisjoint for Polygons -// InitTo{Intersection/ApproxIntersection/Union/ApproxUnion/Diff/ApproxDiff} -// InitToSimplified -// InitToSnapped -// IntersectWithPolyline -// ApproxIntersectWithPolyline -// SubtractFromPolyline -// ApproxSubtractFromPolyline -// DestructiveUnion -// DestructiveApproxUnion -// InitToCellUnionBorder -// IsNormalized -// Equal/BoundaryEqual/BoundaryApproxEqual/BoundaryNear Polygons -// BreakEdgesAndAddToBuilder -// -// clearLoops -// findLoopNestingError -// initToSimplifiedInternal -// internalClipPolyline -// clipBoundary diff --git a/vendor/github.com/golang/geo/s2/polyline.go b/vendor/github.com/golang/geo/s2/polyline.go deleted file mode 100644 index 517968342..000000000 --- a/vendor/github.com/golang/geo/s2/polyline.go +++ /dev/null @@ -1,589 +0,0 @@ -// Copyright 2016 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "math" - - "github.com/golang/geo/s1" -) - -// Polyline represents a sequence of zero or more vertices connected by -// straight edges (geodesics). Edges of length 0 and 180 degrees are not -// allowed, i.e. adjacent vertices should not be identical or antipodal. -type Polyline []Point - -// PolylineFromLatLngs creates a new Polyline from the given LatLngs. -func PolylineFromLatLngs(points []LatLng) *Polyline { - p := make(Polyline, len(points)) - for k, v := range points { - p[k] = PointFromLatLng(v) - } - return &p -} - -// Reverse reverses the order of the Polyline vertices. -func (p *Polyline) Reverse() { - for i := 0; i < len(*p)/2; i++ { - (*p)[i], (*p)[len(*p)-i-1] = (*p)[len(*p)-i-1], (*p)[i] - } -} - -// Length returns the length of this Polyline. -func (p *Polyline) Length() s1.Angle { - var length s1.Angle - - for i := 1; i < len(*p); i++ { - length += (*p)[i-1].Distance((*p)[i]) - } - return length -} - -// Centroid returns the true centroid of the polyline multiplied by the length of the -// polyline. The result is not unit length, so you may wish to normalize it. -// -// Scaling by the Polyline length makes it easy to compute the centroid -// of several Polylines (by simply adding up their centroids). -func (p *Polyline) Centroid() Point { - var centroid Point - for i := 1; i < len(*p); i++ { - // The centroid (multiplied by length) is a vector toward the midpoint - // of the edge, whose length is twice the sin of half the angle between - // the two vertices. Defining theta to be this angle, we have: - vSum := (*p)[i-1].Add((*p)[i].Vector) // Length == 2*cos(theta) - vDiff := (*p)[i-1].Sub((*p)[i].Vector) // Length == 2*sin(theta) - - // Length == 2*sin(theta) - centroid = Point{centroid.Add(vSum.Mul(math.Sqrt(vDiff.Norm2() / vSum.Norm2())))} - } - return centroid -} - -// Equal reports whether the given Polyline is exactly the same as this one. -func (p *Polyline) Equal(b *Polyline) bool { - if len(*p) != len(*b) { - return false - } - for i, v := range *p { - if v != (*b)[i] { - return false - } - } - - return true -} - -// ApproxEqual reports whether two polylines have the same number of vertices, -// and corresponding vertex pairs are separated by no more the standard margin. -func (p *Polyline) ApproxEqual(o *Polyline) bool { - return p.approxEqual(o, s1.Angle(epsilon)) -} - -// approxEqual reports whether two polylines are equal within the given margin. -func (p *Polyline) approxEqual(o *Polyline, maxError s1.Angle) bool { - if len(*p) != len(*o) { - return false - } - for offset, val := range *p { - if !val.approxEqual((*o)[offset], maxError) { - return false - } - } - return true -} - -// CapBound returns the bounding Cap for this Polyline. -func (p *Polyline) CapBound() Cap { - return p.RectBound().CapBound() -} - -// RectBound returns the bounding Rect for this Polyline. -func (p *Polyline) RectBound() Rect { - rb := NewRectBounder() - for _, v := range *p { - rb.AddPoint(v) - } - return rb.RectBound() -} - -// ContainsCell reports whether this Polyline contains the given Cell. Always returns false -// because "containment" is not numerically well-defined except at the Polyline vertices. -func (p *Polyline) ContainsCell(cell Cell) bool { - return false -} - -// IntersectsCell reports whether this Polyline intersects the given Cell. -func (p *Polyline) IntersectsCell(cell Cell) bool { - if len(*p) == 0 { - return false - } - - // We only need to check whether the cell contains vertex 0 for correctness, - // but these tests are cheap compared to edge crossings so we might as well - // check all the vertices. - for _, v := range *p { - if cell.ContainsPoint(v) { - return true - } - } - - cellVertices := []Point{ - cell.Vertex(0), - cell.Vertex(1), - cell.Vertex(2), - cell.Vertex(3), - } - - for j := 0; j < 4; j++ { - crosser := NewChainEdgeCrosser(cellVertices[j], cellVertices[(j+1)&3], (*p)[0]) - for i := 1; i < len(*p); i++ { - if crosser.ChainCrossingSign((*p)[i]) != DoNotCross { - // There is a proper crossing, or two vertices were the same. - return true - } - } - } - return false -} - -// ContainsPoint returns false since Polylines are not closed. -func (p *Polyline) ContainsPoint(point Point) bool { - return false -} - -// CellUnionBound computes a covering of the Polyline. -func (p *Polyline) CellUnionBound() []CellID { - return p.CapBound().CellUnionBound() -} - -// NumEdges returns the number of edges in this shape. -func (p *Polyline) NumEdges() int { - if len(*p) == 0 { - return 0 - } - return len(*p) - 1 -} - -// Edge returns endpoints for the given edge index. -func (p *Polyline) Edge(i int) Edge { - return Edge{(*p)[i], (*p)[i+1]} -} - -// ReferencePoint returns the default reference point with negative containment because Polylines are not closed. -func (p *Polyline) ReferencePoint() ReferencePoint { - return OriginReferencePoint(false) -} - -// NumChains reports the number of contiguous edge chains in this Polyline. -func (p *Polyline) NumChains() int { - return minInt(1, p.NumEdges()) -} - -// Chain returns the i-th edge Chain in the Shape. -func (p *Polyline) Chain(chainID int) Chain { - return Chain{0, p.NumEdges()} -} - -// ChainEdge returns the j-th edge of the i-th edge Chain. -func (p *Polyline) ChainEdge(chainID, offset int) Edge { - return Edge{(*p)[offset], (*p)[offset+1]} -} - -// ChainPosition returns a pair (i, j) such that edgeID is the j-th edge -func (p *Polyline) ChainPosition(edgeID int) ChainPosition { - return ChainPosition{0, edgeID} -} - -// Dimension returns the dimension of the geometry represented by this Polyline. -func (p *Polyline) Dimension() int { return 1 } - -// IsEmpty reports whether this shape contains no points. -func (p *Polyline) IsEmpty() bool { return defaultShapeIsEmpty(p) } - -// IsFull reports whether this shape contains all points on the sphere. -func (p *Polyline) IsFull() bool { return defaultShapeIsFull(p) } - -func (p *Polyline) typeTag() typeTag { return typeTagPolyline } - -func (p *Polyline) privateInterface() {} - -// findEndVertex reports the maximal end index such that the line segment between -// the start index and this one such that the line segment between these two -// vertices passes within the given tolerance of all interior vertices, in order. -func findEndVertex(p Polyline, tolerance s1.Angle, index int) int { - // The basic idea is to keep track of the "pie wedge" of angles - // from the starting vertex such that a ray from the starting - // vertex at that angle will pass through the discs of radius - // tolerance centered around all vertices processed so far. - // - // First we define a coordinate frame for the tangent and normal - // spaces at the starting vertex. Essentially this means picking - // three orthonormal vectors X,Y,Z such that X and Y span the - // tangent plane at the starting vertex, and Z is up. We use - // the coordinate frame to define a mapping from 3D direction - // vectors to a one-dimensional ray angle in the range (-π, - // π]. The angle of a direction vector is computed by - // transforming it into the X,Y,Z basis, and then calculating - // atan2(y,x). This mapping allows us to represent a wedge of - // angles as a 1D interval. Since the interval wraps around, we - // represent it as an Interval, i.e. an interval on the unit - // circle. - origin := p[index] - frame := getFrame(origin) - - // As we go along, we keep track of the current wedge of angles - // and the distance to the last vertex (which must be - // non-decreasing). - currentWedge := s1.FullInterval() - var lastDistance s1.Angle - - for index++; index < len(p); index++ { - candidate := p[index] - distance := origin.Distance(candidate) - - // We don't allow simplification to create edges longer than - // 90 degrees, to avoid numeric instability as lengths - // approach 180 degrees. We do need to allow for original - // edges longer than 90 degrees, though. - if distance > math.Pi/2 && lastDistance > 0 { - break - } - - // Vertices must be in increasing order along the ray, except - // for the initial disc around the origin. - if distance < lastDistance && lastDistance > tolerance { - break - } - - lastDistance = distance - - // Points that are within the tolerance distance of the origin - // do not constrain the ray direction, so we can ignore them. - if distance <= tolerance { - continue - } - - // If the current wedge of angles does not contain the angle - // to this vertex, then stop right now. Note that the wedge - // of possible ray angles is not necessarily empty yet, but we - // can't continue unless we are willing to backtrack to the - // last vertex that was contained within the wedge (since we - // don't create new vertices). This would be more complicated - // and also make the worst-case running time more than linear. - direction := toFrame(frame, candidate) - center := math.Atan2(direction.Y, direction.X) - if !currentWedge.Contains(center) { - break - } - - // To determine how this vertex constrains the possible ray - // angles, consider the triangle ABC where A is the origin, B - // is the candidate vertex, and C is one of the two tangent - // points between A and the spherical cap of radius - // tolerance centered at B. Then from the spherical law of - // sines, sin(a)/sin(A) = sin(c)/sin(C), where a and c are - // the lengths of the edges opposite A and C. In our case C - // is a 90 degree angle, therefore A = asin(sin(a) / sin(c)). - // Angle A is the half-angle of the allowable wedge. - halfAngle := math.Asin(math.Sin(tolerance.Radians()) / math.Sin(distance.Radians())) - target := s1.IntervalFromPointPair(center, center).Expanded(halfAngle) - currentWedge = currentWedge.Intersection(target) - } - - // We break out of the loop when we reach a vertex index that - // can't be included in the line segment, so back up by one - // vertex. - return index - 1 -} - -// SubsampleVertices returns a subsequence of vertex indices such that the -// polyline connecting these vertices is never further than the given tolerance from -// the original polyline. Provided the first and last vertices are distinct, -// they are always preserved; if they are not, the subsequence may contain -// only a single index. -// -// Some useful properties of the algorithm: -// -// - It runs in linear time. -// -// - The output always represents a valid polyline. In particular, adjacent -// output vertices are never identical or antipodal. -// -// - The method is not optimal, but it tends to produce 2-3% fewer -// vertices than the Douglas-Peucker algorithm with the same tolerance. -// -// - The output is parametrically equivalent to the original polyline to -// within the given tolerance. For example, if a polyline backtracks on -// itself and then proceeds onwards, the backtracking will be preserved -// (to within the given tolerance). This is different than the -// Douglas-Peucker algorithm which only guarantees geometric equivalence. -func (p *Polyline) SubsampleVertices(tolerance s1.Angle) []int { - var result []int - - if len(*p) < 1 { - return result - } - - result = append(result, 0) - clampedTolerance := s1.Angle(math.Max(tolerance.Radians(), 0)) - - for index := 0; index+1 < len(*p); { - nextIndex := findEndVertex(*p, clampedTolerance, index) - // Don't create duplicate adjacent vertices. - if (*p)[nextIndex] != (*p)[index] { - result = append(result, nextIndex) - } - index = nextIndex - } - - return result -} - -// Encode encodes the Polyline. -func (p Polyline) Encode(w io.Writer) error { - e := &encoder{w: w} - p.encode(e) - return e.err -} - -func (p Polyline) encode(e *encoder) { - e.writeInt8(encodingVersion) - e.writeUint32(uint32(len(p))) - for _, v := range p { - e.writeFloat64(v.X) - e.writeFloat64(v.Y) - e.writeFloat64(v.Z) - } -} - -// Decode decodes the polyline. -func (p *Polyline) Decode(r io.Reader) error { - d := decoder{r: asByteReader(r)} - p.decode(d) - return d.err -} - -func (p *Polyline) decode(d decoder) { - version := d.readInt8() - if d.err != nil { - return - } - if int(version) != int(encodingVersion) { - d.err = fmt.Errorf("can't decode version %d; my version: %d", version, encodingVersion) - return - } - nvertices := d.readUint32() - if d.err != nil { - return - } - if nvertices > maxEncodedVertices { - d.err = fmt.Errorf("too many vertices (%d; max is %d)", nvertices, maxEncodedVertices) - return - } - *p = make([]Point, nvertices) - for i := range *p { - (*p)[i].X = d.readFloat64() - (*p)[i].Y = d.readFloat64() - (*p)[i].Z = d.readFloat64() - } -} - -// Project returns a point on the polyline that is closest to the given point, -// and the index of the next vertex after the projected point. The -// value of that index is always in the range [1, len(polyline)]. -// The polyline must not be empty. -func (p *Polyline) Project(point Point) (Point, int) { - if len(*p) == 1 { - // If there is only one vertex, it is always closest to any given point. - return (*p)[0], 1 - } - - // Initial value larger than any possible distance on the unit sphere. - minDist := 10 * s1.Radian - minIndex := -1 - - // Find the line segment in the polyline that is closest to the point given. - for i := 1; i < len(*p); i++ { - if dist := DistanceFromSegment(point, (*p)[i-1], (*p)[i]); dist < minDist { - minDist = dist - minIndex = i - } - } - - // Compute the point on the segment found that is closest to the point given. - closest := Project(point, (*p)[minIndex-1], (*p)[minIndex]) - if closest == (*p)[minIndex] { - minIndex++ - } - - return closest, minIndex -} - -// IsOnRight reports whether the point given is on the right hand side of the -// polyline, using a naive definition of "right-hand-sideness" where the point -// is on the RHS of the polyline iff the point is on the RHS of the line segment -// in the polyline which it is closest to. -// The polyline must have at least 2 vertices. -func (p *Polyline) IsOnRight(point Point) bool { - // If the closest point C is an interior vertex of the polyline, let B and D - // be the previous and next vertices. The given point P is on the right of - // the polyline (locally) if B, P, D are ordered CCW around vertex C. - closest, next := p.Project(point) - if closest == (*p)[next-1] && next > 1 && next < len(*p) { - if point == (*p)[next-1] { - // Polyline vertices are not on the RHS. - return false - } - return OrderedCCW((*p)[next-2], point, (*p)[next], (*p)[next-1]) - } - // Otherwise, the closest point C is incident to exactly one polyline edge. - // We test the point P against that edge. - if next == len(*p) { - next-- - } - return Sign(point, (*p)[next], (*p)[next-1]) -} - -// Validate checks whether this is a valid polyline or not. -func (p *Polyline) Validate() error { - // All vertices must be unit length. - for i, pt := range *p { - if !pt.IsUnit() { - return fmt.Errorf("vertex %d is not unit length", i) - } - } - - // Adjacent vertices must not be identical or antipodal. - for i := 1; i < len(*p); i++ { - prev, cur := (*p)[i-1], (*p)[i] - if prev == cur { - return fmt.Errorf("vertices %d and %d are identical", i-1, i) - } - if prev == (Point{cur.Mul(-1)}) { - return fmt.Errorf("vertices %d and %d are antipodal", i-1, i) - } - } - - return nil -} - -// Intersects reports whether this polyline intersects the given polyline. If -// the polylines share a vertex they are considered to be intersecting. When a -// polyline endpoint is the only intersection with the other polyline, the -// function may return true or false arbitrarily. -// -// The running time is quadratic in the number of vertices. -func (p *Polyline) Intersects(o *Polyline) bool { - if len(*p) == 0 || len(*o) == 0 { - return false - } - - if !p.RectBound().Intersects(o.RectBound()) { - return false - } - - // TODO(roberts): Use ShapeIndex here. - for i := 1; i < len(*p); i++ { - crosser := NewChainEdgeCrosser((*p)[i-1], (*p)[i], (*o)[0]) - for j := 1; j < len(*o); j++ { - if crosser.ChainCrossingSign((*o)[j]) != DoNotCross { - return true - } - } - } - return false -} - -// Interpolate returns the point whose distance from vertex 0 along the polyline is -// the given fraction of the polyline's total length, and the index of -// the next vertex after the interpolated point P. Fractions less than zero -// or greater than one are clamped. The return value is unit length. The cost of -// this function is currently linear in the number of vertices. -// -// This method allows the caller to easily construct a given suffix of the -// polyline by concatenating P with the polyline vertices starting at that next -// vertex. Note that P is guaranteed to be different than the point at the next -// vertex, so this will never result in a duplicate vertex. -// -// The polyline must not be empty. Note that if fraction >= 1.0, then the next -// vertex will be set to len(p) (indicating that no vertices from the polyline -// need to be appended). The value of the next vertex is always between 1 and -// len(p). -// -// This method can also be used to construct a prefix of the polyline, by -// taking the polyline vertices up to next vertex-1 and appending the -// returned point P if it is different from the last vertex (since in this -// case there is no guarantee of distinctness). -func (p *Polyline) Interpolate(fraction float64) (Point, int) { - // We intentionally let the (fraction >= 1) case fall through, since - // we need to handle it in the loop below in any case because of - // possible roundoff errors. - if fraction <= 0 { - return (*p)[0], 1 - } - target := s1.Angle(fraction) * p.Length() - - for i := 1; i < len(*p); i++ { - length := (*p)[i-1].Distance((*p)[i]) - if target < length { - // This interpolates with respect to arc length rather than - // straight-line distance, and produces a unit-length result. - result := InterpolateAtDistance(target, (*p)[i-1], (*p)[i]) - - // It is possible that (result == vertex(i)) due to rounding errors. - if result == (*p)[i] { - return result, i + 1 - } - return result, i - } - target -= length - } - - return (*p)[len(*p)-1], len(*p) -} - -// Uninterpolate is the inverse operation of Interpolate. Given a point on the -// polyline, it returns the ratio of the distance to the point from the -// beginning of the polyline over the length of the polyline. The return -// value is always betwen 0 and 1 inclusive. -// -// The polyline should not be empty. If it has fewer than 2 vertices, the -// return value is zero. -func (p *Polyline) Uninterpolate(point Point, nextVertex int) float64 { - if len(*p) < 2 { - return 0 - } - - var sum s1.Angle - for i := 1; i < nextVertex; i++ { - sum += (*p)[i-1].Distance((*p)[i]) - } - lengthToPoint := sum + (*p)[nextVertex-1].Distance(point) - for i := nextVertex; i < len(*p); i++ { - sum += (*p)[i-1].Distance((*p)[i]) - } - // The ratio can be greater than 1.0 due to rounding errors or because the - // point is not exactly on the polyline. - return minFloat64(1.0, float64(lengthToPoint/sum)) -} - -// TODO(roberts): Differences from C++. -// NearlyCoversPolyline -// InitToSnapped -// InitToSimplified -// SnapLevel -// encode/decode compressed diff --git a/vendor/github.com/golang/geo/s2/polyline_measures.go b/vendor/github.com/golang/geo/s2/polyline_measures.go deleted file mode 100644 index 38ce991b5..000000000 --- a/vendor/github.com/golang/geo/s2/polyline_measures.go +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// This file defines various measures for polylines on the sphere. These are -// low-level methods that work directly with arrays of Points. They are used to -// implement the methods in various other measures files. - -import ( - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// polylineLength returns the length of the given Polyline. -// It returns 0 for polylines with fewer than two vertices. -func polylineLength(p []Point) s1.Angle { - var length s1.Angle - - for i := 1; i < len(p); i++ { - length += p[i-1].Distance(p[i]) - } - return length -} - -// polylineCentroid returns the true centroid of the polyline multiplied by the -// length of the polyline. The result is not unit length, so you may wish to -// normalize it. -// -// Scaling by the Polyline length makes it easy to compute the centroid -// of several Polylines (by simply adding up their centroids). -// -// Note that for degenerate Polylines (e.g., AA) this returns Point(0, 0, 0). -// (This answer is correct; the result of this function is a line integral over -// the polyline, whose value is always zero if the polyline is degenerate.) -func polylineCentroid(p []Point) Point { - var centroid r3.Vector - for i := 1; i < len(p); i++ { - centroid = centroid.Add(EdgeTrueCentroid(p[i-1], p[i]).Vector) - } - return Point{centroid} -} diff --git a/vendor/github.com/golang/geo/s2/predicates.go b/vendor/github.com/golang/geo/s2/predicates.go deleted file mode 100644 index 9fc5e1751..000000000 --- a/vendor/github.com/golang/geo/s2/predicates.go +++ /dev/null @@ -1,701 +0,0 @@ -// Copyright 2016 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// This file contains various predicates that are guaranteed to produce -// correct, consistent results. They are also relatively efficient. This is -// achieved by computing conservative error bounds and falling back to high -// precision or even exact arithmetic when the result is uncertain. Such -// predicates are useful in implementing robust algorithms. -// -// See also EdgeCrosser, which implements various exact -// edge-crossing predicates more efficiently than can be done here. - -import ( - "math" - "math/big" - - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -const ( - // If any other machine architectures need to be suppported, these next three - // values will need to be updated. - - // epsilon is a small number that represents a reasonable level of noise between two - // values that can be considered to be equal. - epsilon = 1e-15 - // dblEpsilon is a smaller number for values that require more precision. - // This is the C++ DBL_EPSILON equivalent. - dblEpsilon = 2.220446049250313e-16 - // dblError is the C++ value for S2 rounding_epsilon(). - dblError = 1.110223024625156e-16 - - // maxDeterminantError is the maximum error in computing (AxB).C where all vectors - // are unit length. Using standard inequalities, it can be shown that - // - // fl(AxB) = AxB + D where |D| <= (|AxB| + (2/sqrt(3))*|A|*|B|) * e - // - // where "fl()" denotes a calculation done in floating-point arithmetic, - // |x| denotes either absolute value or the L2-norm as appropriate, and - // e is a reasonably small value near the noise level of floating point - // number accuracy. Similarly, - // - // fl(B.C) = B.C + d where |d| <= (|B.C| + 2*|B|*|C|) * e . - // - // Applying these bounds to the unit-length vectors A,B,C and neglecting - // relative error (which does not affect the sign of the result), we get - // - // fl((AxB).C) = (AxB).C + d where |d| <= (3 + 2/sqrt(3)) * e - maxDeterminantError = 1.8274 * dblEpsilon - - // detErrorMultiplier is the factor to scale the magnitudes by when checking - // for the sign of set of points with certainty. Using a similar technique to - // the one used for maxDeterminantError, the error is at most: - // - // |d| <= (3 + 6/sqrt(3)) * |A-C| * |B-C| * e - // - // If the determinant magnitude is larger than this value then we know - // its sign with certainty. - detErrorMultiplier = 3.2321 * dblEpsilon -) - -// Direction is an indication of the ordering of a set of points. -type Direction int - -// These are the three options for the direction of a set of points. -const ( - Clockwise Direction = -1 - Indeterminate Direction = 0 - CounterClockwise Direction = 1 -) - -// newBigFloat constructs a new big.Float with maximum precision. -func newBigFloat() *big.Float { return new(big.Float).SetPrec(big.MaxPrec) } - -// Sign returns true if the points A, B, C are strictly counterclockwise, -// and returns false if the points are clockwise or collinear (i.e. if they are all -// contained on some great circle). -// -// Due to numerical errors, situations may arise that are mathematically -// impossible, e.g. ABC may be considered strictly CCW while BCA is not. -// However, the implementation guarantees the following: -// -// If Sign(a,b,c), then !Sign(c,b,a) for all a,b,c. -func Sign(a, b, c Point) bool { - // NOTE(dnadasi): In the C++ API the equivalent method here was known as "SimpleSign". - - // We compute the signed volume of the parallelepiped ABC. The usual - // formula for this is (A ⨯ B) · C, but we compute it here using (C ⨯ A) · B - // in order to ensure that ABC and CBA are not both CCW. This follows - // from the following identities (which are true numerically, not just - // mathematically): - // - // (1) x ⨯ y == -(y ⨯ x) - // (2) -x · y == -(x · y) - return c.Cross(a.Vector).Dot(b.Vector) > 0 -} - -// RobustSign returns a Direction representing the ordering of the points. -// CounterClockwise is returned if the points are in counter-clockwise order, -// Clockwise for clockwise, and Indeterminate if any two points are the same (collinear), -// or the sign could not completely be determined. -// -// This function has additional logic to make sure that the above properties hold even -// when the three points are coplanar, and to deal with the limitations of -// floating-point arithmetic. -// -// RobustSign satisfies the following conditions: -// -// (1) RobustSign(a,b,c) == Indeterminate if and only if a == b, b == c, or c == a -// (2) RobustSign(b,c,a) == RobustSign(a,b,c) for all a,b,c -// (3) RobustSign(c,b,a) == -RobustSign(a,b,c) for all a,b,c -// -// In other words: -// -// (1) The result is Indeterminate if and only if two points are the same. -// (2) Rotating the order of the arguments does not affect the result. -// (3) Exchanging any two arguments inverts the result. -// -// On the other hand, note that it is not true in general that -// RobustSign(-a,b,c) == -RobustSign(a,b,c), or any similar identities -// involving antipodal points. -func RobustSign(a, b, c Point) Direction { - sign := triageSign(a, b, c) - if sign == Indeterminate { - sign = expensiveSign(a, b, c) - } - return sign -} - -// stableSign reports the direction sign of the points in a numerically stable way. -// Unlike triageSign, this method can usually compute the correct determinant sign -// even when all three points are as collinear as possible. For example if three -// points are spaced 1km apart along a random line on the Earth's surface using -// the nearest representable points, there is only a 0.4% chance that this method -// will not be able to find the determinant sign. The probability of failure -// decreases as the points get closer together; if the collinear points are 1 meter -// apart, the failure rate drops to 0.0004%. -// -// This method could be extended to also handle nearly-antipodal points, but antipodal -// points are rare in practice so it seems better to simply fall back to -// exact arithmetic in that case. -func stableSign(a, b, c Point) Direction { - ab := b.Sub(a.Vector) - ab2 := ab.Norm2() - bc := c.Sub(b.Vector) - bc2 := bc.Norm2() - ca := a.Sub(c.Vector) - ca2 := ca.Norm2() - - // Now compute the determinant ((A-C)x(B-C)).C, where the vertices have been - // cyclically permuted if necessary so that AB is the longest edge. (This - // minimizes the magnitude of cross product.) At the same time we also - // compute the maximum error in the determinant. - - // The two shortest edges, pointing away from their common point. - var e1, e2, op r3.Vector - if ab2 >= bc2 && ab2 >= ca2 { - // AB is the longest edge. - e1, e2, op = ca, bc, c.Vector - } else if bc2 >= ca2 { - // BC is the longest edge. - e1, e2, op = ab, ca, a.Vector - } else { - // CA is the longest edge. - e1, e2, op = bc, ab, b.Vector - } - - det := -e1.Cross(e2).Dot(op) - maxErr := detErrorMultiplier * math.Sqrt(e1.Norm2()*e2.Norm2()) - - // If the determinant isn't zero, within maxErr, we know definitively the point ordering. - if det > maxErr { - return CounterClockwise - } - if det < -maxErr { - return Clockwise - } - return Indeterminate -} - -// triageSign returns the direction sign of the points. It returns Indeterminate if two -// points are identical or the result is uncertain. Uncertain cases can be resolved, if -// desired, by calling expensiveSign. -// -// The purpose of this method is to allow additional cheap tests to be done without -// calling expensiveSign. -func triageSign(a, b, c Point) Direction { - det := a.Cross(b.Vector).Dot(c.Vector) - if det > maxDeterminantError { - return CounterClockwise - } - if det < -maxDeterminantError { - return Clockwise - } - return Indeterminate -} - -// expensiveSign reports the direction sign of the points. It returns Indeterminate -// if two of the input points are the same. It uses multiple-precision arithmetic -// to ensure that its results are always self-consistent. -func expensiveSign(a, b, c Point) Direction { - // Return Indeterminate if and only if two points are the same. - // This ensures RobustSign(a,b,c) == Indeterminate if and only if a == b, b == c, or c == a. - // ie. Property 1 of RobustSign. - if a == b || b == c || c == a { - return Indeterminate - } - - // Next we try recomputing the determinant still using floating-point - // arithmetic but in a more precise way. This is more expensive than the - // simple calculation done by triageSign, but it is still *much* cheaper - // than using arbitrary-precision arithmetic. This optimization is able to - // compute the correct determinant sign in virtually all cases except when - // the three points are truly collinear (e.g., three points on the equator). - detSign := stableSign(a, b, c) - if detSign != Indeterminate { - return detSign - } - - // Otherwise fall back to exact arithmetic and symbolic permutations. - return exactSign(a, b, c, true) -} - -// exactSign reports the direction sign of the points computed using high-precision -// arithmetic and/or symbolic perturbations. -func exactSign(a, b, c Point, perturb bool) Direction { - // Sort the three points in lexicographic order, keeping track of the sign - // of the permutation. (Each exchange inverts the sign of the determinant.) - permSign := CounterClockwise - pa := &a - pb := &b - pc := &c - if pa.Cmp(pb.Vector) > 0 { - pa, pb = pb, pa - permSign = -permSign - } - if pb.Cmp(pc.Vector) > 0 { - pb, pc = pc, pb - permSign = -permSign - } - if pa.Cmp(pb.Vector) > 0 { - pa, pb = pb, pa - permSign = -permSign - } - - // Construct multiple-precision versions of the sorted points and compute - // their precise 3x3 determinant. - xa := r3.PreciseVectorFromVector(pa.Vector) - xb := r3.PreciseVectorFromVector(pb.Vector) - xc := r3.PreciseVectorFromVector(pc.Vector) - xbCrossXc := xb.Cross(xc) - det := xa.Dot(xbCrossXc) - - // The precision of big.Float is high enough that the result should always - // be exact enough (no rounding was performed). - - // If the exact determinant is non-zero, we're done. - detSign := Direction(det.Sign()) - if detSign == Indeterminate && perturb { - // Otherwise, we need to resort to symbolic perturbations to resolve the - // sign of the determinant. - detSign = symbolicallyPerturbedSign(xa, xb, xc, xbCrossXc) - } - return permSign * detSign -} - -// symbolicallyPerturbedSign reports the sign of the determinant of three points -// A, B, C under a model where every possible Point is slightly perturbed by -// a unique infinitesmal amount such that no three perturbed points are -// collinear and no four points are coplanar. The perturbations are so small -// that they do not change the sign of any determinant that was non-zero -// before the perturbations, and therefore can be safely ignored unless the -// determinant of three points is exactly zero (using multiple-precision -// arithmetic). This returns CounterClockwise or Clockwise according to the -// sign of the determinant after the symbolic perturbations are taken into account. -// -// Since the symbolic perturbation of a given point is fixed (i.e., the -// perturbation is the same for all calls to this method and does not depend -// on the other two arguments), the results of this method are always -// self-consistent. It will never return results that would correspond to an -// impossible configuration of non-degenerate points. -// -// This requires that the 3x3 determinant of A, B, C must be exactly zero. -// And the points must be distinct, with A < B < C in lexicographic order. -// -// Reference: -// "Simulation of Simplicity" (Edelsbrunner and Muecke, ACM Transactions on -// Graphics, 1990). -// -func symbolicallyPerturbedSign(a, b, c, bCrossC r3.PreciseVector) Direction { - // This method requires that the points are sorted in lexicographically - // increasing order. This is because every possible Point has its own - // symbolic perturbation such that if A < B then the symbolic perturbation - // for A is much larger than the perturbation for B. - // - // Alternatively, we could sort the points in this method and keep track of - // the sign of the permutation, but it is more efficient to do this before - // converting the inputs to the multi-precision representation, and this - // also lets us re-use the result of the cross product B x C. - // - // Every input coordinate x[i] is assigned a symbolic perturbation dx[i]. - // We then compute the sign of the determinant of the perturbed points, - // i.e. - // | a.X+da.X a.Y+da.Y a.Z+da.Z | - // | b.X+db.X b.Y+db.Y b.Z+db.Z | - // | c.X+dc.X c.Y+dc.Y c.Z+dc.Z | - // - // The perturbations are chosen such that - // - // da.Z > da.Y > da.X > db.Z > db.Y > db.X > dc.Z > dc.Y > dc.X - // - // where each perturbation is so much smaller than the previous one that we - // don't even need to consider it unless the coefficients of all previous - // perturbations are zero. In fact, it is so small that we don't need to - // consider it unless the coefficient of all products of the previous - // perturbations are zero. For example, we don't need to consider the - // coefficient of db.Y unless the coefficient of db.Z *da.X is zero. - // - // The follow code simply enumerates the coefficients of the perturbations - // (and products of perturbations) that appear in the determinant above, in - // order of decreasing perturbation magnitude. The first non-zero - // coefficient determines the sign of the result. The easiest way to - // enumerate the coefficients in the correct order is to pretend that each - // perturbation is some tiny value "eps" raised to a power of two: - // - // eps** 1 2 4 8 16 32 64 128 256 - // da.Z da.Y da.X db.Z db.Y db.X dc.Z dc.Y dc.X - // - // Essentially we can then just count in binary and test the corresponding - // subset of perturbations at each step. So for example, we must test the - // coefficient of db.Z*da.X before db.Y because eps**12 > eps**16. - // - // Of course, not all products of these perturbations appear in the - // determinant above, since the determinant only contains the products of - // elements in distinct rows and columns. Thus we don't need to consider - // da.Z*da.Y, db.Y *da.Y, etc. Furthermore, sometimes different pairs of - // perturbations have the same coefficient in the determinant; for example, - // da.Y*db.X and db.Y*da.X have the same coefficient (c.Z). Therefore - // we only need to test this coefficient the first time we encounter it in - // the binary order above (which will be db.Y*da.X). - // - // The sequence of tests below also appears in Table 4-ii of the paper - // referenced above, if you just want to look it up, with the following - // translations: [a,b,c] -> [i,j,k] and [0,1,2] -> [1,2,3]. Also note that - // some of the signs are different because the opposite cross product is - // used (e.g., B x C rather than C x B). - - detSign := bCrossC.Z.Sign() // da.Z - if detSign != 0 { - return Direction(detSign) - } - detSign = bCrossC.Y.Sign() // da.Y - if detSign != 0 { - return Direction(detSign) - } - detSign = bCrossC.X.Sign() // da.X - if detSign != 0 { - return Direction(detSign) - } - - detSign = newBigFloat().Sub(newBigFloat().Mul(c.X, a.Y), newBigFloat().Mul(c.Y, a.X)).Sign() // db.Z - if detSign != 0 { - return Direction(detSign) - } - detSign = c.X.Sign() // db.Z * da.Y - if detSign != 0 { - return Direction(detSign) - } - detSign = -(c.Y.Sign()) // db.Z * da.X - if detSign != 0 { - return Direction(detSign) - } - - detSign = newBigFloat().Sub(newBigFloat().Mul(c.Z, a.X), newBigFloat().Mul(c.X, a.Z)).Sign() // db.Y - if detSign != 0 { - return Direction(detSign) - } - detSign = c.Z.Sign() // db.Y * da.X - if detSign != 0 { - return Direction(detSign) - } - - // The following test is listed in the paper, but it is redundant because - // the previous tests guarantee that C == (0, 0, 0). - // (c.Y*a.Z - c.Z*a.Y).Sign() // db.X - - detSign = newBigFloat().Sub(newBigFloat().Mul(a.X, b.Y), newBigFloat().Mul(a.Y, b.X)).Sign() // dc.Z - if detSign != 0 { - return Direction(detSign) - } - detSign = -(b.X.Sign()) // dc.Z * da.Y - if detSign != 0 { - return Direction(detSign) - } - detSign = b.Y.Sign() // dc.Z * da.X - if detSign != 0 { - return Direction(detSign) - } - detSign = a.X.Sign() // dc.Z * db.Y - if detSign != 0 { - return Direction(detSign) - } - return CounterClockwise // dc.Z * db.Y * da.X -} - -// CompareDistances returns -1, 0, or +1 according to whether AX < BX, A == B, -// or AX > BX respectively. Distances are measured with respect to the positions -// of X, A, and B as though they were reprojected to lie exactly on the surface of -// the unit sphere. Furthermore, this method uses symbolic perturbations to -// ensure that the result is non-zero whenever A != B, even when AX == BX -// exactly, or even when A and B project to the same point on the sphere. -// Such results are guaranteed to be self-consistent, i.e. if AB < BC and -// BC < AC, then AB < AC. -func CompareDistances(x, a, b Point) int { - // We start by comparing distances using dot products (i.e., cosine of the - // angle), because (1) this is the cheapest technique, and (2) it is valid - // over the entire range of possible angles. (We can only use the sin^2 - // technique if both angles are less than 90 degrees or both angles are - // greater than 90 degrees.) - sign := triageCompareCosDistances(x, a, b) - if sign != 0 { - return sign - } - - // Optimization for (a == b) to avoid falling back to exact arithmetic. - if a == b { - return 0 - } - - // It is much better numerically to compare distances using cos(angle) if - // the distances are near 90 degrees and sin^2(angle) if the distances are - // near 0 or 180 degrees. We only need to check one of the two angles when - // making this decision because the fact that the test above failed means - // that angles "a" and "b" are very close together. - cosAX := a.Dot(x.Vector) - if cosAX > 1/math.Sqrt2 { - // Angles < 45 degrees. - sign = triageCompareSin2Distances(x, a, b) - } else if cosAX < -1/math.Sqrt2 { - // Angles > 135 degrees. sin^2(angle) is decreasing in this range. - sign = -triageCompareSin2Distances(x, a, b) - } - // C++ adds an additional check here using 80-bit floats. - // This is skipped in Go because we only have 32 and 64 bit floats. - - if sign != 0 { - return sign - } - - sign = exactCompareDistances(r3.PreciseVectorFromVector(x.Vector), r3.PreciseVectorFromVector(a.Vector), r3.PreciseVectorFromVector(b.Vector)) - if sign != 0 { - return sign - } - return symbolicCompareDistances(x, a, b) -} - -// cosDistance returns cos(XY) where XY is the angle between X and Y, and the -// maximum error amount in the result. This requires X and Y be normalized. -func cosDistance(x, y Point) (cos, err float64) { - cos = x.Dot(y.Vector) - return cos, 9.5*dblError*math.Abs(cos) + 1.5*dblError -} - -// sin2Distance returns sin**2(XY), where XY is the angle between X and Y, -// and the maximum error amount in the result. This requires X and Y be normalized. -func sin2Distance(x, y Point) (sin2, err float64) { - // The (x-y).Cross(x+y) trick eliminates almost all of error due to x - // and y being not quite unit length. This method is extremely accurate - // for small distances; the *relative* error in the result is O(dblError) for - // distances as small as dblError. - n := x.Sub(y.Vector).Cross(x.Add(y.Vector)) - sin2 = 0.25 * n.Norm2() - err = ((21+4*math.Sqrt(3))*dblError*sin2 + - 32*math.Sqrt(3)*dblError*dblError*math.Sqrt(sin2) + - 768*dblError*dblError*dblError*dblError) - return sin2, err -} - -// triageCompareCosDistances returns -1, 0, or +1 according to whether AX < BX, -// A == B, or AX > BX by comparing the distances between them using cosDistance. -func triageCompareCosDistances(x, a, b Point) int { - cosAX, cosAXerror := cosDistance(a, x) - cosBX, cosBXerror := cosDistance(b, x) - diff := cosAX - cosBX - err := cosAXerror + cosBXerror - if diff > err { - return -1 - } - if diff < -err { - return 1 - } - return 0 -} - -// triageCompareSin2Distances returns -1, 0, or +1 according to whether AX < BX, -// A == B, or AX > BX by comparing the distances between them using sin2Distance. -func triageCompareSin2Distances(x, a, b Point) int { - sin2AX, sin2AXerror := sin2Distance(a, x) - sin2BX, sin2BXerror := sin2Distance(b, x) - diff := sin2AX - sin2BX - err := sin2AXerror + sin2BXerror - if diff > err { - return 1 - } - if diff < -err { - return -1 - } - return 0 -} - -// exactCompareDistances returns -1, 0, or 1 after comparing using the values as -// PreciseVectors. -func exactCompareDistances(x, a, b r3.PreciseVector) int { - // This code produces the same result as though all points were reprojected - // to lie exactly on the surface of the unit sphere. It is based on testing - // whether x.Dot(a.Normalize()) < x.Dot(b.Normalize()), reformulated - // so that it can be evaluated using exact arithmetic. - cosAX := x.Dot(a) - cosBX := x.Dot(b) - - // If the two values have different signs, we need to handle that case now - // before squaring them below. - aSign := cosAX.Sign() - bSign := cosBX.Sign() - if aSign != bSign { - // If cos(AX) > cos(BX), then AX < BX. - if aSign > bSign { - return -1 - } - return 1 - } - cosAX2 := newBigFloat().Mul(cosAX, cosAX) - cosBX2 := newBigFloat().Mul(cosBX, cosBX) - cmp := newBigFloat().Sub(cosBX2.Mul(cosBX2, a.Norm2()), cosAX2.Mul(cosAX2, b.Norm2())) - return aSign * cmp.Sign() -} - -// symbolicCompareDistances returns -1, 0, or +1 given three points such that AX == BX -// (exactly) according to whether AX < BX, AX == BX, or AX > BX after symbolic -// perturbations are taken into account. -func symbolicCompareDistances(x, a, b Point) int { - // Our symbolic perturbation strategy is based on the following model. - // Similar to "simulation of simplicity", we assign a perturbation to every - // point such that if A < B, then the symbolic perturbation for A is much, - // much larger than the symbolic perturbation for B. We imagine that - // rather than projecting every point to lie exactly on the unit sphere, - // instead each point is positioned on its own tiny pedestal that raises it - // just off the surface of the unit sphere. This means that the distance AX - // is actually the true distance AX plus the (symbolic) heights of the - // pedestals for A and X. The pedestals are infinitesmally thin, so they do - // not affect distance measurements except at the two endpoints. If several - // points project to exactly the same point on the unit sphere, we imagine - // that they are placed on separate pedestals placed close together, where - // the distance between pedestals is much, much less than the height of any - // pedestal. (There are a finite number of Points, and therefore a finite - // number of pedestals, so this is possible.) - // - // If A < B, then A is on a higher pedestal than B, and therefore AX > BX. - switch a.Cmp(b.Vector) { - case -1: - return 1 - case 1: - return -1 - default: - return 0 - } -} - -var ( - // ca45Degrees is a predefined ChordAngle representing (approximately) 45 degrees. - ca45Degrees = s1.ChordAngleFromSquaredLength(2 - math.Sqrt2) -) - -// CompareDistance returns -1, 0, or +1 according to whether the distance XY is -// respectively less than, equal to, or greater than the provided chord angle. Distances are measured -// with respect to the positions of all points as though they are projected to lie -// exactly on the surface of the unit sphere. -func CompareDistance(x, y Point, r s1.ChordAngle) int { - // As with CompareDistances, we start by comparing dot products because - // the sin^2 method is only valid when the distance XY and the limit "r" are - // both less than 90 degrees. - sign := triageCompareCosDistance(x, y, float64(r)) - if sign != 0 { - return sign - } - - // Unlike with CompareDistances, it's not worth using the sin^2 method - // when the distance limit is near 180 degrees because the ChordAngle - // representation itself has has a rounding error of up to 2e-8 radians for - // distances near 180 degrees. - if r < ca45Degrees { - sign = triageCompareSin2Distance(x, y, float64(r)) - if sign != 0 { - return sign - } - } - return exactCompareDistance(r3.PreciseVectorFromVector(x.Vector), r3.PreciseVectorFromVector(y.Vector), big.NewFloat(float64(r)).SetPrec(big.MaxPrec)) -} - -// triageCompareCosDistance returns -1, 0, or +1 according to whether the distance XY is -// less than, equal to, or greater than r2 respectively using cos distance. -func triageCompareCosDistance(x, y Point, r2 float64) int { - cosXY, cosXYError := cosDistance(x, y) - cosR := 1.0 - 0.5*r2 - cosRError := 2.0 * dblError * cosR - diff := cosXY - cosR - err := cosXYError + cosRError - if diff > err { - return -1 - } - if diff < -err { - return 1 - } - return 0 -} - -// triageCompareSin2Distance returns -1, 0, or +1 according to whether the distance XY is -// less than, equal to, or greater than r2 respectively using sin^2 distance. -func triageCompareSin2Distance(x, y Point, r2 float64) int { - // Only valid for distance limits < 90 degrees. - sin2XY, sin2XYError := sin2Distance(x, y) - sin2R := r2 * (1.0 - 0.25*r2) - sin2RError := 3.0 * dblError * sin2R - diff := sin2XY - sin2R - err := sin2XYError + sin2RError - if diff > err { - return 1 - } - if diff < -err { - return -1 - } - return 0 -} - -var ( - bigOne = big.NewFloat(1.0).SetPrec(big.MaxPrec) - bigHalf = big.NewFloat(0.5).SetPrec(big.MaxPrec) -) - -// exactCompareDistance returns -1, 0, or +1 after comparing using PreciseVectors. -func exactCompareDistance(x, y r3.PreciseVector, r2 *big.Float) int { - // This code produces the same result as though all points were reprojected - // to lie exactly on the surface of the unit sphere. It is based on - // comparing the cosine of the angle XY (when both points are projected to - // lie exactly on the sphere) to the given threshold. - cosXY := x.Dot(y) - cosR := newBigFloat().Sub(bigOne, newBigFloat().Mul(bigHalf, r2)) - - // If the two values have different signs, we need to handle that case now - // before squaring them below. - xySign := cosXY.Sign() - rSign := cosR.Sign() - if xySign != rSign { - if xySign > rSign { - return -1 - } - return 1 // If cos(XY) > cos(r), then XY < r. - } - cmp := newBigFloat().Sub( - newBigFloat().Mul( - newBigFloat().Mul(cosR, cosR), newBigFloat().Mul(x.Norm2(), y.Norm2())), - newBigFloat().Mul(cosXY, cosXY)) - return xySign * cmp.Sign() -} - -// TODO(roberts): Differences from C++ -// CompareEdgeDistance -// CompareEdgeDirections -// EdgeCircumcenterSign -// GetVoronoiSiteExclusion -// GetClosestVertex -// TriageCompareLineSin2Distance -// TriageCompareLineCos2Distance -// TriageCompareLineDistance -// TriageCompareEdgeDistance -// ExactCompareLineDistance -// ExactCompareEdgeDistance -// TriageCompareEdgeDirections -// ExactCompareEdgeDirections -// ArePointsAntipodal -// ArePointsLinearlyDependent -// GetCircumcenter -// TriageEdgeCircumcenterSign -// ExactEdgeCircumcenterSign -// UnperturbedSign -// SymbolicEdgeCircumcenterSign -// ExactVoronoiSiteExclusion diff --git a/vendor/github.com/golang/geo/s2/projections.go b/vendor/github.com/golang/geo/s2/projections.go deleted file mode 100644 index f7273609c..000000000 --- a/vendor/github.com/golang/geo/s2/projections.go +++ /dev/null @@ -1,241 +0,0 @@ -// Copyright 2018 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/r2" - "github.com/golang/geo/s1" -) - -// Projection defines an interface for different ways of mapping between s2 and r2 Points. -// It can also define the coordinate wrapping behavior along each axis. -type Projection interface { - // Project converts a point on the sphere to a projected 2D point. - Project(p Point) r2.Point - - // Unproject converts a projected 2D point to a point on the sphere. - // - // If wrapping is defined for a given axis (see below), then this method - // should accept any real number for the corresponding coordinate. - Unproject(p r2.Point) Point - - // FromLatLng is a convenience function equivalent to Project(LatLngToPoint(ll)), - // but the implementation is more efficient. - FromLatLng(ll LatLng) r2.Point - - // ToLatLng is a convenience function equivalent to LatLngFromPoint(Unproject(p)), - // but the implementation is more efficient. - ToLatLng(p r2.Point) LatLng - - // Interpolate returns the point obtained by interpolating the given - // fraction of the distance along the line from A to B. - // Fractions < 0 or > 1 result in extrapolation instead. - Interpolate(f float64, a, b r2.Point) r2.Point - - // WrapDistance reports the coordinate wrapping distance along each axis. - // If this value is non-zero for a given axis, the coordinates are assumed - // to "wrap" with the given period. For example, if WrapDistance.Y == 360 - // then (x, y) and (x, y + 360) should map to the same Point. - // - // This information is used to ensure that edges takes the shortest path - // between two given points. For example, if coordinates represent - // (latitude, longitude) pairs in degrees and WrapDistance().Y == 360, - // then the edge (5:179, 5:-179) would be interpreted as spanning 2 degrees - // of longitude rather than 358 degrees. - // - // If a given axis does not wrap, its WrapDistance should be set to zero. - WrapDistance() r2.Point - - // WrapDestination that wraps the coordinates of B if necessary in order to - // obtain the shortest edge AB. For example, suppose that A = [170, 20], - // B = [-170, 20], and the projection wraps so that [x, y] == [x + 360, y]. - // Then this function would return [190, 20] for point B (reducing the edge - // length in the "x" direction from 340 to 20). - WrapDestination(a, b r2.Point) r2.Point - - // We do not support implementations of this interface outside this package. - privateInterface() -} - -// PlateCarreeProjection defines the "plate carree" (square plate) projection, -// which converts points on the sphere to (longitude, latitude) pairs. -// Coordinates can be scaled so that they represent radians, degrees, etc, but -// the projection is always centered around (latitude=0, longitude=0). -// -// Note that (x, y) coordinates are backwards compared to the usual (latitude, -// longitude) ordering, in order to match the usual convention for graphs in -// which "x" is horizontal and "y" is vertical. -type PlateCarreeProjection struct { - xWrap float64 - toRadians float64 // Multiplier to convert coordinates to radians. - fromRadians float64 // Multiplier to convert coordinates from radians. -} - -// NewPlateCarreeProjection constructs a plate carree projection where the -// x-coordinates (lng) span [-xScale, xScale] and the y coordinates (lat) -// span [-xScale/2, xScale/2]. For example if xScale==180 then the x -// range is [-180, 180] and the y range is [-90, 90]. -// -// By default coordinates are expressed in radians, i.e. the x range is -// [-Pi, Pi] and the y range is [-Pi/2, Pi/2]. -func NewPlateCarreeProjection(xScale float64) Projection { - return &PlateCarreeProjection{ - xWrap: 2 * xScale, - toRadians: math.Pi / xScale, - fromRadians: xScale / math.Pi, - } -} - -// Project converts a point on the sphere to a projected 2D point. -func (p *PlateCarreeProjection) Project(pt Point) r2.Point { - return p.FromLatLng(LatLngFromPoint(pt)) -} - -// Unproject converts a projected 2D point to a point on the sphere. -func (p *PlateCarreeProjection) Unproject(pt r2.Point) Point { - return PointFromLatLng(p.ToLatLng(pt)) -} - -// FromLatLng returns the LatLng projected into an R2 Point. -func (p *PlateCarreeProjection) FromLatLng(ll LatLng) r2.Point { - return r2.Point{ - X: p.fromRadians * ll.Lng.Radians(), - Y: p.fromRadians * ll.Lat.Radians(), - } -} - -// ToLatLng returns the LatLng projected from the given R2 Point. -func (p *PlateCarreeProjection) ToLatLng(pt r2.Point) LatLng { - return LatLng{ - Lat: s1.Angle(p.toRadians * pt.Y), - Lng: s1.Angle(p.toRadians * math.Remainder(pt.X, p.xWrap)), - } -} - -// Interpolate returns the point obtained by interpolating the given -// fraction of the distance along the line from A to B. -func (p *PlateCarreeProjection) Interpolate(f float64, a, b r2.Point) r2.Point { - return a.Mul(1 - f).Add(b.Mul(f)) -} - -// WrapDistance reports the coordinate wrapping distance along each axis. -func (p *PlateCarreeProjection) WrapDistance() r2.Point { - return r2.Point{p.xWrap, 0} -} - -// WrapDestination wraps the points if needed to get the shortest edge. -func (p *PlateCarreeProjection) WrapDestination(a, b r2.Point) r2.Point { - return wrapDestination(a, b, p.WrapDistance) -} - -func (p *PlateCarreeProjection) privateInterface() {} - -// MercatorProjection defines the spherical Mercator projection. Google Maps -// uses this projection together with WGS84 coordinates, in which case it is -// known as the "Web Mercator" projection (see Wikipedia). This class makes -// no assumptions regarding the coordinate system of its input points, but -// simply applies the spherical Mercator projection to them. -// -// The Mercator projection is finite in width (x) but infinite in height (y). -// "x" corresponds to longitude, and spans a finite range such as [-180, 180] -// (with coordinate wrapping), while "y" is a function of latitude and spans -// an infinite range. (As "y" coordinates get larger, points get closer to -// the north pole but never quite reach it.) The north and south poles have -// infinite "y" values. (Note that this will cause problems if you tessellate -// a Mercator edge where one endpoint is a pole. If you need to do this, clip -// the edge first so that the "y" coordinate is no more than about 5 * maxX.) -type MercatorProjection struct { - xWrap float64 - toRadians float64 // Multiplier to convert coordinates to radians. - fromRadians float64 // Multiplier to convert coordinates from radians. -} - -// NewMercatorProjection constructs a Mercator projection with the given maximum -// longitude axis value corresponding to a range of [-maxLng, maxLng]. -// The horizontal and vertical axes are scaled equally. -func NewMercatorProjection(maxLng float64) Projection { - return &MercatorProjection{ - xWrap: 2 * maxLng, - toRadians: math.Pi / maxLng, - fromRadians: maxLng / math.Pi, - } -} - -// Project converts a point on the sphere to a projected 2D point. -func (p *MercatorProjection) Project(pt Point) r2.Point { - return p.FromLatLng(LatLngFromPoint(pt)) -} - -// Unproject converts a projected 2D point to a point on the sphere. -func (p *MercatorProjection) Unproject(pt r2.Point) Point { - return PointFromLatLng(p.ToLatLng(pt)) -} - -// FromLatLng returns the LatLng projected into an R2 Point. -func (p *MercatorProjection) FromLatLng(ll LatLng) r2.Point { - // This formula is more accurate near zero than the log(tan()) version. - // Note that latitudes of +/- 90 degrees yield "y" values of +/- infinity. - sinPhi := math.Sin(float64(ll.Lat)) - y := 0.5 * math.Log((1+sinPhi)/(1-sinPhi)) - return r2.Point{p.fromRadians * float64(ll.Lng), p.fromRadians * y} -} - -// ToLatLng returns the LatLng projected from the given R2 Point. -func (p *MercatorProjection) ToLatLng(pt r2.Point) LatLng { - // This formula is more accurate near zero than the atan(exp()) version. - x := p.toRadians * math.Remainder(pt.X, p.xWrap) - k := math.Exp(2 * p.toRadians * pt.Y) - var y float64 - if math.IsInf(k, 0) { - y = math.Pi / 2 - } else { - y = math.Asin((k - 1) / (k + 1)) - } - return LatLng{s1.Angle(y), s1.Angle(x)} -} - -// Interpolate returns the point obtained by interpolating the given -// fraction of the distance along the line from A to B. -func (p *MercatorProjection) Interpolate(f float64, a, b r2.Point) r2.Point { - return a.Mul(1 - f).Add(b.Mul(f)) -} - -// WrapDistance reports the coordinate wrapping distance along each axis. -func (p *MercatorProjection) WrapDistance() r2.Point { - return r2.Point{p.xWrap, 0} -} - -// WrapDestination wraps the points if needed to get the shortest edge. -func (p *MercatorProjection) WrapDestination(a, b r2.Point) r2.Point { - return wrapDestination(a, b, p.WrapDistance) -} - -func (p *MercatorProjection) privateInterface() {} - -func wrapDestination(a, b r2.Point, wrapDistance func() r2.Point) r2.Point { - wrap := wrapDistance() - x := b.X - y := b.Y - // The code below ensures that "b" is unmodified unless wrapping is required. - if wrap.X > 0 && math.Abs(x-a.X) > 0.5*wrap.X { - x = a.X + math.Remainder(x-a.X, wrap.X) - } - if wrap.Y > 0 && math.Abs(y-a.Y) > 0.5*wrap.Y { - y = a.Y + math.Remainder(y-a.Y, wrap.Y) - } - return r2.Point{x, y} -} diff --git a/vendor/github.com/golang/geo/s2/query_entry.go b/vendor/github.com/golang/geo/s2/query_entry.go deleted file mode 100644 index 65e819e3a..000000000 --- a/vendor/github.com/golang/geo/s2/query_entry.go +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright 2020 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import "container/heap" - -// A queryQueueEntry stores CellIDs and distance from a target. It is used by the -// different S2 Query types to efficiently build their internal priority queue -// in the optimized algorithm implementations. -type queryQueueEntry struct { - // A lower bound on the distance from the target to ID. This is the key - // of the priority queue. - distance distance - - // The cell being queued. - id CellID - - // If the CellID belongs to a ShapeIndex, this field stores the - // corresponding ShapeIndexCell. Otherwise ID is a proper ancestor of - // one or more ShapeIndexCells and this field stores is nil. - indexCell *ShapeIndexCell -} - -// queryQueue is used by the optimized algorithm to maintain a priority queue of -// unprocessed CellIDs, sorted in increasing order of distance from the target. -type queryQueue struct { - queue queryPQ -} - -// newQueryQueue returns a new initialized queryQueue. -func newQueryQueue() *queryQueue { - q := &queryQueue{ - queue: make(queryPQ, 0), - } - heap.Init(&q.queue) - return q -} - -// push adds the given entry to the top of this queue. -func (q *queryQueue) push(e *queryQueueEntry) { - heap.Push(&q.queue, e) -} - -// pop returns the top element of this queue. -func (q *queryQueue) pop() *queryQueueEntry { - return heap.Pop(&q.queue).(*queryQueueEntry) -} - -func (q *queryQueue) size() int { - return q.queue.Len() -} - -func (q *queryQueue) reset() { - q.queue = q.queue[:0] -} - -// queryPQ is a priority queue that implements the heap interface. -type queryPQ []*queryQueueEntry - -func (q queryPQ) Len() int { return len(q) } -func (q queryPQ) Less(i, j int) bool { - return q[i].distance.less(q[j].distance) -} - -// Swap swaps the two entries. -func (q queryPQ) Swap(i, j int) { - q[i], q[j] = q[j], q[i] -} - -// Push adds the given entry to the queue. -func (q *queryPQ) Push(x interface{}) { - item := x.(*queryQueueEntry) - *q = append(*q, item) -} - -// Pop returns the top element of the queue. -func (q *queryPQ) Pop() interface{} { - item := (*q)[len(*q)-1] - *q = (*q)[:len(*q)-1] - return item -} diff --git a/vendor/github.com/golang/geo/s2/query_options.go b/vendor/github.com/golang/geo/s2/query_options.go deleted file mode 100644 index 9b7e38d62..000000000 --- a/vendor/github.com/golang/geo/s2/query_options.go +++ /dev/null @@ -1,196 +0,0 @@ -// Copyright 2019 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/s1" -) - -const maxQueryResults = math.MaxInt32 - -// queryOptions represents the set of all configurable parameters used by all of -// the Query types. Most of these fields have non-zero defaults, so initialization -// is handled within each Query type. All of the exported methods accept user -// supplied sets of options to set or adjust as necessary. -// -// Several of the defaults depend on the distance interface type being used -// (e.g. minDistance, maxDistance, etc.) -// -// If a user sets an option value that a given query type doesn't use, it is ignored. -type queryOptions struct { - // maxResults specifies that at most MaxResults edges should be returned. - // This must be at least 1. - // - // The default value is to return all results. - maxResults int - - // distanceLimit specifies that only edges whose distance to the target is - // within this distance should be returned. - // - // Note that edges whose distance is exactly equal to this are - // not returned. In most cases this doesn't matter (since distances are - // not computed exactly in the first place), but if such edges are needed - // then you can retrieve them by specifying the distance as the next - // largest representable distance. i.e. distanceLimit.Successor(). - // - // The default value is the infinity value, such that all results will be - // returned. - distanceLimit s1.ChordAngle - - // maxError specifies that edges up to MaxError further away than the true - // closest edges may be substituted in the result set, as long as such - // edges satisfy all the remaining search criteria (such as DistanceLimit). - // This option only has an effect if MaxResults is also specified; - // otherwise all edges closer than MaxDistance will always be returned. - // - // Note that this does not affect how the distance between edges is - // computed; it simply gives the algorithm permission to stop the search - // early as soon as the best possible improvement drops below MaxError. - // - // This can be used to implement distance predicates efficiently. For - // example, to determine whether the minimum distance is less than D, set - // MaxResults == 1 and MaxDistance == MaxError == D. This causes - // the algorithm to terminate as soon as it finds any edge whose distance - // is less than D, rather than continuing to search for an edge that is - // even closer. - // - // The default value is zero. - maxError s1.ChordAngle - - // includeInteriors specifies that polygon interiors should be included - // when measuring distances. In other words, polygons that contain the target - // should have a distance of zero. (For targets consisting of multiple connected - // components, the distance is zero if any component is contained.) This - // is indicated in the results by returning a (ShapeID, EdgeID) pair - // with EdgeID == -1, i.e. this value denotes the polygons's interior. - // - // Note that for efficiency, any polygon that intersects the target may or - // may not have an EdgeID == -1 result. Such results are optional - // because in that case the distance to the polygon is already zero. - // - // The default value is true. - includeInteriors bool - - // specifies that distances should be computed by examining every edge - // rather than using the ShapeIndex. - // - // TODO(roberts): When optimized is implemented, update the default to false. - // The default value is true. - useBruteForce bool - - // region specifies that results must intersect the given Region. - // - // Note that if you want to set the region to a disc around a target - // point, it is faster to use a PointTarget with distanceLimit set - // instead. You can also set a distance limit and also require that results - // lie within a given rectangle. - // - // The default is nil (no region limits). - region Region -} - -// UseBruteForce sets or disables the use of brute force in a query. -func (q *queryOptions) UseBruteForce(x bool) *queryOptions { - q.useBruteForce = x - return q -} - -// IncludeInteriors specifies whether polygon interiors should be -// included when measuring distances. -func (q *queryOptions) IncludeInteriors(x bool) *queryOptions { - q.includeInteriors = x - return q -} - -// MaxError specifies that edges up to dist away than the true -// matching edges may be substituted in the result set, as long as such -// edges satisfy all the remaining search criteria (such as DistanceLimit). -// This option only has an effect if MaxResults is also specified; -// otherwise all edges closer than MaxDistance will always be returned. -func (q *queryOptions) MaxError(x s1.ChordAngle) *queryOptions { - q.maxError = x - return q -} - -// MaxResults specifies that at most MaxResults edges should be returned. -// This must be at least 1. -func (q *queryOptions) MaxResults(x int) *queryOptions { - // TODO(roberts): What should be done if the value is <= 0? - q.maxResults = int(x) - return q -} - -// DistanceLimit specifies that only edges whose distance to the target is -// within, this distance should be returned. Edges whose distance is equal -// are not returned. -// -// To include values that are equal, specify the limit with the next largest -// representable distance such as limit.Successor(), or set the option with -// Furthest/ClosestInclusiveDistanceLimit. -func (q *queryOptions) DistanceLimit(x s1.ChordAngle) *queryOptions { - q.distanceLimit = x - return q -} - -// ClosestInclusiveDistanceLimit sets the distance limit such that results whose -// distance is exactly equal to the limit are also returned. -func (q *queryOptions) ClosestInclusiveDistanceLimit(limit s1.ChordAngle) *queryOptions { - q.distanceLimit = limit.Successor() - return q -} - -// FurthestInclusiveDistanceLimit sets the distance limit such that results whose -// distance is exactly equal to the limit are also returned. -func (q *queryOptions) FurthestInclusiveDistanceLimit(limit s1.ChordAngle) *queryOptions { - q.distanceLimit = limit.Predecessor() - return q -} - -// ClosestConservativeDistanceLimit sets the distance limit such that results -// also incorporates the error in distance calculations. This ensures that all -// edges whose true distance is less than or equal to limit will be returned -// (along with some edges whose true distance is slightly greater). -// -// Algorithms that need to do exact distance comparisons can use this -// option to find a set of candidate edges that can then be filtered -// further (e.g., using CompareDistance). -func (q *queryOptions) ClosestConservativeDistanceLimit(limit s1.ChordAngle) *queryOptions { - q.distanceLimit = limit.Expanded(minUpdateDistanceMaxError(limit)) - return q -} - -// FurthestConservativeDistanceLimit sets the distance limit such that results -// also incorporates the error in distance calculations. This ensures that all -// edges whose true distance is greater than or equal to limit will be returned -// (along with some edges whose true distance is slightly less). -func (q *queryOptions) FurthestConservativeDistanceLimit(limit s1.ChordAngle) *queryOptions { - q.distanceLimit = limit.Expanded(-minUpdateDistanceMaxError(limit)) - return q -} - -// newQueryOptions returns a set of options using the given distance type -// with the proper default values. -func newQueryOptions(d distance) *queryOptions { - return &queryOptions{ - maxResults: maxQueryResults, - distanceLimit: d.infinity().chordAngle(), - maxError: 0, - includeInteriors: true, - useBruteForce: false, - region: nil, - } -} diff --git a/vendor/github.com/golang/geo/s2/rect.go b/vendor/github.com/golang/geo/s2/rect.go deleted file mode 100644 index f6b52a59e..000000000 --- a/vendor/github.com/golang/geo/s2/rect.go +++ /dev/null @@ -1,710 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "fmt" - "io" - "math" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// Rect represents a closed latitude-longitude rectangle. -type Rect struct { - Lat r1.Interval - Lng s1.Interval -} - -var ( - validRectLatRange = r1.Interval{-math.Pi / 2, math.Pi / 2} - validRectLngRange = s1.FullInterval() -) - -// EmptyRect returns the empty rectangle. -func EmptyRect() Rect { return Rect{r1.EmptyInterval(), s1.EmptyInterval()} } - -// FullRect returns the full rectangle. -func FullRect() Rect { return Rect{validRectLatRange, validRectLngRange} } - -// RectFromLatLng constructs a rectangle containing a single point p. -func RectFromLatLng(p LatLng) Rect { - return Rect{ - Lat: r1.Interval{p.Lat.Radians(), p.Lat.Radians()}, - Lng: s1.Interval{p.Lng.Radians(), p.Lng.Radians()}, - } -} - -// RectFromCenterSize constructs a rectangle with the given size and center. -// center needs to be normalized, but size does not. The latitude -// interval of the result is clamped to [-90,90] degrees, and the longitude -// interval of the result is FullRect() if and only if the longitude size is -// 360 degrees or more. -// -// Examples of clamping (in degrees): -// center=(80,170), size=(40,60) -> lat=[60,90], lng=[140,-160] -// center=(10,40), size=(210,400) -> lat=[-90,90], lng=[-180,180] -// center=(-90,180), size=(20,50) -> lat=[-90,-80], lng=[155,-155] -func RectFromCenterSize(center, size LatLng) Rect { - half := LatLng{size.Lat / 2, size.Lng / 2} - return RectFromLatLng(center).expanded(half) -} - -// IsValid returns true iff the rectangle is valid. -// This requires Lat ⊆ [-π/2,π/2] and Lng ⊆ [-π,π], and Lat = ∅ iff Lng = ∅ -func (r Rect) IsValid() bool { - return math.Abs(r.Lat.Lo) <= math.Pi/2 && - math.Abs(r.Lat.Hi) <= math.Pi/2 && - r.Lng.IsValid() && - r.Lat.IsEmpty() == r.Lng.IsEmpty() -} - -// IsEmpty reports whether the rectangle is empty. -func (r Rect) IsEmpty() bool { return r.Lat.IsEmpty() } - -// IsFull reports whether the rectangle is full. -func (r Rect) IsFull() bool { return r.Lat.Equal(validRectLatRange) && r.Lng.IsFull() } - -// IsPoint reports whether the rectangle is a single point. -func (r Rect) IsPoint() bool { return r.Lat.Lo == r.Lat.Hi && r.Lng.Lo == r.Lng.Hi } - -// Vertex returns the i-th vertex of the rectangle (i = 0,1,2,3) in CCW order -// (lower left, lower right, upper right, upper left). -func (r Rect) Vertex(i int) LatLng { - var lat, lng float64 - - switch i { - case 0: - lat = r.Lat.Lo - lng = r.Lng.Lo - case 1: - lat = r.Lat.Lo - lng = r.Lng.Hi - case 2: - lat = r.Lat.Hi - lng = r.Lng.Hi - case 3: - lat = r.Lat.Hi - lng = r.Lng.Lo - } - return LatLng{s1.Angle(lat) * s1.Radian, s1.Angle(lng) * s1.Radian} -} - -// Lo returns one corner of the rectangle. -func (r Rect) Lo() LatLng { - return LatLng{s1.Angle(r.Lat.Lo) * s1.Radian, s1.Angle(r.Lng.Lo) * s1.Radian} -} - -// Hi returns the other corner of the rectangle. -func (r Rect) Hi() LatLng { - return LatLng{s1.Angle(r.Lat.Hi) * s1.Radian, s1.Angle(r.Lng.Hi) * s1.Radian} -} - -// Center returns the center of the rectangle. -func (r Rect) Center() LatLng { - return LatLng{s1.Angle(r.Lat.Center()) * s1.Radian, s1.Angle(r.Lng.Center()) * s1.Radian} -} - -// Size returns the size of the Rect. -func (r Rect) Size() LatLng { - return LatLng{s1.Angle(r.Lat.Length()) * s1.Radian, s1.Angle(r.Lng.Length()) * s1.Radian} -} - -// Area returns the surface area of the Rect. -func (r Rect) Area() float64 { - if r.IsEmpty() { - return 0 - } - capDiff := math.Abs(math.Sin(r.Lat.Hi) - math.Sin(r.Lat.Lo)) - return r.Lng.Length() * capDiff -} - -// AddPoint increases the size of the rectangle to include the given point. -func (r Rect) AddPoint(ll LatLng) Rect { - if !ll.IsValid() { - return r - } - return Rect{ - Lat: r.Lat.AddPoint(ll.Lat.Radians()), - Lng: r.Lng.AddPoint(ll.Lng.Radians()), - } -} - -// expanded returns a rectangle that has been expanded by margin.Lat on each side -// in the latitude direction, and by margin.Lng on each side in the longitude -// direction. If either margin is negative, then it shrinks the rectangle on -// the corresponding sides instead. The resulting rectangle may be empty. -// -// The latitude-longitude space has the topology of a cylinder. Longitudes -// "wrap around" at +/-180 degrees, while latitudes are clamped to range [-90, 90]. -// This means that any expansion (positive or negative) of the full longitude range -// remains full (since the "rectangle" is actually a continuous band around the -// cylinder), while expansion of the full latitude range remains full only if the -// margin is positive. -// -// If either the latitude or longitude interval becomes empty after -// expansion by a negative margin, the result is empty. -// -// Note that if an expanded rectangle contains a pole, it may not contain -// all possible lat/lng representations of that pole, e.g., both points [π/2,0] -// and [π/2,1] represent the same pole, but they might not be contained by the -// same Rect. -// -// If you are trying to grow a rectangle by a certain distance on the -// sphere (e.g. 5km), refer to the ExpandedByDistance() C++ method implementation -// instead. -func (r Rect) expanded(margin LatLng) Rect { - lat := r.Lat.Expanded(margin.Lat.Radians()) - lng := r.Lng.Expanded(margin.Lng.Radians()) - - if lat.IsEmpty() || lng.IsEmpty() { - return EmptyRect() - } - - return Rect{ - Lat: lat.Intersection(validRectLatRange), - Lng: lng, - } -} - -func (r Rect) String() string { return fmt.Sprintf("[Lo%v, Hi%v]", r.Lo(), r.Hi()) } - -// PolarClosure returns the rectangle unmodified if it does not include either pole. -// If it includes either pole, PolarClosure returns an expansion of the rectangle along -// the longitudinal range to include all possible representations of the contained poles. -func (r Rect) PolarClosure() Rect { - if r.Lat.Lo == -math.Pi/2 || r.Lat.Hi == math.Pi/2 { - return Rect{r.Lat, s1.FullInterval()} - } - return r -} - -// Union returns the smallest Rect containing the union of this rectangle and the given rectangle. -func (r Rect) Union(other Rect) Rect { - return Rect{ - Lat: r.Lat.Union(other.Lat), - Lng: r.Lng.Union(other.Lng), - } -} - -// Intersection returns the smallest rectangle containing the intersection of -// this rectangle and the given rectangle. Note that the region of intersection -// may consist of two disjoint rectangles, in which case a single rectangle -// spanning both of them is returned. -func (r Rect) Intersection(other Rect) Rect { - lat := r.Lat.Intersection(other.Lat) - lng := r.Lng.Intersection(other.Lng) - - if lat.IsEmpty() || lng.IsEmpty() { - return EmptyRect() - } - return Rect{lat, lng} -} - -// Intersects reports whether this rectangle and the other have any points in common. -func (r Rect) Intersects(other Rect) bool { - return r.Lat.Intersects(other.Lat) && r.Lng.Intersects(other.Lng) -} - -// CapBound returns a cap that contains Rect. -func (r Rect) CapBound() Cap { - // We consider two possible bounding caps, one whose axis passes - // through the center of the lat-long rectangle and one whose axis - // is the north or south pole. We return the smaller of the two caps. - - if r.IsEmpty() { - return EmptyCap() - } - - var poleZ, poleAngle float64 - if r.Lat.Hi+r.Lat.Lo < 0 { - // South pole axis yields smaller cap. - poleZ = -1 - poleAngle = math.Pi/2 + r.Lat.Hi - } else { - poleZ = 1 - poleAngle = math.Pi/2 - r.Lat.Lo - } - poleCap := CapFromCenterAngle(Point{r3.Vector{0, 0, poleZ}}, s1.Angle(poleAngle)*s1.Radian) - - // For bounding rectangles that span 180 degrees or less in longitude, the - // maximum cap size is achieved at one of the rectangle vertices. For - // rectangles that are larger than 180 degrees, we punt and always return a - // bounding cap centered at one of the two poles. - if math.Remainder(r.Lng.Hi-r.Lng.Lo, 2*math.Pi) >= 0 && r.Lng.Hi-r.Lng.Lo < 2*math.Pi { - midCap := CapFromPoint(PointFromLatLng(r.Center())).AddPoint(PointFromLatLng(r.Lo())).AddPoint(PointFromLatLng(r.Hi())) - if midCap.Height() < poleCap.Height() { - return midCap - } - } - return poleCap -} - -// RectBound returns itself. -func (r Rect) RectBound() Rect { - return r -} - -// Contains reports whether this Rect contains the other Rect. -func (r Rect) Contains(other Rect) bool { - return r.Lat.ContainsInterval(other.Lat) && r.Lng.ContainsInterval(other.Lng) -} - -// ContainsCell reports whether the given Cell is contained by this Rect. -func (r Rect) ContainsCell(c Cell) bool { - // A latitude-longitude rectangle contains a cell if and only if it contains - // the cell's bounding rectangle. This test is exact from a mathematical - // point of view, assuming that the bounds returned by Cell.RectBound() - // are tight. However, note that there can be a loss of precision when - // converting between representations -- for example, if an s2.Cell is - // converted to a polygon, the polygon's bounding rectangle may not contain - // the cell's bounding rectangle. This has some slightly unexpected side - // effects; for instance, if one creates an s2.Polygon from an s2.Cell, the - // polygon will contain the cell, but the polygon's bounding box will not. - return r.Contains(c.RectBound()) -} - -// ContainsLatLng reports whether the given LatLng is within the Rect. -func (r Rect) ContainsLatLng(ll LatLng) bool { - if !ll.IsValid() { - return false - } - return r.Lat.Contains(ll.Lat.Radians()) && r.Lng.Contains(ll.Lng.Radians()) -} - -// ContainsPoint reports whether the given Point is within the Rect. -func (r Rect) ContainsPoint(p Point) bool { - return r.ContainsLatLng(LatLngFromPoint(p)) -} - -// CellUnionBound computes a covering of the Rect. -func (r Rect) CellUnionBound() []CellID { - return r.CapBound().CellUnionBound() -} - -// intersectsLatEdge reports whether the edge AB intersects the given edge of constant -// latitude. Requires the points to have unit length. -func intersectsLatEdge(a, b Point, lat s1.Angle, lng s1.Interval) bool { - // Unfortunately, lines of constant latitude are curves on - // the sphere. They can intersect a straight edge in 0, 1, or 2 points. - - // First, compute the normal to the plane AB that points vaguely north. - z := Point{a.PointCross(b).Normalize()} - if z.Z < 0 { - z = Point{z.Mul(-1)} - } - - // Extend this to an orthonormal frame (x,y,z) where x is the direction - // where the great circle through AB achieves its maximium latitude. - y := Point{z.PointCross(PointFromCoords(0, 0, 1)).Normalize()} - x := y.Cross(z.Vector) - - // Compute the angle "theta" from the x-axis (in the x-y plane defined - // above) where the great circle intersects the given line of latitude. - sinLat := math.Sin(float64(lat)) - if math.Abs(sinLat) >= x.Z { - // The great circle does not reach the given latitude. - return false - } - - cosTheta := sinLat / x.Z - sinTheta := math.Sqrt(1 - cosTheta*cosTheta) - theta := math.Atan2(sinTheta, cosTheta) - - // The candidate intersection points are located +/- theta in the x-y - // plane. For an intersection to be valid, we need to check that the - // intersection point is contained in the interior of the edge AB and - // also that it is contained within the given longitude interval "lng". - - // Compute the range of theta values spanned by the edge AB. - abTheta := s1.IntervalFromPointPair( - math.Atan2(a.Dot(y.Vector), a.Dot(x)), - math.Atan2(b.Dot(y.Vector), b.Dot(x))) - - if abTheta.Contains(theta) { - // Check if the intersection point is also in the given lng interval. - isect := x.Mul(cosTheta).Add(y.Mul(sinTheta)) - if lng.Contains(math.Atan2(isect.Y, isect.X)) { - return true - } - } - - if abTheta.Contains(-theta) { - // Check if the other intersection point is also in the given lng interval. - isect := x.Mul(cosTheta).Sub(y.Mul(sinTheta)) - if lng.Contains(math.Atan2(isect.Y, isect.X)) { - return true - } - } - return false -} - -// intersectsLngEdge reports whether the edge AB intersects the given edge of constant -// longitude. Requires the points to have unit length. -func intersectsLngEdge(a, b Point, lat r1.Interval, lng s1.Angle) bool { - // The nice thing about edges of constant longitude is that - // they are straight lines on the sphere (geodesics). - return CrossingSign(a, b, PointFromLatLng(LatLng{s1.Angle(lat.Lo), lng}), - PointFromLatLng(LatLng{s1.Angle(lat.Hi), lng})) == Cross -} - -// IntersectsCell reports whether this rectangle intersects the given cell. This is an -// exact test and may be fairly expensive. -func (r Rect) IntersectsCell(c Cell) bool { - // First we eliminate the cases where one region completely contains the - // other. Once these are disposed of, then the regions will intersect - // if and only if their boundaries intersect. - if r.IsEmpty() { - return false - } - if r.ContainsPoint(Point{c.id.rawPoint()}) { - return true - } - if c.ContainsPoint(PointFromLatLng(r.Center())) { - return true - } - - // Quick rejection test (not required for correctness). - if !r.Intersects(c.RectBound()) { - return false - } - - // Precompute the cell vertices as points and latitude-longitudes. We also - // check whether the Cell contains any corner of the rectangle, or - // vice-versa, since the edge-crossing tests only check the edge interiors. - vertices := [4]Point{} - latlngs := [4]LatLng{} - - for i := range vertices { - vertices[i] = c.Vertex(i) - latlngs[i] = LatLngFromPoint(vertices[i]) - if r.ContainsLatLng(latlngs[i]) { - return true - } - if c.ContainsPoint(PointFromLatLng(r.Vertex(i))) { - return true - } - } - - // Now check whether the boundaries intersect. Unfortunately, a - // latitude-longitude rectangle does not have straight edges: two edges - // are curved, and at least one of them is concave. - for i := range vertices { - edgeLng := s1.IntervalFromEndpoints(latlngs[i].Lng.Radians(), latlngs[(i+1)&3].Lng.Radians()) - if !r.Lng.Intersects(edgeLng) { - continue - } - - a := vertices[i] - b := vertices[(i+1)&3] - if edgeLng.Contains(r.Lng.Lo) && intersectsLngEdge(a, b, r.Lat, s1.Angle(r.Lng.Lo)) { - return true - } - if edgeLng.Contains(r.Lng.Hi) && intersectsLngEdge(a, b, r.Lat, s1.Angle(r.Lng.Hi)) { - return true - } - if intersectsLatEdge(a, b, s1.Angle(r.Lat.Lo), r.Lng) { - return true - } - if intersectsLatEdge(a, b, s1.Angle(r.Lat.Hi), r.Lng) { - return true - } - } - return false -} - -// Encode encodes the Rect. -func (r Rect) Encode(w io.Writer) error { - e := &encoder{w: w} - r.encode(e) - return e.err -} - -func (r Rect) encode(e *encoder) { - e.writeInt8(encodingVersion) - e.writeFloat64(r.Lat.Lo) - e.writeFloat64(r.Lat.Hi) - e.writeFloat64(r.Lng.Lo) - e.writeFloat64(r.Lng.Hi) -} - -// Decode decodes a rectangle. -func (r *Rect) Decode(rd io.Reader) error { - d := &decoder{r: asByteReader(rd)} - r.decode(d) - return d.err -} - -func (r *Rect) decode(d *decoder) { - if version := d.readUint8(); int8(version) != encodingVersion && d.err == nil { - d.err = fmt.Errorf("can't decode version %d; my version: %d", version, encodingVersion) - return - } - r.Lat.Lo = d.readFloat64() - r.Lat.Hi = d.readFloat64() - r.Lng.Lo = d.readFloat64() - r.Lng.Hi = d.readFloat64() - return -} - -// DistanceToLatLng returns the minimum distance (measured along the surface of the sphere) -// from a given point to the rectangle (both its boundary and its interior). -// If r is empty, the result is meaningless. -// The latlng must be valid. -func (r Rect) DistanceToLatLng(ll LatLng) s1.Angle { - if r.Lng.Contains(float64(ll.Lng)) { - return maxAngle(0, ll.Lat-s1.Angle(r.Lat.Hi), s1.Angle(r.Lat.Lo)-ll.Lat) - } - - i := s1.IntervalFromEndpoints(r.Lng.Hi, r.Lng.ComplementCenter()) - rectLng := r.Lng.Lo - if i.Contains(float64(ll.Lng)) { - rectLng = r.Lng.Hi - } - - lo := LatLng{s1.Angle(r.Lat.Lo) * s1.Radian, s1.Angle(rectLng) * s1.Radian} - hi := LatLng{s1.Angle(r.Lat.Hi) * s1.Radian, s1.Angle(rectLng) * s1.Radian} - return DistanceFromSegment(PointFromLatLng(ll), PointFromLatLng(lo), PointFromLatLng(hi)) -} - -// DirectedHausdorffDistance returns the directed Hausdorff distance (measured along the -// surface of the sphere) to the given Rect. The directed Hausdorff -// distance from rectangle A to rectangle B is given by -// h(A, B) = max_{p in A} min_{q in B} d(p, q). -func (r Rect) DirectedHausdorffDistance(other Rect) s1.Angle { - if r.IsEmpty() { - return 0 * s1.Radian - } - if other.IsEmpty() { - return math.Pi * s1.Radian - } - - lng := r.Lng.DirectedHausdorffDistance(other.Lng) - return directedHausdorffDistance(lng, r.Lat, other.Lat) -} - -// HausdorffDistance returns the undirected Hausdorff distance (measured along the -// surface of the sphere) to the given Rect. -// The Hausdorff distance between rectangle A and rectangle B is given by -// H(A, B) = max{h(A, B), h(B, A)}. -func (r Rect) HausdorffDistance(other Rect) s1.Angle { - return maxAngle(r.DirectedHausdorffDistance(other), - other.DirectedHausdorffDistance(r)) -} - -// ApproxEqual reports whether the latitude and longitude intervals of the two rectangles -// are the same up to a small tolerance. -func (r Rect) ApproxEqual(other Rect) bool { - return r.Lat.ApproxEqual(other.Lat) && r.Lng.ApproxEqual(other.Lng) -} - -// directedHausdorffDistance returns the directed Hausdorff distance -// from one longitudinal edge spanning latitude range 'a' to the other -// longitudinal edge spanning latitude range 'b', with their longitudinal -// difference given by 'lngDiff'. -func directedHausdorffDistance(lngDiff s1.Angle, a, b r1.Interval) s1.Angle { - // By symmetry, we can assume a's longitude is 0 and b's longitude is - // lngDiff. Call b's two endpoints bLo and bHi. Let H be the hemisphere - // containing a and delimited by the longitude line of b. The Voronoi diagram - // of b on H has three edges (portions of great circles) all orthogonal to b - // and meeting at bLo cross bHi. - // E1: (bLo, bLo cross bHi) - // E2: (bHi, bLo cross bHi) - // E3: (-bMid, bLo cross bHi), where bMid is the midpoint of b - // - // They subdivide H into three Voronoi regions. Depending on how longitude 0 - // (which contains edge a) intersects these regions, we distinguish two cases: - // Case 1: it intersects three regions. This occurs when lngDiff <= π/2. - // Case 2: it intersects only two regions. This occurs when lngDiff > π/2. - // - // In the first case, the directed Hausdorff distance to edge b can only be - // realized by the following points on a: - // A1: two endpoints of a. - // A2: intersection of a with the equator, if b also intersects the equator. - // - // In the second case, the directed Hausdorff distance to edge b can only be - // realized by the following points on a: - // B1: two endpoints of a. - // B2: intersection of a with E3 - // B3: farthest point from bLo to the interior of D, and farthest point from - // bHi to the interior of U, if any, where D (resp. U) is the portion - // of edge a below (resp. above) the intersection point from B2. - - if lngDiff < 0 { - panic("impossible: negative lngDiff") - } - if lngDiff > math.Pi { - panic("impossible: lngDiff > Pi") - } - - if lngDiff == 0 { - return s1.Angle(a.DirectedHausdorffDistance(b)) - } - - // Assumed longitude of b. - bLng := lngDiff - // Two endpoints of b. - bLo := PointFromLatLng(LatLng{s1.Angle(b.Lo), bLng}) - bHi := PointFromLatLng(LatLng{s1.Angle(b.Hi), bLng}) - - // Cases A1 and B1. - aLo := PointFromLatLng(LatLng{s1.Angle(a.Lo), 0}) - aHi := PointFromLatLng(LatLng{s1.Angle(a.Hi), 0}) - maxDistance := maxAngle( - DistanceFromSegment(aLo, bLo, bHi), - DistanceFromSegment(aHi, bLo, bHi)) - - if lngDiff <= math.Pi/2 { - // Case A2. - if a.Contains(0) && b.Contains(0) { - maxDistance = maxAngle(maxDistance, lngDiff) - } - return maxDistance - } - - // Case B2. - p := bisectorIntersection(b, bLng) - pLat := LatLngFromPoint(p).Lat - if a.Contains(float64(pLat)) { - maxDistance = maxAngle(maxDistance, p.Angle(bLo.Vector)) - } - - // Case B3. - if pLat > s1.Angle(a.Lo) { - intDist, ok := interiorMaxDistance(r1.Interval{a.Lo, math.Min(float64(pLat), a.Hi)}, bLo) - if ok { - maxDistance = maxAngle(maxDistance, intDist) - } - } - if pLat < s1.Angle(a.Hi) { - intDist, ok := interiorMaxDistance(r1.Interval{math.Max(float64(pLat), a.Lo), a.Hi}, bHi) - if ok { - maxDistance = maxAngle(maxDistance, intDist) - } - } - - return maxDistance -} - -// interiorMaxDistance returns the max distance from a point b to the segment spanning latitude range -// aLat on longitude 0 if the max occurs in the interior of aLat. Otherwise, returns (0, false). -func interiorMaxDistance(aLat r1.Interval, b Point) (a s1.Angle, ok bool) { - // Longitude 0 is in the y=0 plane. b.X >= 0 implies that the maximum - // does not occur in the interior of aLat. - if aLat.IsEmpty() || b.X >= 0 { - return 0, false - } - - // Project b to the y=0 plane. The antipodal of the normalized projection is - // the point at which the maxium distance from b occurs, if it is contained - // in aLat. - intersectionPoint := PointFromCoords(-b.X, 0, -b.Z) - if !aLat.InteriorContains(float64(LatLngFromPoint(intersectionPoint).Lat)) { - return 0, false - } - return b.Angle(intersectionPoint.Vector), true -} - -// bisectorIntersection return the intersection of longitude 0 with the bisector of an edge -// on longitude 'lng' and spanning latitude range 'lat'. -func bisectorIntersection(lat r1.Interval, lng s1.Angle) Point { - lng = s1.Angle(math.Abs(float64(lng))) - latCenter := s1.Angle(lat.Center()) - - // A vector orthogonal to the bisector of the given longitudinal edge. - orthoBisector := LatLng{latCenter - math.Pi/2, lng} - if latCenter < 0 { - orthoBisector = LatLng{-latCenter - math.Pi/2, lng - math.Pi} - } - - // A vector orthogonal to longitude 0. - orthoLng := Point{r3.Vector{0, -1, 0}} - - return orthoLng.PointCross(PointFromLatLng(orthoBisector)) -} - -// Centroid returns the true centroid of the given Rect multiplied by its -// surface area. The result is not unit length, so you may want to normalize it. -// Note that in general the centroid is *not* at the center of the rectangle, and -// in fact it may not even be contained by the rectangle. (It is the "center of -// mass" of the rectangle viewed as subset of the unit sphere, i.e. it is the -// point in space about which this curved shape would rotate.) -// -// The reason for multiplying the result by the rectangle area is to make it -// easier to compute the centroid of more complicated shapes. The centroid -// of a union of disjoint regions can be computed simply by adding their -// Centroid results. -func (r Rect) Centroid() Point { - // When a sphere is divided into slices of constant thickness by a set - // of parallel planes, all slices have the same surface area. This - // implies that the z-component of the centroid is simply the midpoint - // of the z-interval spanned by the Rect. - // - // Similarly, it is easy to see that the (x,y) of the centroid lies in - // the plane through the midpoint of the rectangle's longitude interval. - // We only need to determine the distance "d" of this point from the - // z-axis. - // - // Let's restrict our attention to a particular z-value. In this - // z-plane, the Rect is a circular arc. The centroid of this arc - // lies on a radial line through the midpoint of the arc, and at a - // distance from the z-axis of - // - // r * (sin(alpha) / alpha) - // - // where r = sqrt(1-z^2) is the radius of the arc, and "alpha" is half - // of the arc length (i.e., the arc covers longitudes [-alpha, alpha]). - // - // To find the centroid distance from the z-axis for the entire - // rectangle, we just need to integrate over the z-interval. This gives - // - // d = Integrate[sqrt(1-z^2)*sin(alpha)/alpha, z1..z2] / (z2 - z1) - // - // where [z1, z2] is the range of z-values covered by the rectangle. - // This simplifies to - // - // d = sin(alpha)/(2*alpha*(z2-z1))*(z2*r2 - z1*r1 + theta2 - theta1) - // - // where [theta1, theta2] is the latitude interval, z1=sin(theta1), - // z2=sin(theta2), r1=cos(theta1), and r2=cos(theta2). - // - // Finally, we want to return not the centroid itself, but the centroid - // scaled by the area of the rectangle. The area of the rectangle is - // - // A = 2 * alpha * (z2 - z1) - // - // which fortunately appears in the denominator of "d". - - if r.IsEmpty() { - return Point{} - } - - z1 := math.Sin(r.Lat.Lo) - z2 := math.Sin(r.Lat.Hi) - r1 := math.Cos(r.Lat.Lo) - r2 := math.Cos(r.Lat.Hi) - - alpha := 0.5 * r.Lng.Length() - r0 := math.Sin(alpha) * (r2*z2 - r1*z1 + r.Lat.Length()) - lng := r.Lng.Center() - z := alpha * (z2 + z1) * (z2 - z1) // scaled by the area - - return Point{r3.Vector{r0 * math.Cos(lng), r0 * math.Sin(lng), z}} -} - -// BUG: The major differences from the C++ version are: -// - Get*Distance, Vertex, InteriorContains(LatLng|Rect|Point) diff --git a/vendor/github.com/golang/geo/s2/rect_bounder.go b/vendor/github.com/golang/geo/s2/rect_bounder.go deleted file mode 100644 index 419dea0c1..000000000 --- a/vendor/github.com/golang/geo/s2/rect_bounder.go +++ /dev/null @@ -1,352 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r3" - "github.com/golang/geo/s1" -) - -// RectBounder is used to compute a bounding rectangle that contains all edges -// defined by a vertex chain (v0, v1, v2, ...). All vertices must be unit length. -// Note that the bounding rectangle of an edge can be larger than the bounding -// rectangle of its endpoints, e.g. consider an edge that passes through the North Pole. -// -// The bounds are calculated conservatively to account for numerical errors -// when points are converted to LatLngs. More precisely, this function -// guarantees the following: -// Let L be a closed edge chain (Loop) such that the interior of the loop does -// not contain either pole. Now if P is any point such that L.ContainsPoint(P), -// then RectBound(L).ContainsPoint(LatLngFromPoint(P)). -type RectBounder struct { - // The previous vertex in the chain. - a Point - // The previous vertex latitude longitude. - aLL LatLng - bound Rect -} - -// NewRectBounder returns a new instance of a RectBounder. -func NewRectBounder() *RectBounder { - return &RectBounder{ - bound: EmptyRect(), - } -} - -// maxErrorForTests returns the maximum error in RectBound provided that the -// result does not include either pole. It is only used for testing purposes -func (r *RectBounder) maxErrorForTests() LatLng { - // The maximum error in the latitude calculation is - // 3.84 * dblEpsilon for the PointCross calculation - // 0.96 * dblEpsilon for the Latitude calculation - // 5 * dblEpsilon added by AddPoint/RectBound to compensate for error - // ----------------- - // 9.80 * dblEpsilon maximum error in result - // - // The maximum error in the longitude calculation is dblEpsilon. RectBound - // does not do any expansion because this isn't necessary in order to - // bound the *rounded* longitudes of contained points. - return LatLng{10 * dblEpsilon * s1.Radian, 1 * dblEpsilon * s1.Radian} -} - -// AddPoint adds the given point to the chain. The Point must be unit length. -func (r *RectBounder) AddPoint(b Point) { - bLL := LatLngFromPoint(b) - - if r.bound.IsEmpty() { - r.a = b - r.aLL = bLL - r.bound = r.bound.AddPoint(bLL) - return - } - - // First compute the cross product N = A x B robustly. This is the normal - // to the great circle through A and B. We don't use RobustSign - // since that method returns an arbitrary vector orthogonal to A if the two - // vectors are proportional, and we want the zero vector in that case. - n := r.a.Sub(b.Vector).Cross(r.a.Add(b.Vector)) // N = 2 * (A x B) - - // The relative error in N gets large as its norm gets very small (i.e., - // when the two points are nearly identical or antipodal). We handle this - // by choosing a maximum allowable error, and if the error is greater than - // this we fall back to a different technique. Since it turns out that - // the other sources of error in converting the normal to a maximum - // latitude add up to at most 1.16 * dblEpsilon, and it is desirable to - // have the total error be a multiple of dblEpsilon, we have chosen to - // limit the maximum error in the normal to be 3.84 * dblEpsilon. - // It is possible to show that the error is less than this when - // - // n.Norm() >= 8 * sqrt(3) / (3.84 - 0.5 - sqrt(3)) * dblEpsilon - // = 1.91346e-15 (about 8.618 * dblEpsilon) - nNorm := n.Norm() - if nNorm < 1.91346e-15 { - // A and B are either nearly identical or nearly antipodal (to within - // 4.309 * dblEpsilon, or about 6 nanometers on the earth's surface). - if r.a.Dot(b.Vector) < 0 { - // The two points are nearly antipodal. The easiest solution is to - // assume that the edge between A and B could go in any direction - // around the sphere. - r.bound = FullRect() - } else { - // The two points are nearly identical (to within 4.309 * dblEpsilon). - // In this case we can just use the bounding rectangle of the points, - // since after the expansion done by GetBound this Rect is - // guaranteed to include the (lat,lng) values of all points along AB. - r.bound = r.bound.Union(RectFromLatLng(r.aLL).AddPoint(bLL)) - } - r.a = b - r.aLL = bLL - return - } - - // Compute the longitude range spanned by AB. - lngAB := s1.EmptyInterval().AddPoint(r.aLL.Lng.Radians()).AddPoint(bLL.Lng.Radians()) - if lngAB.Length() >= math.Pi-2*dblEpsilon { - // The points lie on nearly opposite lines of longitude to within the - // maximum error of the calculation. The easiest solution is to assume - // that AB could go on either side of the pole. - lngAB = s1.FullInterval() - } - - // Next we compute the latitude range spanned by the edge AB. We start - // with the range spanning the two endpoints of the edge: - latAB := r1.IntervalFromPoint(r.aLL.Lat.Radians()).AddPoint(bLL.Lat.Radians()) - - // This is the desired range unless the edge AB crosses the plane - // through N and the Z-axis (which is where the great circle through A - // and B attains its minimum and maximum latitudes). To test whether AB - // crosses this plane, we compute a vector M perpendicular to this - // plane and then project A and B onto it. - m := n.Cross(r3.Vector{0, 0, 1}) - mA := m.Dot(r.a.Vector) - mB := m.Dot(b.Vector) - - // We want to test the signs of "mA" and "mB", so we need to bound - // the error in these calculations. It is possible to show that the - // total error is bounded by - // - // (1 + sqrt(3)) * dblEpsilon * nNorm + 8 * sqrt(3) * (dblEpsilon**2) - // = 6.06638e-16 * nNorm + 6.83174e-31 - - mError := 6.06638e-16*nNorm + 6.83174e-31 - if mA*mB < 0 || math.Abs(mA) <= mError || math.Abs(mB) <= mError { - // Minimum/maximum latitude *may* occur in the edge interior. - // - // The maximum latitude is 90 degrees minus the latitude of N. We - // compute this directly using atan2 in order to get maximum accuracy - // near the poles. - // - // Our goal is compute a bound that contains the computed latitudes of - // all S2Points P that pass the point-in-polygon containment test. - // There are three sources of error we need to consider: - // - the directional error in N (at most 3.84 * dblEpsilon) - // - converting N to a maximum latitude - // - computing the latitude of the test point P - // The latter two sources of error are at most 0.955 * dblEpsilon - // individually, but it is possible to show by a more complex analysis - // that together they can add up to at most 1.16 * dblEpsilon, for a - // total error of 5 * dblEpsilon. - // - // We add 3 * dblEpsilon to the bound here, and GetBound() will pad - // the bound by another 2 * dblEpsilon. - maxLat := math.Min( - math.Atan2(math.Sqrt(n.X*n.X+n.Y*n.Y), math.Abs(n.Z))+3*dblEpsilon, - math.Pi/2) - - // In order to get tight bounds when the two points are close together, - // we also bound the min/max latitude relative to the latitudes of the - // endpoints A and B. First we compute the distance between A and B, - // and then we compute the maximum change in latitude between any two - // points along the great circle that are separated by this distance. - // This gives us a latitude change "budget". Some of this budget must - // be spent getting from A to B; the remainder bounds the round-trip - // distance (in latitude) from A or B to the min or max latitude - // attained along the edge AB. - latBudget := 2 * math.Asin(0.5*(r.a.Sub(b.Vector)).Norm()*math.Sin(maxLat)) - maxDelta := 0.5*(latBudget-latAB.Length()) + dblEpsilon - - // Test whether AB passes through the point of maximum latitude or - // minimum latitude. If the dot product(s) are small enough then the - // result may be ambiguous. - if mA <= mError && mB >= -mError { - latAB.Hi = math.Min(maxLat, latAB.Hi+maxDelta) - } - if mB <= mError && mA >= -mError { - latAB.Lo = math.Max(-maxLat, latAB.Lo-maxDelta) - } - } - r.a = b - r.aLL = bLL - r.bound = r.bound.Union(Rect{latAB, lngAB}) -} - -// RectBound returns the bounding rectangle of the edge chain that connects the -// vertices defined so far. This bound satisfies the guarantee made -// above, i.e. if the edge chain defines a Loop, then the bound contains -// the LatLng coordinates of all Points contained by the loop. -func (r *RectBounder) RectBound() Rect { - return r.bound.expanded(LatLng{s1.Angle(2 * dblEpsilon), 0}).PolarClosure() -} - -// ExpandForSubregions expands a bounding Rect so that it is guaranteed to -// contain the bounds of any subregion whose bounds are computed using -// ComputeRectBound. For example, consider a loop L that defines a square. -// GetBound ensures that if a point P is contained by this square, then -// LatLngFromPoint(P) is contained by the bound. But now consider a diamond -// shaped loop S contained by L. It is possible that GetBound returns a -// *larger* bound for S than it does for L, due to rounding errors. This -// method expands the bound for L so that it is guaranteed to contain the -// bounds of any subregion S. -// -// More precisely, if L is a loop that does not contain either pole, and S -// is a loop such that L.Contains(S), then -// -// ExpandForSubregions(L.RectBound).Contains(S.RectBound). -// -func ExpandForSubregions(bound Rect) Rect { - // Empty bounds don't need expansion. - if bound.IsEmpty() { - return bound - } - - // First we need to check whether the bound B contains any nearly-antipodal - // points (to within 4.309 * dblEpsilon). If so then we need to return - // FullRect, since the subregion might have an edge between two - // such points, and AddPoint returns Full for such edges. Note that - // this can happen even if B is not Full for example, consider a loop - // that defines a 10km strip straddling the equator extending from - // longitudes -100 to +100 degrees. - // - // It is easy to check whether B contains any antipodal points, but checking - // for nearly-antipodal points is trickier. Essentially we consider the - // original bound B and its reflection through the origin B', and then test - // whether the minimum distance between B and B' is less than 4.309 * dblEpsilon. - - // lngGap is a lower bound on the longitudinal distance between B and its - // reflection B'. (2.5 * dblEpsilon is the maximum combined error of the - // endpoint longitude calculations and the Length call.) - lngGap := math.Max(0, math.Pi-bound.Lng.Length()-2.5*dblEpsilon) - - // minAbsLat is the minimum distance from B to the equator (if zero or - // negative, then B straddles the equator). - minAbsLat := math.Max(bound.Lat.Lo, -bound.Lat.Hi) - - // latGapSouth and latGapNorth measure the minimum distance from B to the - // south and north poles respectively. - latGapSouth := math.Pi/2 + bound.Lat.Lo - latGapNorth := math.Pi/2 - bound.Lat.Hi - - if minAbsLat >= 0 { - // The bound B does not straddle the equator. In this case the minimum - // distance is between one endpoint of the latitude edge in B closest to - // the equator and the other endpoint of that edge in B'. The latitude - // distance between these two points is 2*minAbsLat, and the longitude - // distance is lngGap. We could compute the distance exactly using the - // Haversine formula, but then we would need to bound the errors in that - // calculation. Since we only need accuracy when the distance is very - // small (close to 4.309 * dblEpsilon), we substitute the Euclidean - // distance instead. This gives us a right triangle XYZ with two edges of - // length x = 2*minAbsLat and y ~= lngGap. The desired distance is the - // length of the third edge z, and we have - // - // z ~= sqrt(x^2 + y^2) >= (x + y) / sqrt(2) - // - // Therefore the region may contain nearly antipodal points only if - // - // 2*minAbsLat + lngGap < sqrt(2) * 4.309 * dblEpsilon - // ~= 1.354e-15 - // - // Note that because the given bound B is conservative, minAbsLat and - // lngGap are both lower bounds on their true values so we do not need - // to make any adjustments for their errors. - if 2*minAbsLat+lngGap < 1.354e-15 { - return FullRect() - } - } else if lngGap >= math.Pi/2 { - // B spans at most Pi/2 in longitude. The minimum distance is always - // between one corner of B and the diagonally opposite corner of B'. We - // use the same distance approximation that we used above; in this case - // we have an obtuse triangle XYZ with two edges of length x = latGapSouth - // and y = latGapNorth, and angle Z >= Pi/2 between them. We then have - // - // z >= sqrt(x^2 + y^2) >= (x + y) / sqrt(2) - // - // Unlike the case above, latGapSouth and latGapNorth are not lower bounds - // (because of the extra addition operation, and because math.Pi/2 is not - // exactly equal to Pi/2); they can exceed their true values by up to - // 0.75 * dblEpsilon. Putting this all together, the region may contain - // nearly antipodal points only if - // - // latGapSouth + latGapNorth < (sqrt(2) * 4.309 + 1.5) * dblEpsilon - // ~= 1.687e-15 - if latGapSouth+latGapNorth < 1.687e-15 { - return FullRect() - } - } else { - // Otherwise we know that (1) the bound straddles the equator and (2) its - // width in longitude is at least Pi/2. In this case the minimum - // distance can occur either between a corner of B and the diagonally - // opposite corner of B' (as in the case above), or between a corner of B - // and the opposite longitudinal edge reflected in B'. It is sufficient - // to only consider the corner-edge case, since this distance is also a - // lower bound on the corner-corner distance when that case applies. - - // Consider the spherical triangle XYZ where X is a corner of B with - // minimum absolute latitude, Y is the closest pole to X, and Z is the - // point closest to X on the opposite longitudinal edge of B'. This is a - // right triangle (Z = Pi/2), and from the spherical law of sines we have - // - // sin(z) / sin(Z) = sin(y) / sin(Y) - // sin(maxLatGap) / 1 = sin(dMin) / sin(lngGap) - // sin(dMin) = sin(maxLatGap) * sin(lngGap) - // - // where "maxLatGap" = max(latGapSouth, latGapNorth) and "dMin" is the - // desired minimum distance. Now using the facts that sin(t) >= (2/Pi)*t - // for 0 <= t <= Pi/2, that we only need an accurate approximation when - // at least one of "maxLatGap" or lngGap is extremely small (in which - // case sin(t) ~= t), and recalling that "maxLatGap" has an error of up - // to 0.75 * dblEpsilon, we want to test whether - // - // maxLatGap * lngGap < (4.309 + 0.75) * (Pi/2) * dblEpsilon - // ~= 1.765e-15 - if math.Max(latGapSouth, latGapNorth)*lngGap < 1.765e-15 { - return FullRect() - } - } - // Next we need to check whether the subregion might contain any edges that - // span (math.Pi - 2 * dblEpsilon) radians or more in longitude, since AddPoint - // sets the longitude bound to Full in that case. This corresponds to - // testing whether (lngGap <= 0) in lngExpansion below. - - // Otherwise, the maximum latitude error in AddPoint is 4.8 * dblEpsilon. - // In the worst case, the errors when computing the latitude bound for a - // subregion could go in the opposite direction as the errors when computing - // the bound for the original region, so we need to double this value. - // (More analysis shows that it's okay to round down to a multiple of - // dblEpsilon.) - // - // For longitude, we rely on the fact that atan2 is correctly rounded and - // therefore no additional bounds expansion is necessary. - - latExpansion := 9 * dblEpsilon - lngExpansion := 0.0 - if lngGap <= 0 { - lngExpansion = math.Pi - } - return bound.expanded(LatLng{s1.Angle(latExpansion), s1.Angle(lngExpansion)}).PolarClosure() -} diff --git a/vendor/github.com/golang/geo/s2/region.go b/vendor/github.com/golang/geo/s2/region.go deleted file mode 100644 index 9ea3de1ca..000000000 --- a/vendor/github.com/golang/geo/s2/region.go +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// A Region represents a two-dimensional region on the unit sphere. -// -// The purpose of this interface is to allow complex regions to be -// approximated as simpler regions. The interface is restricted to methods -// that are useful for computing approximations. -type Region interface { - // CapBound returns a bounding spherical cap. This is not guaranteed to be exact. - CapBound() Cap - - // RectBound returns a bounding latitude-longitude rectangle that contains - // the region. The bounds are not guaranteed to be tight. - RectBound() Rect - - // ContainsCell reports whether the region completely contains the given region. - // It returns false if containment could not be determined. - ContainsCell(c Cell) bool - - // IntersectsCell reports whether the region intersects the given cell or - // if intersection could not be determined. It returns false if the region - // does not intersect. - IntersectsCell(c Cell) bool - - // ContainsPoint reports whether the region contains the given point or not. - // The point should be unit length, although some implementations may relax - // this restriction. - ContainsPoint(p Point) bool - - // CellUnionBound returns a small collection of CellIDs whose union covers - // the region. The cells are not sorted, may have redundancies (such as cells - // that contain other cells), and may cover much more area than necessary. - // - // This method is not intended for direct use by client code. Clients - // should typically use Covering, which has options to control the size and - // accuracy of the covering. Alternatively, if you want a fast covering and - // don't care about accuracy, consider calling FastCovering (which returns a - // cleaned-up version of the covering computed by this method). - // - // CellUnionBound implementations should attempt to return a small - // covering (ideally 4 cells or fewer) that covers the region and can be - // computed quickly. The result is used by RegionCoverer as a starting - // point for further refinement. - CellUnionBound() []CellID -} - -// Enforce Region interface satisfaction. -var ( - _ Region = Cap{} - _ Region = Cell{} - _ Region = (*CellUnion)(nil) - _ Region = (*Loop)(nil) - _ Region = Point{} - _ Region = (*Polygon)(nil) - _ Region = (*Polyline)(nil) - _ Region = Rect{} -) diff --git a/vendor/github.com/golang/geo/s2/regioncoverer.go b/vendor/github.com/golang/geo/s2/regioncoverer.go deleted file mode 100644 index de5b0c20d..000000000 --- a/vendor/github.com/golang/geo/s2/regioncoverer.go +++ /dev/null @@ -1,615 +0,0 @@ -// Copyright 2015 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "container/heap" - "sort" -) - -// RegionCoverer allows arbitrary regions to be approximated as unions of cells (CellUnion). -// This is useful for implementing various sorts of search and precomputation operations. -// -// Typical usage: -// -// rc := &s2.RegionCoverer{MaxLevel: 30, MaxCells: 5} -// r := s2.Region(CapFromCenterArea(center, area)) -// covering := rc.Covering(r) -// -// This yields a CellUnion of at most 5 cells that is guaranteed to cover the -// given region (a disc-shaped region on the sphere). -// -// For covering, only cells where (level - MinLevel) is a multiple of LevelMod will be used. -// This effectively allows the branching factor of the S2 CellID hierarchy to be increased. -// Currently the only parameter values allowed are 1, 2, or 3, corresponding to -// branching factors of 4, 16, and 64 respectively. -// -// Note the following: -// -// - MinLevel takes priority over MaxCells, i.e. cells below the given level will -// never be used even if this causes a large number of cells to be returned. -// -// - For any setting of MaxCells, up to 6 cells may be returned if that -// is the minimum number of cells required (e.g. if the region intersects -// all six face cells). Up to 3 cells may be returned even for very tiny -// convex regions if they happen to be located at the intersection of -// three cube faces. -// -// - For any setting of MaxCells, an arbitrary number of cells may be -// returned if MinLevel is too high for the region being approximated. -// -// - If MaxCells is less than 4, the area of the covering may be -// arbitrarily large compared to the area of the original region even if -// the region is convex (e.g. a Cap or Rect). -// -// The approximation algorithm is not optimal but does a pretty good job in -// practice. The output does not always use the maximum number of cells -// allowed, both because this would not always yield a better approximation, -// and because MaxCells is a limit on how much work is done exploring the -// possible covering as well as a limit on the final output size. -// -// Because it is an approximation algorithm, one should not rely on the -// stability of the output. In particular, the output of the covering algorithm -// may change across different versions of the library. -// -// One can also generate interior coverings, which are sets of cells which -// are entirely contained within a region. Interior coverings can be -// empty, even for non-empty regions, if there are no cells that satisfy -// the provided constraints and are contained by the region. Note that for -// performance reasons, it is wise to specify a MaxLevel when computing -// interior coverings - otherwise for regions with small or zero area, the -// algorithm may spend a lot of time subdividing cells all the way to leaf -// level to try to find contained cells. -type RegionCoverer struct { - MinLevel int // the minimum cell level to be used. - MaxLevel int // the maximum cell level to be used. - LevelMod int // the LevelMod to be used. - MaxCells int // the maximum desired number of cells in the approximation. -} - -// NewRegionCoverer returns a region coverer with the appropriate defaults. -func NewRegionCoverer() *RegionCoverer { - return &RegionCoverer{ - MinLevel: 0, - MaxLevel: maxLevel, - LevelMod: 1, - MaxCells: 8, - } -} - -type coverer struct { - minLevel int // the minimum cell level to be used. - maxLevel int // the maximum cell level to be used. - levelMod int // the LevelMod to be used. - maxCells int // the maximum desired number of cells in the approximation. - region Region - result CellUnion - pq priorityQueue - interiorCovering bool -} - -type candidate struct { - cell Cell - terminal bool // Cell should not be expanded further. - numChildren int // Number of children that intersect the region. - children []*candidate // Actual size may be 0, 4, 16, or 64 elements. - priority int // Priority of the candidate. -} - -type priorityQueue []*candidate - -func (pq priorityQueue) Len() int { - return len(pq) -} - -func (pq priorityQueue) Less(i, j int) bool { - // We want Pop to give us the highest, not lowest, priority so we use greater than here. - return pq[i].priority > pq[j].priority -} - -func (pq priorityQueue) Swap(i, j int) { - pq[i], pq[j] = pq[j], pq[i] -} - -func (pq *priorityQueue) Push(x interface{}) { - item := x.(*candidate) - *pq = append(*pq, item) -} - -func (pq *priorityQueue) Pop() interface{} { - item := (*pq)[len(*pq)-1] - *pq = (*pq)[:len(*pq)-1] - return item -} - -func (pq *priorityQueue) Reset() { - *pq = (*pq)[:0] -} - -// newCandidate returns a new candidate with no children if the cell intersects the given region. -// The candidate is marked as terminal if it should not be expanded further. -func (c *coverer) newCandidate(cell Cell) *candidate { - if !c.region.IntersectsCell(cell) { - return nil - } - cand := &candidate{cell: cell} - level := int(cell.level) - if level >= c.minLevel { - if c.interiorCovering { - if c.region.ContainsCell(cell) { - cand.terminal = true - } else if level+c.levelMod > c.maxLevel { - return nil - } - } else if level+c.levelMod > c.maxLevel || c.region.ContainsCell(cell) { - cand.terminal = true - } - } - return cand -} - -// expandChildren populates the children of the candidate by expanding the given number of -// levels from the given cell. Returns the number of children that were marked "terminal". -func (c *coverer) expandChildren(cand *candidate, cell Cell, numLevels int) int { - numLevels-- - var numTerminals int - last := cell.id.ChildEnd() - for ci := cell.id.ChildBegin(); ci != last; ci = ci.Next() { - childCell := CellFromCellID(ci) - if numLevels > 0 { - if c.region.IntersectsCell(childCell) { - numTerminals += c.expandChildren(cand, childCell, numLevels) - } - continue - } - if child := c.newCandidate(childCell); child != nil { - cand.children = append(cand.children, child) - cand.numChildren++ - if child.terminal { - numTerminals++ - } - } - } - return numTerminals -} - -// addCandidate adds the given candidate to the result if it is marked as "terminal", -// otherwise expands its children and inserts it into the priority queue. -// Passing an argument of nil does nothing. -func (c *coverer) addCandidate(cand *candidate) { - if cand == nil { - return - } - - if cand.terminal { - c.result = append(c.result, cand.cell.id) - return - } - - // Expand one level at a time until we hit minLevel to ensure that we don't skip over it. - numLevels := c.levelMod - level := int(cand.cell.level) - if level < c.minLevel { - numLevels = 1 - } - - numTerminals := c.expandChildren(cand, cand.cell, numLevels) - maxChildrenShift := uint(2 * c.levelMod) - if cand.numChildren == 0 { - return - } else if !c.interiorCovering && numTerminals == 1<<maxChildrenShift && level >= c.minLevel { - // Optimization: add the parent cell rather than all of its children. - // We can't do this for interior coverings, since the children just - // intersect the region, but may not be contained by it - we need to - // subdivide them further. - cand.terminal = true - c.addCandidate(cand) - } else { - // We negate the priority so that smaller absolute priorities are returned - // first. The heuristic is designed to refine the largest cells first, - // since those are where we have the largest potential gain. Among cells - // of the same size, we prefer the cells with the fewest children. - // Finally, among cells with equal numbers of children we prefer those - // with the smallest number of children that cannot be refined further. - cand.priority = -(((level<<maxChildrenShift)+cand.numChildren)<<maxChildrenShift + numTerminals) - heap.Push(&c.pq, cand) - } -} - -// adjustLevel returns the reduced "level" so that it satisfies levelMod. Levels smaller than minLevel -// are not affected (since cells at these levels are eventually expanded). -func (c *coverer) adjustLevel(level int) int { - if c.levelMod > 1 && level > c.minLevel { - level -= (level - c.minLevel) % c.levelMod - } - return level -} - -// adjustCellLevels ensures that all cells with level > minLevel also satisfy levelMod, -// by replacing them with an ancestor if necessary. Cell levels smaller -// than minLevel are not modified (see AdjustLevel). The output is -// then normalized to ensure that no redundant cells are present. -func (c *coverer) adjustCellLevels(cells *CellUnion) { - if c.levelMod == 1 { - return - } - - var out int - for _, ci := range *cells { - level := ci.Level() - newLevel := c.adjustLevel(level) - if newLevel != level { - ci = ci.Parent(newLevel) - } - if out > 0 && (*cells)[out-1].Contains(ci) { - continue - } - for out > 0 && ci.Contains((*cells)[out-1]) { - out-- - } - (*cells)[out] = ci - out++ - } - *cells = (*cells)[:out] -} - -// initialCandidates computes a set of initial candidates that cover the given region. -func (c *coverer) initialCandidates() { - // Optimization: start with a small (usually 4 cell) covering of the region's bounding cap. - temp := &RegionCoverer{MaxLevel: c.maxLevel, LevelMod: 1, MaxCells: minInt(4, c.maxCells)} - - cells := temp.FastCovering(c.region) - c.adjustCellLevels(&cells) - for _, ci := range cells { - c.addCandidate(c.newCandidate(CellFromCellID(ci))) - } -} - -// coveringInternal generates a covering and stores it in result. -// Strategy: Start with the 6 faces of the cube. Discard any -// that do not intersect the shape. Then repeatedly choose the -// largest cell that intersects the shape and subdivide it. -// -// result contains the cells that will be part of the output, while pq -// contains cells that we may still subdivide further. Cells that are -// entirely contained within the region are immediately added to the output, -// while cells that do not intersect the region are immediately discarded. -// Therefore pq only contains cells that partially intersect the region. -// Candidates are prioritized first according to cell size (larger cells -// first), then by the number of intersecting children they have (fewest -// children first), and then by the number of fully contained children -// (fewest children first). -func (c *coverer) coveringInternal(region Region) { - c.region = region - - c.initialCandidates() - for c.pq.Len() > 0 && (!c.interiorCovering || len(c.result) < c.maxCells) { - cand := heap.Pop(&c.pq).(*candidate) - - // For interior covering we keep subdividing no matter how many children - // candidate has. If we reach MaxCells before expanding all children, - // we will just use some of them. - // For exterior covering we cannot do this, because result has to cover the - // whole region, so all children have to be used. - // candidate.numChildren == 1 case takes care of the situation when we - // already have more than MaxCells in result (minLevel is too high). - // Subdividing of the candidate with one child does no harm in this case. - if c.interiorCovering || int(cand.cell.level) < c.minLevel || cand.numChildren == 1 || len(c.result)+c.pq.Len()+cand.numChildren <= c.maxCells { - for _, child := range cand.children { - if !c.interiorCovering || len(c.result) < c.maxCells { - c.addCandidate(child) - } - } - } else { - cand.terminal = true - c.addCandidate(cand) - } - } - - c.pq.Reset() - c.region = nil - - // Rather than just returning the raw list of cell ids, we construct a cell - // union and then denormalize it. This has the effect of replacing four - // child cells with their parent whenever this does not violate the covering - // parameters specified (min_level, level_mod, etc). This significantly - // reduces the number of cells returned in many cases, and it is cheap - // compared to computing the covering in the first place. - c.result.Normalize() - if c.minLevel > 0 || c.levelMod > 1 { - c.result.Denormalize(c.minLevel, c.levelMod) - } -} - -// newCoverer returns an instance of coverer. -func (rc *RegionCoverer) newCoverer() *coverer { - return &coverer{ - minLevel: maxInt(0, minInt(maxLevel, rc.MinLevel)), - maxLevel: maxInt(0, minInt(maxLevel, rc.MaxLevel)), - levelMod: maxInt(1, minInt(3, rc.LevelMod)), - maxCells: rc.MaxCells, - } -} - -// Covering returns a CellUnion that covers the given region and satisfies the various restrictions. -func (rc *RegionCoverer) Covering(region Region) CellUnion { - covering := rc.CellUnion(region) - covering.Denormalize(maxInt(0, minInt(maxLevel, rc.MinLevel)), maxInt(1, minInt(3, rc.LevelMod))) - return covering -} - -// InteriorCovering returns a CellUnion that is contained within the given region and satisfies the various restrictions. -func (rc *RegionCoverer) InteriorCovering(region Region) CellUnion { - intCovering := rc.InteriorCellUnion(region) - intCovering.Denormalize(maxInt(0, minInt(maxLevel, rc.MinLevel)), maxInt(1, minInt(3, rc.LevelMod))) - return intCovering -} - -// CellUnion returns a normalized CellUnion that covers the given region and -// satisfies the restrictions except for minLevel and levelMod. These criteria -// cannot be satisfied using a cell union because cell unions are -// automatically normalized by replacing four child cells with their parent -// whenever possible. (Note that the list of cell ids passed to the CellUnion -// constructor does in fact satisfy all the given restrictions.) -func (rc *RegionCoverer) CellUnion(region Region) CellUnion { - c := rc.newCoverer() - c.coveringInternal(region) - cu := c.result - cu.Normalize() - return cu -} - -// InteriorCellUnion returns a normalized CellUnion that is contained within the given region and -// satisfies the restrictions except for minLevel and levelMod. These criteria -// cannot be satisfied using a cell union because cell unions are -// automatically normalized by replacing four child cells with their parent -// whenever possible. (Note that the list of cell ids passed to the CellUnion -// constructor does in fact satisfy all the given restrictions.) -func (rc *RegionCoverer) InteriorCellUnion(region Region) CellUnion { - c := rc.newCoverer() - c.interiorCovering = true - c.coveringInternal(region) - cu := c.result - cu.Normalize() - return cu -} - -// FastCovering returns a CellUnion that covers the given region similar to Covering, -// except that this method is much faster and the coverings are not as tight. -// All of the usual parameters are respected (MaxCells, MinLevel, MaxLevel, and LevelMod), -// except that the implementation makes no attempt to take advantage of large values of -// MaxCells. (A small number of cells will always be returned.) -// -// This function is useful as a starting point for algorithms that -// recursively subdivide cells. -func (rc *RegionCoverer) FastCovering(region Region) CellUnion { - c := rc.newCoverer() - cu := CellUnion(region.CellUnionBound()) - c.normalizeCovering(&cu) - return cu -} - -// IsCanonical reports whether the given CellUnion represents a valid covering -// that conforms to the current covering parameters. In particular: -// -// - All CellIDs must be valid. -// -// - CellIDs must be sorted and non-overlapping. -// -// - CellID levels must satisfy MinLevel, MaxLevel, and LevelMod. -// -// - If the covering has more than MaxCells, there must be no two cells with -// a common ancestor at MinLevel or higher. -// -// - There must be no sequence of cells that could be replaced by an -// ancestor (i.e. with LevelMod == 1, the 4 child cells of a parent). -func (rc *RegionCoverer) IsCanonical(covering CellUnion) bool { - return rc.newCoverer().isCanonical(covering) -} - -// normalizeCovering normalizes the "covering" so that it conforms to the -// current covering parameters (maxCells, minLevel, maxLevel, and levelMod). -// This method makes no attempt to be optimal. In particular, if -// minLevel > 0 or levelMod > 1 then it may return more than the -// desired number of cells even when this isn't necessary. -// -// Note that when the covering parameters have their default values, almost -// all of the code in this function is skipped. -func (c *coverer) normalizeCovering(covering *CellUnion) { - // If any cells are too small, or don't satisfy levelMod, then replace them with ancestors. - if c.maxLevel < maxLevel || c.levelMod > 1 { - for i, ci := range *covering { - level := ci.Level() - newLevel := c.adjustLevel(minInt(level, c.maxLevel)) - if newLevel != level { - (*covering)[i] = ci.Parent(newLevel) - } - } - } - // Sort the cells and simplify them. - covering.Normalize() - - // Make sure that the covering satisfies minLevel and levelMod, - // possibly at the expense of satisfying MaxCells. - if c.minLevel > 0 || c.levelMod > 1 { - covering.Denormalize(c.minLevel, c.levelMod) - } - - // If there are too many cells and the covering is very large, use the - // RegionCoverer to compute a new covering. (This avoids possible O(n^2) - // behavior of the simpler algorithm below.) - excess := len(*covering) - c.maxCells - if excess <= 0 || c.isCanonical(*covering) { - return - } - if excess*len(*covering) > 10000 { - rc := NewRegionCoverer() - (*covering) = rc.Covering(covering) - return - } - - // If there are still too many cells, then repeatedly replace two adjacent - // cells in CellID order by their lowest common ancestor. - for len(*covering) > c.maxCells { - bestIndex := -1 - bestLevel := -1 - for i := 0; i+1 < len(*covering); i++ { - level, ok := (*covering)[i].CommonAncestorLevel((*covering)[i+1]) - if !ok { - continue - } - level = c.adjustLevel(level) - if level > bestLevel { - bestLevel = level - bestIndex = i - } - } - - if bestLevel < c.minLevel { - break - } - - // Replace all cells contained by the new ancestor cell. - id := (*covering)[bestIndex].Parent(bestLevel) - (*covering) = c.replaceCellsWithAncestor(*covering, id) - - // Now repeatedly check whether all children of the parent cell are - // present, in which case we can replace those cells with their parent. - for bestLevel > c.minLevel { - bestLevel -= c.levelMod - id = id.Parent(bestLevel) - if !c.containsAllChildren(*covering, id) { - break - } - (*covering) = c.replaceCellsWithAncestor(*covering, id) - } - } -} - -// isCanonical reports whether the covering is canonical. -func (c *coverer) isCanonical(covering CellUnion) bool { - trueMax := c.maxLevel - if c.levelMod != 1 { - trueMax = c.maxLevel - (c.maxLevel-c.minLevel)%c.levelMod - } - tooManyCells := len(covering) > c.maxCells - sameParentCount := 1 - - prevID := CellID(0) - for _, id := range covering { - if !id.IsValid() { - return false - } - - // Check that the CellID level is acceptable. - level := id.Level() - if level < c.minLevel || level > trueMax { - return false - } - if c.levelMod > 1 && (level-c.minLevel)%c.levelMod != 0 { - return false - } - - if prevID != 0 { - // Check that cells are sorted and non-overlapping. - if prevID.RangeMax() >= id.RangeMin() { - return false - } - - lev, ok := id.CommonAncestorLevel(prevID) - // If there are too many cells, check that no pair of adjacent cells - // could be replaced by an ancestor. - if tooManyCells && (ok && lev >= c.minLevel) { - return false - } - - // Check that there are no sequences of (4 ** level_mod) cells that all - // have the same parent (considering only multiples of "level_mod"). - pLevel := level - c.levelMod - if pLevel < c.minLevel || level != prevID.Level() || - id.Parent(pLevel) != prevID.Parent(pLevel) { - sameParentCount = 1 - } else { - sameParentCount++ - if sameParentCount == 1<<uint(2*c.levelMod) { - return false - } - } - } - prevID = id - } - - return true -} - -func (c *coverer) containsAllChildren(covering []CellID, id CellID) bool { - pos := sort.Search(len(covering), func(i int) bool { return (covering)[i] >= id.RangeMin() }) - level := id.Level() + c.levelMod - for child := id.ChildBeginAtLevel(level); child != id.ChildEndAtLevel(level); child = child.Next() { - if pos == len(covering) || covering[pos] != child { - return false - } - pos++ - } - return true -} - -// replaceCellsWithAncestor replaces all descendants of the given id in covering -// with id. This requires the covering contains at least one descendant of id. -func (c *coverer) replaceCellsWithAncestor(covering []CellID, id CellID) []CellID { - begin := sort.Search(len(covering), func(i int) bool { return covering[i] > id.RangeMin() }) - end := sort.Search(len(covering), func(i int) bool { return covering[i] > id.RangeMax() }) - - return append(append(covering[:begin], id), covering[end:]...) -} - -// SimpleRegionCovering returns a set of cells at the given level that cover -// the connected region and a starting point on the boundary or inside the -// region. The cells are returned in arbitrary order. -// -// Note that this method is not faster than the regular Covering -// method for most region types, such as Cap or Polygon, and in fact it -// can be much slower when the output consists of a large number of cells. -// Currently it can be faster at generating coverings of long narrow regions -// such as polylines, but this may change in the future. -func SimpleRegionCovering(region Region, start Point, level int) []CellID { - return FloodFillRegionCovering(region, cellIDFromPoint(start).Parent(level)) -} - -// FloodFillRegionCovering returns all edge-connected cells at the same level as -// the given CellID that intersect the given region, in arbitrary order. -func FloodFillRegionCovering(region Region, start CellID) []CellID { - var output []CellID - all := map[CellID]bool{ - start: true, - } - frontier := []CellID{start} - for len(frontier) > 0 { - id := frontier[len(frontier)-1] - frontier = frontier[:len(frontier)-1] - if !region.IntersectsCell(CellFromCellID(id)) { - continue - } - output = append(output, id) - for _, nbr := range id.EdgeNeighbors() { - if !all[nbr] { - all[nbr] = true - frontier = append(frontier, nbr) - } - } - } - - return output -} diff --git a/vendor/github.com/golang/geo/s2/regionunion.go b/vendor/github.com/golang/geo/s2/regionunion.go deleted file mode 100644 index 915b7c330..000000000 --- a/vendor/github.com/golang/geo/s2/regionunion.go +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright 2020 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// A RegionUnion represents a union of possibly overlapping regions. -// It is convenient for computing a covering of a set of regions. -type RegionUnion []Region - -// CapBound returns a bounding cap for this RegionUnion. -func (ru RegionUnion) CapBound() Cap { return ru.RectBound().CapBound() } - -// RectBound returns a bounding latitude-longitude rectangle for this RegionUnion. -func (ru RegionUnion) RectBound() Rect { - ret := EmptyRect() - for _, reg := range ru { - ret = ret.Union(reg.RectBound()) - } - return ret -} - -// ContainsCell reports whether the given Cell is contained by this RegionUnion. -func (ru RegionUnion) ContainsCell(c Cell) bool { - for _, reg := range ru { - if reg.ContainsCell(c) { - return true - } - } - return false -} - -// IntersectsCell reports whether this RegionUnion intersects the given cell. -func (ru RegionUnion) IntersectsCell(c Cell) bool { - for _, reg := range ru { - if reg.IntersectsCell(c) { - return true - } - } - return false -} - -// ContainsPoint reports whether this RegionUnion contains the Point. -func (ru RegionUnion) ContainsPoint(p Point) bool { - for _, reg := range ru { - if reg.ContainsPoint(p) { - return true - } - } - return false -} - -// CellUnionBound computes a covering of the RegionUnion. -func (ru RegionUnion) CellUnionBound() []CellID { - return ru.CapBound().CellUnionBound() -} diff --git a/vendor/github.com/golang/geo/s2/shape.go b/vendor/github.com/golang/geo/s2/shape.go deleted file mode 100644 index 2cbf170c3..000000000 --- a/vendor/github.com/golang/geo/s2/shape.go +++ /dev/null @@ -1,263 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "sort" -) - -// Edge represents a geodesic edge consisting of two vertices. Zero-length edges are -// allowed, and can be used to represent points. -type Edge struct { - V0, V1 Point -} - -// Cmp compares the two edges using the underlying Points Cmp method and returns -// -// -1 if e < other -// 0 if e == other -// +1 if e > other -// -// The two edges are compared by first vertex, and then by the second vertex. -func (e Edge) Cmp(other Edge) int { - if v0cmp := e.V0.Cmp(other.V0.Vector); v0cmp != 0 { - return v0cmp - } - return e.V1.Cmp(other.V1.Vector) -} - -// sortEdges sorts the slice of Edges in place. -func sortEdges(e []Edge) { - sort.Sort(edges(e)) -} - -// edges implements the Sort interface for slices of Edge. -type edges []Edge - -func (e edges) Len() int { return len(e) } -func (e edges) Swap(i, j int) { e[i], e[j] = e[j], e[i] } -func (e edges) Less(i, j int) bool { return e[i].Cmp(e[j]) == -1 } - -// ShapeEdgeID is a unique identifier for an Edge within an ShapeIndex, -// consisting of a (shapeID, edgeID) pair. -type ShapeEdgeID struct { - ShapeID int32 - EdgeID int32 -} - -// Cmp compares the two ShapeEdgeIDs and returns -// -// -1 if s < other -// 0 if s == other -// +1 if s > other -// -// The two are compared first by shape id and then by edge id. -func (s ShapeEdgeID) Cmp(other ShapeEdgeID) int { - switch { - case s.ShapeID < other.ShapeID: - return -1 - case s.ShapeID > other.ShapeID: - return 1 - } - switch { - case s.EdgeID < other.EdgeID: - return -1 - case s.EdgeID > other.EdgeID: - return 1 - } - return 0 -} - -// ShapeEdge represents a ShapeEdgeID with the two endpoints of that Edge. -type ShapeEdge struct { - ID ShapeEdgeID - Edge Edge -} - -// Chain represents a range of edge IDs corresponding to a chain of connected -// edges, specified as a (start, length) pair. The chain is defined to consist of -// edge IDs {start, start + 1, ..., start + length - 1}. -type Chain struct { - Start, Length int -} - -// ChainPosition represents the position of an edge within a given edge chain, -// specified as a (chainID, offset) pair. Chains are numbered sequentially -// starting from zero, and offsets are measured from the start of each chain. -type ChainPosition struct { - ChainID, Offset int -} - -// A ReferencePoint consists of a point and a boolean indicating whether the point -// is contained by a particular shape. -type ReferencePoint struct { - Point Point - Contained bool -} - -// OriginReferencePoint returns a ReferencePoint with the given value for -// contained and the origin point. It should be used when all points or no -// points are contained. -func OriginReferencePoint(contained bool) ReferencePoint { - return ReferencePoint{Point: OriginPoint(), Contained: contained} -} - -// typeTag is a 32-bit tag that can be used to identify the type of an encoded -// Shape. All encodable types have a non-zero type tag. The tag associated with -type typeTag uint32 - -const ( - // Indicates that a given Shape type cannot be encoded. - typeTagNone typeTag = 0 - typeTagPolygon typeTag = 1 - typeTagPolyline typeTag = 2 - typeTagPointVector typeTag = 3 - typeTagLaxPolyline typeTag = 4 - typeTagLaxPolygon typeTag = 5 - - // The minimum allowable tag for future user-defined Shape types. - typeTagMinUser typeTag = 8192 -) - -// Shape represents polygonal geometry in a flexible way. It is organized as a -// collection of edges that optionally defines an interior. All geometry -// represented by a given Shape must have the same dimension, which means that -// an Shape can represent either a set of points, a set of polylines, or a set -// of polygons. -// -// Shape is defined as an interface in order to give clients control over the -// underlying data representation. Sometimes an Shape does not have any data of -// its own, but instead wraps some other type. -// -// Shape operations are typically defined on a ShapeIndex rather than -// individual shapes. An ShapeIndex is simply a collection of Shapes, -// possibly of different dimensions (e.g. 10 points and 3 polygons), organized -// into a data structure for efficient edge access. -// -// The edges of a Shape are indexed by a contiguous range of edge IDs -// starting at 0. The edges are further subdivided into chains, where each -// chain consists of a sequence of edges connected end-to-end (a polyline). -// For example, a Shape representing two polylines AB and CDE would have -// three edges (AB, CD, DE) grouped into two chains: (AB) and (CD, DE). -// Similarly, an Shape representing 5 points would have 5 chains consisting -// of one edge each. -// -// Shape has methods that allow edges to be accessed either using the global -// numbering (edge ID) or within a particular chain. The global numbering is -// sufficient for most purposes, but the chain representation is useful for -// certain algorithms such as intersection (see BooleanOperation). -type Shape interface { - // NumEdges returns the number of edges in this shape. - NumEdges() int - - // Edge returns the edge for the given edge index. - Edge(i int) Edge - - // ReferencePoint returns an arbitrary reference point for the shape. (The - // containment boolean value must be false for shapes that do not have an interior.) - // - // This reference point may then be used to compute the containment of other - // points by counting edge crossings. - ReferencePoint() ReferencePoint - - // NumChains reports the number of contiguous edge chains in the shape. - // For example, a shape whose edges are [AB, BC, CD, AE, EF] would consist - // of two chains (AB,BC,CD and AE,EF). Every chain is assigned a chain Id - // numbered sequentially starting from zero. - // - // Note that it is always acceptable to implement this method by returning - // NumEdges, i.e. every chain consists of a single edge, but this may - // reduce the efficiency of some algorithms. - NumChains() int - - // Chain returns the range of edge IDs corresponding to the given edge chain. - // Edge chains must form contiguous, non-overlapping ranges that cover - // the entire range of edge IDs. This is spelled out more formally below: - // - // 0 <= i < NumChains() - // Chain(i).length > 0, for all i - // Chain(0).start == 0 - // Chain(i).start + Chain(i).length == Chain(i+1).start, for i < NumChains()-1 - // Chain(i).start + Chain(i).length == NumEdges(), for i == NumChains()-1 - Chain(chainID int) Chain - - // ChainEdgeReturns the edge at offset "offset" within edge chain "chainID". - // Equivalent to "shape.Edge(shape.Chain(chainID).start + offset)" - // but more efficient. - ChainEdge(chainID, offset int) Edge - - // ChainPosition finds the chain containing the given edge, and returns the - // position of that edge as a ChainPosition(chainID, offset) pair. - // - // shape.Chain(pos.chainID).start + pos.offset == edgeID - // shape.Chain(pos.chainID+1).start > edgeID - // - // where pos == shape.ChainPosition(edgeID). - ChainPosition(edgeID int) ChainPosition - - // Dimension returns the dimension of the geometry represented by this shape, - // either 0, 1 or 2 for point, polyline and polygon geometry respectively. - // - // 0 - Point geometry. Each point is represented as a degenerate edge. - // - // 1 - Polyline geometry. Polyline edges may be degenerate. A shape may - // represent any number of polylines. Polylines edges may intersect. - // - // 2 - Polygon geometry. Edges should be oriented such that the polygon - // interior is always on the left. In theory the edges may be returned - // in any order, but typically the edges are organized as a collection - // of edge chains where each chain represents one polygon loop. - // Polygons may have degeneracies (e.g., degenerate edges or sibling - // pairs consisting of an edge and its corresponding reversed edge). - // A polygon loop may also be full (containing all points on the - // sphere); by convention this is represented as a chain with no edges. - // (See laxPolygon for details.) - // - // This method allows degenerate geometry of different dimensions - // to be distinguished, e.g. it allows a point to be distinguished from a - // polyline or polygon that has been simplified to a single point. - Dimension() int - - // IsEmpty reports whether the Shape contains no points. (Note that the full - // polygon is represented as a chain with zero edges.) - IsEmpty() bool - - // IsFull reports whether the Shape contains all points on the sphere. - IsFull() bool - - // typeTag returns a value that can be used to identify the type of an - // encoded Shape. - typeTag() typeTag - - // We do not support implementations of this interface outside this package. - privateInterface() -} - -// defaultShapeIsEmpty reports whether this shape contains no points. -func defaultShapeIsEmpty(s Shape) bool { - return s.NumEdges() == 0 && (s.Dimension() != 2 || s.NumChains() == 0) -} - -// defaultShapeIsFull reports whether this shape contains all points on the sphere. -func defaultShapeIsFull(s Shape) bool { - return s.NumEdges() == 0 && s.Dimension() == 2 && s.NumChains() > 0 -} - -// A minimal check for types that should satisfy the Shape interface. -var ( - _ Shape = &Loop{} - _ Shape = &Polygon{} - _ Shape = &Polyline{} -) diff --git a/vendor/github.com/golang/geo/s2/shapeindex.go b/vendor/github.com/golang/geo/s2/shapeindex.go deleted file mode 100644 index 6efa213ab..000000000 --- a/vendor/github.com/golang/geo/s2/shapeindex.go +++ /dev/null @@ -1,1526 +0,0 @@ -// Copyright 2016 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - "sort" - "sync" - "sync/atomic" - - "github.com/golang/geo/r1" - "github.com/golang/geo/r2" -) - -// CellRelation describes the possible relationships between a target cell -// and the cells of the ShapeIndex. If the target is an index cell or is -// contained by an index cell, it is Indexed. If the target is subdivided -// into one or more index cells, it is Subdivided. Otherwise it is Disjoint. -type CellRelation int - -// The possible CellRelations for a ShapeIndex. -const ( - Indexed CellRelation = iota - Subdivided - Disjoint -) - -const ( - // cellPadding defines the total error when clipping an edge which comes - // from two sources: - // (1) Clipping the original spherical edge to a cube face (the face edge). - // The maximum error in this step is faceClipErrorUVCoord. - // (2) Clipping the face edge to the u- or v-coordinate of a cell boundary. - // The maximum error in this step is edgeClipErrorUVCoord. - // Finally, since we encounter the same errors when clipping query edges, we - // double the total error so that we only need to pad edges during indexing - // and not at query time. - cellPadding = 2.0 * (faceClipErrorUVCoord + edgeClipErrorUVCoord) - - // cellSizeToLongEdgeRatio defines the cell size relative to the length of an - // edge at which it is first considered to be long. Long edges do not - // contribute toward the decision to subdivide a cell further. For example, - // a value of 2.0 means that the cell must be at least twice the size of the - // edge in order for that edge to be counted. There are two reasons for not - // counting long edges: (1) such edges typically need to be propagated to - // several children, which increases time and memory costs without much benefit, - // and (2) in pathological cases, many long edges close together could force - // subdivision to continue all the way to the leaf cell level. - cellSizeToLongEdgeRatio = 1.0 -) - -// clippedShape represents the part of a shape that intersects a Cell. -// It consists of the set of edge IDs that intersect that cell and a boolean -// indicating whether the center of the cell is inside the shape (for shapes -// that have an interior). -// -// Note that the edges themselves are not clipped; we always use the original -// edges for intersection tests so that the results will be the same as the -// original shape. -type clippedShape struct { - // shapeID is the index of the shape this clipped shape is a part of. - shapeID int32 - - // containsCenter indicates if the center of the CellID this shape has been - // clipped to falls inside this shape. This is false for shapes that do not - // have an interior. - containsCenter bool - - // edges is the ordered set of ShapeIndex original edge IDs. Edges - // are stored in increasing order of edge ID. - edges []int -} - -// newClippedShape returns a new clipped shape for the given shapeID and number of expected edges. -func newClippedShape(id int32, numEdges int) *clippedShape { - return &clippedShape{ - shapeID: id, - edges: make([]int, numEdges), - } -} - -// numEdges returns the number of edges that intersect the CellID of the Cell this was clipped to. -func (c *clippedShape) numEdges() int { - return len(c.edges) -} - -// containsEdge reports if this clipped shape contains the given edge ID. -func (c *clippedShape) containsEdge(id int) bool { - // Linear search is fast because the number of edges per shape is typically - // very small (less than 10). - for _, e := range c.edges { - if e == id { - return true - } - } - return false -} - -// ShapeIndexCell stores the index contents for a particular CellID. -type ShapeIndexCell struct { - shapes []*clippedShape -} - -// NewShapeIndexCell creates a new cell that is sized to hold the given number of shapes. -func NewShapeIndexCell(numShapes int) *ShapeIndexCell { - return &ShapeIndexCell{ - shapes: make([]*clippedShape, numShapes), - } -} - -// numEdges reports the total number of edges in all clipped shapes in this cell. -func (s *ShapeIndexCell) numEdges() int { - var e int - for _, cs := range s.shapes { - e += cs.numEdges() - } - return e -} - -// add adds the given clipped shape to this index cell. -func (s *ShapeIndexCell) add(c *clippedShape) { - // C++ uses a set, so it's ordered and unique. We don't currently catch - // the case when a duplicate value is added. - s.shapes = append(s.shapes, c) -} - -// findByShapeID returns the clipped shape that contains the given shapeID, -// or nil if none of the clipped shapes contain it. -func (s *ShapeIndexCell) findByShapeID(shapeID int32) *clippedShape { - // Linear search is fine because the number of shapes per cell is typically - // very small (most often 1), and is large only for pathological inputs - // (e.g. very deeply nested loops). - for _, clipped := range s.shapes { - if clipped.shapeID == shapeID { - return clipped - } - } - return nil -} - -// faceEdge and clippedEdge store temporary edge data while the index is being -// updated. -// -// While it would be possible to combine all the edge information into one -// structure, there are two good reasons for separating it: -// -// - Memory usage. Separating the two means that we only need to -// store one copy of the per-face data no matter how many times an edge is -// subdivided, and it also lets us delay computing bounding boxes until -// they are needed for processing each face (when the dataset spans -// multiple faces). -// -// - Performance. UpdateEdges is significantly faster on large polygons when -// the data is separated, because it often only needs to access the data in -// clippedEdge and this data is cached more successfully. - -// faceEdge represents an edge that has been projected onto a given face, -type faceEdge struct { - shapeID int32 // The ID of shape that this edge belongs to - edgeID int // Edge ID within that shape - maxLevel int // Not desirable to subdivide this edge beyond this level - hasInterior bool // Belongs to a shape that has a dimension of 2 - a, b r2.Point // The edge endpoints, clipped to a given face - edge Edge // The original edge. -} - -// clippedEdge represents the portion of that edge that has been clipped to a given Cell. -type clippedEdge struct { - faceEdge *faceEdge // The original unclipped edge - bound r2.Rect // Bounding box for the clipped portion -} - -// ShapeIndexIteratorPos defines the set of possible iterator starting positions. By -// default iterators are unpositioned, since this avoids an extra seek in this -// situation where one of the seek methods (such as Locate) is immediately called. -type ShapeIndexIteratorPos int - -const ( - // IteratorBegin specifies the iterator should be positioned at the beginning of the index. - IteratorBegin ShapeIndexIteratorPos = iota - // IteratorEnd specifies the iterator should be positioned at the end of the index. - IteratorEnd -) - -// ShapeIndexIterator is an iterator that provides low-level access to -// the cells of the index. Cells are returned in increasing order of CellID. -// -// for it := index.Iterator(); !it.Done(); it.Next() { -// fmt.Print(it.CellID()) -// } -// -type ShapeIndexIterator struct { - index *ShapeIndex - position int - id CellID - cell *ShapeIndexCell -} - -// NewShapeIndexIterator creates a new iterator for the given index. If a starting -// position is specified, the iterator is positioned at the given spot. -func NewShapeIndexIterator(index *ShapeIndex, pos ...ShapeIndexIteratorPos) *ShapeIndexIterator { - s := &ShapeIndexIterator{ - index: index, - } - - if len(pos) > 0 { - if len(pos) > 1 { - panic("too many ShapeIndexIteratorPos arguments") - } - switch pos[0] { - case IteratorBegin: - s.Begin() - case IteratorEnd: - s.End() - default: - panic("unknown ShapeIndexIteratorPos value") - } - } - - return s -} - -func (s *ShapeIndexIterator) clone() *ShapeIndexIterator { - return &ShapeIndexIterator{ - index: s.index, - position: s.position, - id: s.id, - cell: s.cell, - } -} - -// CellID returns the CellID of the current index cell. -// If s.Done() is true, a value larger than any valid CellID is returned. -func (s *ShapeIndexIterator) CellID() CellID { - return s.id -} - -// IndexCell returns the current index cell. -func (s *ShapeIndexIterator) IndexCell() *ShapeIndexCell { - // TODO(roberts): C++ has this call a virtual method to allow subclasses - // of ShapeIndexIterator to do other work before returning the cell. Do - // we need such a thing? - return s.cell -} - -// Center returns the Point at the center of the current position of the iterator. -func (s *ShapeIndexIterator) Center() Point { - return s.CellID().Point() -} - -// Begin positions the iterator at the beginning of the index. -func (s *ShapeIndexIterator) Begin() { - if !s.index.IsFresh() { - s.index.maybeApplyUpdates() - } - s.position = 0 - s.refresh() -} - -// Next positions the iterator at the next index cell. -func (s *ShapeIndexIterator) Next() { - s.position++ - s.refresh() -} - -// Prev advances the iterator to the previous cell in the index and returns true to -// indicate it was not yet at the beginning of the index. If the iterator is at the -// first cell the call does nothing and returns false. -func (s *ShapeIndexIterator) Prev() bool { - if s.position <= 0 { - return false - } - - s.position-- - s.refresh() - return true -} - -// End positions the iterator at the end of the index. -func (s *ShapeIndexIterator) End() { - s.position = len(s.index.cells) - s.refresh() -} - -// Done reports if the iterator is positioned at or after the last index cell. -func (s *ShapeIndexIterator) Done() bool { - return s.id == SentinelCellID -} - -// refresh updates the stored internal iterator values. -func (s *ShapeIndexIterator) refresh() { - if s.position < len(s.index.cells) { - s.id = s.index.cells[s.position] - s.cell = s.index.cellMap[s.CellID()] - } else { - s.id = SentinelCellID - s.cell = nil - } -} - -// seek positions the iterator at the first cell whose ID >= target, or at the -// end of the index if no such cell exists. -func (s *ShapeIndexIterator) seek(target CellID) { - s.position = sort.Search(len(s.index.cells), func(i int) bool { - return s.index.cells[i] >= target - }) - s.refresh() -} - -// LocatePoint positions the iterator at the cell that contains the given Point. -// If no such cell exists, the iterator position is unspecified, and false is returned. -// The cell at the matched position is guaranteed to contain all edges that might -// intersect the line segment between target and the cell's center. -func (s *ShapeIndexIterator) LocatePoint(p Point) bool { - // Let I = cellMap.LowerBound(T), where T is the leaf cell containing - // point P. Then if T is contained by an index cell, then the - // containing cell is either I or I'. We test for containment by comparing - // the ranges of leaf cells spanned by T, I, and I'. - target := cellIDFromPoint(p) - s.seek(target) - if !s.Done() && s.CellID().RangeMin() <= target { - return true - } - - if s.Prev() && s.CellID().RangeMax() >= target { - return true - } - return false -} - -// LocateCellID attempts to position the iterator at the first matching index cell -// in the index that has some relation to the given CellID. Let T be the target CellID. -// If T is contained by (or equal to) some index cell I, then the iterator is positioned -// at I and returns Indexed. Otherwise if T contains one or more (smaller) index cells, -// then the iterator is positioned at the first such cell I and return Subdivided. -// Otherwise Disjoint is returned and the iterator position is undefined. -func (s *ShapeIndexIterator) LocateCellID(target CellID) CellRelation { - // Let T be the target, let I = cellMap.LowerBound(T.RangeMin()), and - // let I' be the predecessor of I. If T contains any index cells, then T - // contains I. Similarly, if T is contained by an index cell, then the - // containing cell is either I or I'. We test for containment by comparing - // the ranges of leaf cells spanned by T, I, and I'. - s.seek(target.RangeMin()) - if !s.Done() { - if s.CellID() >= target && s.CellID().RangeMin() <= target { - return Indexed - } - if s.CellID() <= target.RangeMax() { - return Subdivided - } - } - if s.Prev() && s.CellID().RangeMax() >= target { - return Indexed - } - return Disjoint -} - -// tracker keeps track of which shapes in a given set contain a particular point -// (the focus). It provides an efficient way to move the focus from one point -// to another and incrementally update the set of shapes which contain it. We use -// this to compute which shapes contain the center of every CellID in the index, -// by advancing the focus from one cell center to the next. -// -// Initially the focus is at the start of the CellID space-filling curve. We then -// visit all the cells that are being added to the ShapeIndex in increasing order -// of CellID. For each cell, we draw two edges: one from the entry vertex to the -// center, and another from the center to the exit vertex (where entry and exit -// refer to the points where the space-filling curve enters and exits the cell). -// By counting edge crossings we can incrementally compute which shapes contain -// the cell center. Note that the same set of shapes will always contain the exit -// point of one cell and the entry point of the next cell in the index, because -// either (a) these two points are actually the same, or (b) the intervening -// cells in CellID order are all empty, and therefore there are no edge crossings -// if we follow this path from one cell to the other. -// -// In C++, this is S2ShapeIndex::InteriorTracker. -type tracker struct { - isActive bool - a Point - b Point - nextCellID CellID - crosser *EdgeCrosser - shapeIDs []int32 - - // Shape ids saved by saveAndClearStateBefore. The state is never saved - // recursively so we don't need to worry about maintaining a stack. - savedIDs []int32 -} - -// newTracker returns a new tracker with the appropriate defaults. -func newTracker() *tracker { - // As shapes are added, we compute which ones contain the start of the - // CellID space-filling curve by drawing an edge from OriginPoint to this - // point and counting how many shape edges cross this edge. - t := &tracker{ - isActive: false, - b: trackerOrigin(), - nextCellID: CellIDFromFace(0).ChildBeginAtLevel(maxLevel), - } - t.drawTo(Point{faceUVToXYZ(0, -1, -1).Normalize()}) // CellID curve start - - return t -} - -// trackerOrigin returns the initial focus point when the tracker is created -// (corresponding to the start of the CellID space-filling curve). -func trackerOrigin() Point { - // The start of the S2CellId space-filling curve. - return Point{faceUVToXYZ(0, -1, -1).Normalize()} -} - -// focus returns the current focus point of the tracker. -func (t *tracker) focus() Point { return t.b } - -// addShape adds a shape whose interior should be tracked. containsOrigin indicates -// whether the current focus point is inside the shape. Alternatively, if -// the focus point is in the process of being moved (via moveTo/drawTo), you -// can also specify containsOrigin at the old focus point and call testEdge -// for every edge of the shape that might cross the current drawTo line. -// This updates the state to correspond to the new focus point. -// -// This requires shape.HasInterior -func (t *tracker) addShape(shapeID int32, containsFocus bool) { - t.isActive = true - if containsFocus { - t.toggleShape(shapeID) - } -} - -// moveTo moves the focus of the tracker to the given point. This method should -// only be used when it is known that there are no edge crossings between the old -// and new focus locations; otherwise use drawTo. -func (t *tracker) moveTo(b Point) { t.b = b } - -// drawTo moves the focus of the tracker to the given point. After this method is -// called, testEdge should be called with all edges that may cross the line -// segment between the old and new focus locations. -func (t *tracker) drawTo(b Point) { - t.a = t.b - t.b = b - // TODO: the edge crosser may need an in-place Init method if this gets expensive - t.crosser = NewEdgeCrosser(t.a, t.b) -} - -// testEdge checks if the given edge crosses the current edge, and if so, then -// toggle the state of the given shapeID. -// This requires shape to have an interior. -func (t *tracker) testEdge(shapeID int32, edge Edge) { - if t.crosser.EdgeOrVertexCrossing(edge.V0, edge.V1) { - t.toggleShape(shapeID) - } -} - -// setNextCellID is used to indicate that the last argument to moveTo or drawTo -// was the entry vertex of the given CellID, i.e. the tracker is positioned at the -// start of this cell. By using this method together with atCellID, the caller -// can avoid calling moveTo in cases where the exit vertex of the previous cell -// is the same as the entry vertex of the current cell. -func (t *tracker) setNextCellID(nextCellID CellID) { - t.nextCellID = nextCellID.RangeMin() -} - -// atCellID reports if the focus is already at the entry vertex of the given -// CellID (provided that the caller calls setNextCellID as each cell is processed). -func (t *tracker) atCellID(cellid CellID) bool { - return cellid.RangeMin() == t.nextCellID -} - -// toggleShape adds or removes the given shapeID from the set of IDs it is tracking. -func (t *tracker) toggleShape(shapeID int32) { - // Most shapeIDs slices are small, so special case the common steps. - - // If there is nothing here, add it. - if len(t.shapeIDs) == 0 { - t.shapeIDs = append(t.shapeIDs, shapeID) - return - } - - // If it's the first element, drop it from the slice. - if t.shapeIDs[0] == shapeID { - t.shapeIDs = t.shapeIDs[1:] - return - } - - for i, s := range t.shapeIDs { - if s < shapeID { - continue - } - - // If it's in the set, cut it out. - if s == shapeID { - copy(t.shapeIDs[i:], t.shapeIDs[i+1:]) // overwrite the ith element - t.shapeIDs = t.shapeIDs[:len(t.shapeIDs)-1] - return - } - - // We've got to a point in the slice where we should be inserted. - // (the given shapeID is now less than the current positions id.) - t.shapeIDs = append(t.shapeIDs[0:i], - append([]int32{shapeID}, t.shapeIDs[i:len(t.shapeIDs)]...)...) - return - } - - // We got to the end and didn't find it, so add it to the list. - t.shapeIDs = append(t.shapeIDs, shapeID) -} - -// saveAndClearStateBefore makes an internal copy of the state for shape ids below -// the given limit, and then clear the state for those shapes. This is used during -// incremental updates to track the state of added and removed shapes separately. -func (t *tracker) saveAndClearStateBefore(limitShapeID int32) { - limit := t.lowerBound(limitShapeID) - t.savedIDs = append([]int32(nil), t.shapeIDs[:limit]...) - t.shapeIDs = t.shapeIDs[limit:] -} - -// restoreStateBefore restores the state previously saved by saveAndClearStateBefore. -// This only affects the state for shapeIDs below "limitShapeID". -func (t *tracker) restoreStateBefore(limitShapeID int32) { - limit := t.lowerBound(limitShapeID) - t.shapeIDs = append(append([]int32(nil), t.savedIDs...), t.shapeIDs[limit:]...) - t.savedIDs = nil -} - -// lowerBound returns the shapeID of the first entry x where x >= shapeID. -func (t *tracker) lowerBound(shapeID int32) int32 { - panic("not implemented") -} - -// removedShape represents a set of edges from the given shape that is queued for removal. -type removedShape struct { - shapeID int32 - hasInterior bool - containsTrackerOrigin bool - edges []Edge -} - -// There are three basic states the index can be in. -const ( - stale int32 = iota // There are pending updates. - updating // Updates are currently being applied. - fresh // There are no pending updates. -) - -// ShapeIndex indexes a set of Shapes, where a Shape is some collection of edges -// that optionally defines an interior. It can be used to represent a set of -// points, a set of polylines, or a set of polygons. For Shapes that have -// interiors, the index makes it very fast to determine which Shape(s) contain -// a given point or region. -// -// The index can be updated incrementally by adding or removing shapes. It is -// designed to handle up to hundreds of millions of edges. All data structures -// are designed to be small, so the index is compact; generally it is smaller -// than the underlying data being indexed. The index is also fast to construct. -// -// Polygon, Loop, and Polyline implement Shape which allows these objects to -// be indexed easily. You can find useful query methods in CrossingEdgeQuery -// and ClosestEdgeQuery (Not yet implemented in Go). -// -// Example showing how to build an index of Polylines: -// -// index := NewShapeIndex() -// for _, polyline := range polylines { -// index.Add(polyline); -// } -// // Now you can use a CrossingEdgeQuery or ClosestEdgeQuery here. -// -type ShapeIndex struct { - // shapes is a map of shape ID to shape. - shapes map[int32]Shape - - // The maximum number of edges per cell. - // TODO(roberts): Update the comments when the usage of this is implemented. - maxEdgesPerCell int - - // nextID tracks the next ID to hand out. IDs are not reused when shapes - // are removed from the index. - nextID int32 - - // cellMap is a map from CellID to the set of clipped shapes that intersect that - // cell. The cell IDs cover a set of non-overlapping regions on the sphere. - // In C++, this is a BTree, so the cells are ordered naturally by the data structure. - cellMap map[CellID]*ShapeIndexCell - // Track the ordered list of cell IDs. - cells []CellID - - // The current status of the index; accessed atomically. - status int32 - - // Additions and removals are queued and processed on the first subsequent - // query. There are several reasons to do this: - // - // - It is significantly more efficient to process updates in batches if - // the amount of entities added grows. - // - Often the index will never be queried, in which case we can save both - // the time and memory required to build it. Examples: - // + Loops that are created simply to pass to an Polygon. (We don't - // need the Loop index, because Polygon builds its own index.) - // + Applications that load a database of geometry and then query only - // a small fraction of it. - // - // The main drawback is that we need to go to some extra work to ensure that - // some methods are still thread-safe. Note that the goal is *not* to - // make this thread-safe in general, but simply to hide the fact that - // we defer some of the indexing work until query time. - // - // This mutex protects all of following fields in the index. - mu sync.RWMutex - - // pendingAdditionsPos is the index of the first entry that has not been processed - // via applyUpdatesInternal. - pendingAdditionsPos int32 - - // The set of shapes that have been queued for removal but not processed yet by - // applyUpdatesInternal. - pendingRemovals []*removedShape -} - -// NewShapeIndex creates a new ShapeIndex. -func NewShapeIndex() *ShapeIndex { - return &ShapeIndex{ - maxEdgesPerCell: 10, - shapes: make(map[int32]Shape), - cellMap: make(map[CellID]*ShapeIndexCell), - cells: nil, - status: fresh, - } -} - -// Iterator returns an iterator for this index. -func (s *ShapeIndex) Iterator() *ShapeIndexIterator { - s.maybeApplyUpdates() - return NewShapeIndexIterator(s, IteratorBegin) -} - -// Begin positions the iterator at the first cell in the index. -func (s *ShapeIndex) Begin() *ShapeIndexIterator { - s.maybeApplyUpdates() - return NewShapeIndexIterator(s, IteratorBegin) -} - -// End positions the iterator at the last cell in the index. -func (s *ShapeIndex) End() *ShapeIndexIterator { - // TODO(roberts): It's possible that updates could happen to the index between - // the time this is called and the time the iterators position is used and this - // will be invalid or not the end. For now, things will be undefined if this - // happens. See about referencing the IsFresh to guard for this in the future. - s.maybeApplyUpdates() - return NewShapeIndexIterator(s, IteratorEnd) -} - -// Len reports the number of Shapes in this index. -func (s *ShapeIndex) Len() int { - return len(s.shapes) -} - -// Reset resets the index to its original state. -func (s *ShapeIndex) Reset() { - s.shapes = make(map[int32]Shape) - s.nextID = 0 - s.cellMap = make(map[CellID]*ShapeIndexCell) - s.cells = nil - atomic.StoreInt32(&s.status, fresh) -} - -// NumEdges returns the number of edges in this index. -func (s *ShapeIndex) NumEdges() int { - numEdges := 0 - for _, shape := range s.shapes { - numEdges += shape.NumEdges() - } - return numEdges -} - -// NumEdgesUpTo returns the number of edges in the given index, up to the given -// limit. If the limit is encountered, the current running total is returned, -// which may be more than the limit. -func (s *ShapeIndex) NumEdgesUpTo(limit int) int { - var numEdges int - // We choose to iterate over the shapes in order to match the counting - // up behavior in C++ and for test compatibility instead of using a - // more idiomatic range over the shape map. - for i := int32(0); i <= s.nextID; i++ { - s := s.Shape(i) - if s == nil { - continue - } - numEdges += s.NumEdges() - if numEdges >= limit { - break - } - } - - return numEdges -} - -// Shape returns the shape with the given ID, or nil if the shape has been removed from the index. -func (s *ShapeIndex) Shape(id int32) Shape { return s.shapes[id] } - -// idForShape returns the id of the given shape in this index, or -1 if it is -// not in the index. -// -// TODO(roberts): Need to figure out an appropriate way to expose this on a Shape. -// C++ allows a given S2 type (Loop, Polygon, etc) to be part of multiple indexes. -// By having each type extend S2Shape which has an id element, they all inherit their -// own id field rather than having to track it themselves. -func (s *ShapeIndex) idForShape(shape Shape) int32 { - for k, v := range s.shapes { - if v == shape { - return k - } - } - return -1 -} - -// Add adds the given shape to the index and returns the assigned ID.. -func (s *ShapeIndex) Add(shape Shape) int32 { - s.shapes[s.nextID] = shape - s.nextID++ - atomic.StoreInt32(&s.status, stale) - return s.nextID - 1 -} - -// Remove removes the given shape from the index. -func (s *ShapeIndex) Remove(shape Shape) { - // The index updates itself lazily because it is much more efficient to - // process additions and removals in batches. - id := s.idForShape(shape) - - // If the shape wasn't found, it's already been removed or was not in the index. - if s.shapes[id] == nil { - return - } - - // Remove the shape from the shapes map. - delete(s.shapes, id) - - // We are removing a shape that has not yet been added to the index, - // so there is nothing else to do. - if id >= s.pendingAdditionsPos { - return - } - - numEdges := shape.NumEdges() - removed := &removedShape{ - shapeID: id, - hasInterior: shape.Dimension() == 2, - containsTrackerOrigin: shape.ReferencePoint().Contained, - edges: make([]Edge, numEdges), - } - - for e := 0; e < numEdges; e++ { - removed.edges[e] = shape.Edge(e) - } - - s.pendingRemovals = append(s.pendingRemovals, removed) - atomic.StoreInt32(&s.status, stale) -} - -// Build triggers the update of the index. Calls to Add and Release are normally -// queued and processed on the first subsequent query. This has many advantages, -// the most important of which is that sometimes there *is* no subsequent -// query, which lets us avoid building the index completely. -// -// This method forces any pending updates to be applied immediately. -func (s *ShapeIndex) Build() { - s.maybeApplyUpdates() -} - -// IsFresh reports if there are no pending updates that need to be applied. -// This can be useful to avoid building the index unnecessarily, or for -// choosing between two different algorithms depending on whether the index -// is available. -// -// The returned index status may be slightly out of date if the index was -// built in a different thread. This is fine for the intended use (as an -// efficiency hint), but it should not be used by internal methods. -func (s *ShapeIndex) IsFresh() bool { - return atomic.LoadInt32(&s.status) == fresh -} - -// isFirstUpdate reports if this is the first update to the index. -func (s *ShapeIndex) isFirstUpdate() bool { - // Note that it is not sufficient to check whether cellMap is empty, since - // entries are added to it during the update process. - return s.pendingAdditionsPos == 0 -} - -// isShapeBeingRemoved reports if the shape with the given ID is currently slated for removal. -func (s *ShapeIndex) isShapeBeingRemoved(shapeID int32) bool { - // All shape ids being removed fall below the index position of shapes being added. - return shapeID < s.pendingAdditionsPos -} - -// maybeApplyUpdates checks if the index pieces have changed, and if so, applies pending updates. -func (s *ShapeIndex) maybeApplyUpdates() { - // TODO(roberts): To avoid acquiring and releasing the mutex on every - // query, we should use atomic operations when testing whether the status - // is fresh and when updating the status to be fresh. This guarantees - // that any thread that sees a status of fresh will also see the - // corresponding index updates. - if atomic.LoadInt32(&s.status) != fresh { - s.mu.Lock() - s.applyUpdatesInternal() - atomic.StoreInt32(&s.status, fresh) - s.mu.Unlock() - } -} - -// applyUpdatesInternal does the actual work of updating the index by applying all -// pending additions and removals. It does *not* update the indexes status. -func (s *ShapeIndex) applyUpdatesInternal() { - // TODO(roberts): Building the index can use up to 20x as much memory per - // edge as the final index memory size. If this causes issues, add in - // batched updating to limit the amount of items per batch to a - // configurable memory footprint overhead. - t := newTracker() - - // allEdges maps a Face to a collection of faceEdges. - allEdges := make([][]faceEdge, 6) - - for _, p := range s.pendingRemovals { - s.removeShapeInternal(p, allEdges, t) - } - - for id := s.pendingAdditionsPos; id < int32(len(s.shapes)); id++ { - s.addShapeInternal(id, allEdges, t) - } - - for face := 0; face < 6; face++ { - s.updateFaceEdges(face, allEdges[face], t) - } - - s.pendingRemovals = s.pendingRemovals[:0] - s.pendingAdditionsPos = int32(len(s.shapes)) - // It is the caller's responsibility to update the index status. -} - -// addShapeInternal clips all edges of the given shape to the six cube faces, -// adds the clipped edges to the set of allEdges, and starts tracking its -// interior if necessary. -func (s *ShapeIndex) addShapeInternal(shapeID int32, allEdges [][]faceEdge, t *tracker) { - shape, ok := s.shapes[shapeID] - if !ok { - // This shape has already been removed. - return - } - - faceEdge := faceEdge{ - shapeID: shapeID, - hasInterior: shape.Dimension() == 2, - } - - if faceEdge.hasInterior { - t.addShape(shapeID, containsBruteForce(shape, t.focus())) - } - - numEdges := shape.NumEdges() - for e := 0; e < numEdges; e++ { - edge := shape.Edge(e) - - faceEdge.edgeID = e - faceEdge.edge = edge - faceEdge.maxLevel = maxLevelForEdge(edge) - s.addFaceEdge(faceEdge, allEdges) - } -} - -// addFaceEdge adds the given faceEdge into the collection of all edges. -func (s *ShapeIndex) addFaceEdge(fe faceEdge, allEdges [][]faceEdge) { - aFace := face(fe.edge.V0.Vector) - // See if both endpoints are on the same face, and are far enough from - // the edge of the face that they don't intersect any (padded) adjacent face. - if aFace == face(fe.edge.V1.Vector) { - x, y := validFaceXYZToUV(aFace, fe.edge.V0.Vector) - fe.a = r2.Point{x, y} - x, y = validFaceXYZToUV(aFace, fe.edge.V1.Vector) - fe.b = r2.Point{x, y} - - maxUV := 1 - cellPadding - if math.Abs(fe.a.X) <= maxUV && math.Abs(fe.a.Y) <= maxUV && - math.Abs(fe.b.X) <= maxUV && math.Abs(fe.b.Y) <= maxUV { - allEdges[aFace] = append(allEdges[aFace], fe) - return - } - } - - // Otherwise, we simply clip the edge to all six faces. - for face := 0; face < 6; face++ { - if aClip, bClip, intersects := ClipToPaddedFace(fe.edge.V0, fe.edge.V1, face, cellPadding); intersects { - fe.a = aClip - fe.b = bClip - allEdges[face] = append(allEdges[face], fe) - } - } -} - -// updateFaceEdges adds or removes the various edges from the index. -// An edge is added if shapes[id] is not nil, and removed otherwise. -func (s *ShapeIndex) updateFaceEdges(face int, faceEdges []faceEdge, t *tracker) { - numEdges := len(faceEdges) - if numEdges == 0 && len(t.shapeIDs) == 0 { - return - } - - // Create the initial clippedEdge for each faceEdge. Additional clipped - // edges are created when edges are split between child cells. We create - // two arrays, one containing the edge data and another containing pointers - // to those edges, so that during the recursion we only need to copy - // pointers in order to propagate an edge to the correct child. - clippedEdges := make([]*clippedEdge, numEdges) - bound := r2.EmptyRect() - for e := 0; e < numEdges; e++ { - clipped := &clippedEdge{ - faceEdge: &faceEdges[e], - } - clipped.bound = r2.RectFromPoints(faceEdges[e].a, faceEdges[e].b) - clippedEdges[e] = clipped - bound = bound.AddRect(clipped.bound) - } - - // Construct the initial face cell containing all the edges, and then update - // all the edges in the index recursively. - faceID := CellIDFromFace(face) - pcell := PaddedCellFromCellID(faceID, cellPadding) - - disjointFromIndex := s.isFirstUpdate() - if numEdges > 0 { - shrunkID := s.shrinkToFit(pcell, bound) - if shrunkID != pcell.id { - // All the edges are contained by some descendant of the face cell. We - // can save a lot of work by starting directly with that cell, but if we - // are in the interior of at least one shape then we need to create - // index entries for the cells we are skipping over. - s.skipCellRange(faceID.RangeMin(), shrunkID.RangeMin(), t, disjointFromIndex) - pcell = PaddedCellFromCellID(shrunkID, cellPadding) - s.updateEdges(pcell, clippedEdges, t, disjointFromIndex) - s.skipCellRange(shrunkID.RangeMax().Next(), faceID.RangeMax().Next(), t, disjointFromIndex) - return - } - } - - // Otherwise (no edges, or no shrinking is possible), subdivide normally. - s.updateEdges(pcell, clippedEdges, t, disjointFromIndex) -} - -// shrinkToFit shrinks the PaddedCell to fit within the given bounds. -func (s *ShapeIndex) shrinkToFit(pcell *PaddedCell, bound r2.Rect) CellID { - shrunkID := pcell.ShrinkToFit(bound) - - if !s.isFirstUpdate() && shrunkID != pcell.CellID() { - // Don't shrink any smaller than the existing index cells, since we need - // to combine the new edges with those cells. - iter := s.Iterator() - if iter.LocateCellID(shrunkID) == Indexed { - shrunkID = iter.CellID() - } - } - return shrunkID -} - -// skipCellRange skips over the cells in the given range, creating index cells if we are -// currently in the interior of at least one shape. -func (s *ShapeIndex) skipCellRange(begin, end CellID, t *tracker, disjointFromIndex bool) { - // If we aren't in the interior of a shape, then skipping over cells is easy. - if len(t.shapeIDs) == 0 { - return - } - - // Otherwise generate the list of cell ids that we need to visit, and create - // an index entry for each one. - skipped := CellUnionFromRange(begin, end) - for _, cell := range skipped { - var clippedEdges []*clippedEdge - s.updateEdges(PaddedCellFromCellID(cell, cellPadding), clippedEdges, t, disjointFromIndex) - } -} - -// updateEdges adds or removes the given edges whose bounding boxes intersect a -// given cell. disjointFromIndex is an optimization hint indicating that cellMap -// does not contain any entries that overlap the given cell. -func (s *ShapeIndex) updateEdges(pcell *PaddedCell, edges []*clippedEdge, t *tracker, disjointFromIndex bool) { - // This function is recursive with a maximum recursion depth of 30 (maxLevel). - - // Incremental updates are handled as follows. All edges being added or - // removed are combined together in edges, and all shapes with interiors - // are tracked using tracker. We subdivide recursively as usual until we - // encounter an existing index cell. At this point we absorb the index - // cell as follows: - // - // - Edges and shapes that are being removed are deleted from edges and - // tracker. - // - All remaining edges and shapes from the index cell are added to - // edges and tracker. - // - Continue subdividing recursively, creating new index cells as needed. - // - When the recursion gets back to the cell that was absorbed, we - // restore edges and tracker to their previous state. - // - // Note that the only reason that we include removed shapes in the recursive - // subdivision process is so that we can find all of the index cells that - // contain those shapes efficiently, without maintaining an explicit list of - // index cells for each shape (which would be expensive in terms of memory). - indexCellAbsorbed := false - if !disjointFromIndex { - // There may be existing index cells contained inside pcell. If we - // encounter such a cell, we need to combine the edges being updated with - // the existing cell contents by absorbing the cell. - iter := s.Iterator() - r := iter.LocateCellID(pcell.id) - if r == Disjoint { - disjointFromIndex = true - } else if r == Indexed { - // Absorb the index cell by transferring its contents to edges and - // deleting it. We also start tracking the interior of any new shapes. - s.absorbIndexCell(pcell, iter, edges, t) - indexCellAbsorbed = true - disjointFromIndex = true - } else { - // DCHECK_EQ(SUBDIVIDED, r) - } - } - - // If there are existing index cells below us, then we need to keep - // subdividing so that we can merge with those cells. Otherwise, - // makeIndexCell checks if the number of edges is small enough, and creates - // an index cell if possible (returning true when it does so). - if !disjointFromIndex || !s.makeIndexCell(pcell, edges, t) { - // TODO(roberts): If it turns out to have memory problems when there - // are 10M+ edges in the index, look into pre-allocating space so we - // are not always appending. - childEdges := [2][2][]*clippedEdge{} // [i][j] - - // Compute the middle of the padded cell, defined as the rectangle in - // (u,v)-space that belongs to all four (padded) children. By comparing - // against the four boundaries of middle we can determine which children - // each edge needs to be propagated to. - middle := pcell.Middle() - - // Build up a vector edges to be passed to each child cell. The (i,j) - // directions are left (i=0), right (i=1), lower (j=0), and upper (j=1). - // Note that the vast majority of edges are propagated to a single child. - for _, edge := range edges { - if edge.bound.X.Hi <= middle.X.Lo { - // Edge is entirely contained in the two left children. - a, b := s.clipVAxis(edge, middle.Y) - if a != nil { - childEdges[0][0] = append(childEdges[0][0], a) - } - if b != nil { - childEdges[0][1] = append(childEdges[0][1], b) - } - } else if edge.bound.X.Lo >= middle.X.Hi { - // Edge is entirely contained in the two right children. - a, b := s.clipVAxis(edge, middle.Y) - if a != nil { - childEdges[1][0] = append(childEdges[1][0], a) - } - if b != nil { - childEdges[1][1] = append(childEdges[1][1], b) - } - } else if edge.bound.Y.Hi <= middle.Y.Lo { - // Edge is entirely contained in the two lower children. - if a := s.clipUBound(edge, 1, middle.X.Hi); a != nil { - childEdges[0][0] = append(childEdges[0][0], a) - } - if b := s.clipUBound(edge, 0, middle.X.Lo); b != nil { - childEdges[1][0] = append(childEdges[1][0], b) - } - } else if edge.bound.Y.Lo >= middle.Y.Hi { - // Edge is entirely contained in the two upper children. - if a := s.clipUBound(edge, 1, middle.X.Hi); a != nil { - childEdges[0][1] = append(childEdges[0][1], a) - } - if b := s.clipUBound(edge, 0, middle.X.Lo); b != nil { - childEdges[1][1] = append(childEdges[1][1], b) - } - } else { - // The edge bound spans all four children. The edge - // itself intersects either three or four padded children. - left := s.clipUBound(edge, 1, middle.X.Hi) - a, b := s.clipVAxis(left, middle.Y) - if a != nil { - childEdges[0][0] = append(childEdges[0][0], a) - } - if b != nil { - childEdges[0][1] = append(childEdges[0][1], b) - } - right := s.clipUBound(edge, 0, middle.X.Lo) - a, b = s.clipVAxis(right, middle.Y) - if a != nil { - childEdges[1][0] = append(childEdges[1][0], a) - } - if b != nil { - childEdges[1][1] = append(childEdges[1][1], b) - } - } - } - - // Now recursively update the edges in each child. We call the children in - // increasing order of CellID so that when the index is first constructed, - // all insertions into cellMap are at the end (which is much faster). - for pos := 0; pos < 4; pos++ { - i, j := pcell.ChildIJ(pos) - if len(childEdges[i][j]) > 0 || len(t.shapeIDs) > 0 { - s.updateEdges(PaddedCellFromParentIJ(pcell, i, j), childEdges[i][j], - t, disjointFromIndex) - } - } - } - - if indexCellAbsorbed { - // Restore the state for any edges being removed that we are tracking. - t.restoreStateBefore(s.pendingAdditionsPos) - } -} - -// makeIndexCell builds an indexCell from the given padded cell and set of edges and adds -// it to the index. If the cell or edges are empty, no cell is added. -func (s *ShapeIndex) makeIndexCell(p *PaddedCell, edges []*clippedEdge, t *tracker) bool { - // If the cell is empty, no index cell is needed. (In most cases this - // situation is detected before we get to this point, but this can happen - // when all shapes in a cell are removed.) - if len(edges) == 0 && len(t.shapeIDs) == 0 { - return true - } - - // Count the number of edges that have not reached their maximum level yet. - // Return false if there are too many such edges. - count := 0 - for _, ce := range edges { - if p.Level() < ce.faceEdge.maxLevel { - count++ - } - - if count > s.maxEdgesPerCell { - return false - } - } - - // Possible optimization: Continue subdividing as long as exactly one child - // of the padded cell intersects the given edges. This can be done by finding - // the bounding box of all the edges and calling ShrinkToFit: - // - // cellID = p.ShrinkToFit(RectBound(edges)); - // - // Currently this is not beneficial; it slows down construction by 4-25% - // (mainly computing the union of the bounding rectangles) and also slows - // down queries (since more recursive clipping is required to get down to - // the level of a spatial index cell). But it may be worth trying again - // once containsCenter is computed and all algorithms are modified to - // take advantage of it. - - // We update the InteriorTracker as follows. For every Cell in the index - // we construct two edges: one edge from entry vertex of the cell to its - // center, and one from the cell center to its exit vertex. Here entry - // and exit refer the CellID ordering, i.e. the order in which points - // are encountered along the 2 space-filling curve. The exit vertex then - // becomes the entry vertex for the next cell in the index, unless there are - // one or more empty intervening cells, in which case the InteriorTracker - // state is unchanged because the intervening cells have no edges. - - // Shift the InteriorTracker focus point to the center of the current cell. - if t.isActive && len(edges) != 0 { - if !t.atCellID(p.id) { - t.moveTo(p.EntryVertex()) - } - t.drawTo(p.Center()) - s.testAllEdges(edges, t) - } - - // Allocate and fill a new index cell. To get the total number of shapes we - // need to merge the shapes associated with the intersecting edges together - // with the shapes that happen to contain the cell center. - cshapeIDs := t.shapeIDs - numShapes := s.countShapes(edges, cshapeIDs) - cell := NewShapeIndexCell(numShapes) - - // To fill the index cell we merge the two sources of shapes: edge shapes - // (those that have at least one edge that intersects this cell), and - // containing shapes (those that contain the cell center). We keep track - // of the index of the next intersecting edge and the next containing shape - // as we go along. Both sets of shape ids are already sorted. - eNext := 0 - cNextIdx := 0 - for i := 0; i < numShapes; i++ { - var clipped *clippedShape - // advance to next value base + i - eshapeID := int32(s.Len()) - cshapeID := eshapeID // Sentinels - - if eNext != len(edges) { - eshapeID = edges[eNext].faceEdge.shapeID - } - if cNextIdx < len(cshapeIDs) { - cshapeID = cshapeIDs[cNextIdx] - } - eBegin := eNext - if cshapeID < eshapeID { - // The entire cell is in the shape interior. - clipped = newClippedShape(cshapeID, 0) - clipped.containsCenter = true - cNextIdx++ - } else { - // Count the number of edges for this shape and allocate space for them. - for eNext < len(edges) && edges[eNext].faceEdge.shapeID == eshapeID { - eNext++ - } - clipped = newClippedShape(eshapeID, eNext-eBegin) - for e := eBegin; e < eNext; e++ { - clipped.edges[e-eBegin] = edges[e].faceEdge.edgeID - } - if cshapeID == eshapeID { - clipped.containsCenter = true - cNextIdx++ - } - } - cell.shapes[i] = clipped - } - - // Add this cell to the map. - s.cellMap[p.id] = cell - s.cells = append(s.cells, p.id) - - // Shift the tracker focus point to the exit vertex of this cell. - if t.isActive && len(edges) != 0 { - t.drawTo(p.ExitVertex()) - s.testAllEdges(edges, t) - t.setNextCellID(p.id.Next()) - } - return true -} - -// updateBound updates the specified endpoint of the given clipped edge and returns the -// resulting clipped edge. -func (s *ShapeIndex) updateBound(edge *clippedEdge, uEnd int, u float64, vEnd int, v float64) *clippedEdge { - c := &clippedEdge{faceEdge: edge.faceEdge} - if uEnd == 0 { - c.bound.X.Lo = u - c.bound.X.Hi = edge.bound.X.Hi - } else { - c.bound.X.Lo = edge.bound.X.Lo - c.bound.X.Hi = u - } - - if vEnd == 0 { - c.bound.Y.Lo = v - c.bound.Y.Hi = edge.bound.Y.Hi - } else { - c.bound.Y.Lo = edge.bound.Y.Lo - c.bound.Y.Hi = v - } - - return c -} - -// clipUBound clips the given endpoint (lo=0, hi=1) of the u-axis so that -// it does not extend past the given value of the given edge. -func (s *ShapeIndex) clipUBound(edge *clippedEdge, uEnd int, u float64) *clippedEdge { - // First check whether the edge actually requires any clipping. (Sometimes - // this method is called when clipping is not necessary, e.g. when one edge - // endpoint is in the overlap area between two padded child cells.) - if uEnd == 0 { - if edge.bound.X.Lo >= u { - return edge - } - } else { - if edge.bound.X.Hi <= u { - return edge - } - } - // We interpolate the new v-value from the endpoints of the original edge. - // This has two advantages: (1) we don't need to store the clipped endpoints - // at all, just their bounding box; and (2) it avoids the accumulation of - // roundoff errors due to repeated interpolations. The result needs to be - // clamped to ensure that it is in the appropriate range. - e := edge.faceEdge - v := edge.bound.Y.ClampPoint(interpolateFloat64(u, e.a.X, e.b.X, e.a.Y, e.b.Y)) - - // Determine which endpoint of the v-axis bound to update. If the edge - // slope is positive we update the same endpoint, otherwise we update the - // opposite endpoint. - var vEnd int - positiveSlope := (e.a.X > e.b.X) == (e.a.Y > e.b.Y) - if (uEnd == 1) == positiveSlope { - vEnd = 1 - } - return s.updateBound(edge, uEnd, u, vEnd, v) -} - -// clipVBound clips the given endpoint (lo=0, hi=1) of the v-axis so that -// it does not extend past the given value of the given edge. -func (s *ShapeIndex) clipVBound(edge *clippedEdge, vEnd int, v float64) *clippedEdge { - if vEnd == 0 { - if edge.bound.Y.Lo >= v { - return edge - } - } else { - if edge.bound.Y.Hi <= v { - return edge - } - } - - // We interpolate the new v-value from the endpoints of the original edge. - // This has two advantages: (1) we don't need to store the clipped endpoints - // at all, just their bounding box; and (2) it avoids the accumulation of - // roundoff errors due to repeated interpolations. The result needs to be - // clamped to ensure that it is in the appropriate range. - e := edge.faceEdge - u := edge.bound.X.ClampPoint(interpolateFloat64(v, e.a.Y, e.b.Y, e.a.X, e.b.X)) - - // Determine which endpoint of the v-axis bound to update. If the edge - // slope is positive we update the same endpoint, otherwise we update the - // opposite endpoint. - var uEnd int - positiveSlope := (e.a.X > e.b.X) == (e.a.Y > e.b.Y) - if (vEnd == 1) == positiveSlope { - uEnd = 1 - } - return s.updateBound(edge, uEnd, u, vEnd, v) -} - -// cliupVAxis returns the given edge clipped to within the boundaries of the middle -// interval along the v-axis, and adds the result to its children. -func (s *ShapeIndex) clipVAxis(edge *clippedEdge, middle r1.Interval) (a, b *clippedEdge) { - if edge.bound.Y.Hi <= middle.Lo { - // Edge is entirely contained in the lower child. - return edge, nil - } else if edge.bound.Y.Lo >= middle.Hi { - // Edge is entirely contained in the upper child. - return nil, edge - } - // The edge bound spans both children. - return s.clipVBound(edge, 1, middle.Hi), s.clipVBound(edge, 0, middle.Lo) -} - -// absorbIndexCell absorbs an index cell by transferring its contents to edges -// and/or "tracker", and then delete this cell from the index. If edges includes -// any edges that are being removed, this method also updates their -// InteriorTracker state to correspond to the exit vertex of this cell. -func (s *ShapeIndex) absorbIndexCell(p *PaddedCell, iter *ShapeIndexIterator, edges []*clippedEdge, t *tracker) { - // When we absorb a cell, we erase all the edges that are being removed. - // However when we are finished with this cell, we want to restore the state - // of those edges (since that is how we find all the index cells that need - // to be updated). The edges themselves are restored automatically when - // UpdateEdges returns from its recursive call, but the InteriorTracker - // state needs to be restored explicitly. - // - // Here we first update the InteriorTracker state for removed edges to - // correspond to the exit vertex of this cell, and then save the - // InteriorTracker state. This state will be restored by UpdateEdges when - // it is finished processing the contents of this cell. - if t.isActive && len(edges) != 0 && s.isShapeBeingRemoved(edges[0].faceEdge.shapeID) { - // We probably need to update the tracker. ("Probably" because - // it's possible that all shapes being removed do not have interiors.) - if !t.atCellID(p.id) { - t.moveTo(p.EntryVertex()) - } - t.drawTo(p.ExitVertex()) - t.setNextCellID(p.id.Next()) - for _, edge := range edges { - fe := edge.faceEdge - if !s.isShapeBeingRemoved(fe.shapeID) { - break // All shapes being removed come first. - } - if fe.hasInterior { - t.testEdge(fe.shapeID, fe.edge) - } - } - } - - // Save the state of the edges being removed, so that it can be restored - // when we are finished processing this cell and its children. We don't - // need to save the state of the edges being added because they aren't being - // removed from "edges" and will therefore be updated normally as we visit - // this cell and its children. - t.saveAndClearStateBefore(s.pendingAdditionsPos) - - // Create a faceEdge for each edge in this cell that isn't being removed. - var faceEdges []*faceEdge - trackerMoved := false - - cell := iter.IndexCell() - for _, clipped := range cell.shapes { - shapeID := clipped.shapeID - shape := s.Shape(shapeID) - if shape == nil { - continue // This shape is being removed. - } - - numClipped := clipped.numEdges() - - // If this shape has an interior, start tracking whether we are inside the - // shape. updateEdges wants to know whether the entry vertex of this - // cell is inside the shape, but we only know whether the center of the - // cell is inside the shape, so we need to test all the edges against the - // line segment from the cell center to the entry vertex. - edge := &faceEdge{ - shapeID: shapeID, - hasInterior: shape.Dimension() == 2, - } - - if edge.hasInterior { - t.addShape(shapeID, clipped.containsCenter) - // There might not be any edges in this entire cell (i.e., it might be - // in the interior of all shapes), so we delay updating the tracker - // until we see the first edge. - if !trackerMoved && numClipped > 0 { - t.moveTo(p.Center()) - t.drawTo(p.EntryVertex()) - t.setNextCellID(p.id) - trackerMoved = true - } - } - for i := 0; i < numClipped; i++ { - edgeID := clipped.edges[i] - edge.edgeID = edgeID - edge.edge = shape.Edge(edgeID) - edge.maxLevel = maxLevelForEdge(edge.edge) - if edge.hasInterior { - t.testEdge(shapeID, edge.edge) - } - var ok bool - edge.a, edge.b, ok = ClipToPaddedFace(edge.edge.V0, edge.edge.V1, p.id.Face(), cellPadding) - if !ok { - panic("invariant failure in ShapeIndex") - } - faceEdges = append(faceEdges, edge) - } - } - // Now create a clippedEdge for each faceEdge, and put them in "new_edges". - var newEdges []*clippedEdge - for _, faceEdge := range faceEdges { - clipped := &clippedEdge{ - faceEdge: faceEdge, - bound: clippedEdgeBound(faceEdge.a, faceEdge.b, p.bound), - } - newEdges = append(newEdges, clipped) - } - - // Discard any edges from "edges" that are being removed, and append the - // remainder to "newEdges" (This keeps the edges sorted by shape id.) - for i, clipped := range edges { - if !s.isShapeBeingRemoved(clipped.faceEdge.shapeID) { - newEdges = append(newEdges, edges[i:]...) - break - } - } - - // Update the edge list and delete this cell from the index. - edges, newEdges = newEdges, edges - delete(s.cellMap, p.id) - // TODO(roberts): delete from s.Cells -} - -// testAllEdges calls the trackers testEdge on all edges from shapes that have interiors. -func (s *ShapeIndex) testAllEdges(edges []*clippedEdge, t *tracker) { - for _, edge := range edges { - if edge.faceEdge.hasInterior { - t.testEdge(edge.faceEdge.shapeID, edge.faceEdge.edge) - } - } -} - -// countShapes reports the number of distinct shapes that are either associated with the -// given edges, or that are currently stored in the InteriorTracker. -func (s *ShapeIndex) countShapes(edges []*clippedEdge, shapeIDs []int32) int { - count := 0 - lastShapeID := int32(-1) - - // next clipped shape id in the shapeIDs list. - clippedNext := int32(0) - // index of the current element in the shapeIDs list. - shapeIDidx := 0 - for _, edge := range edges { - if edge.faceEdge.shapeID == lastShapeID { - continue - } - - count++ - lastShapeID = edge.faceEdge.shapeID - - // Skip over any containing shapes up to and including this one, - // updating count as appropriate. - for ; shapeIDidx < len(shapeIDs); shapeIDidx++ { - clippedNext = shapeIDs[shapeIDidx] - if clippedNext > lastShapeID { - break - } - if clippedNext < lastShapeID { - count++ - } - } - } - - // Count any remaining containing shapes. - count += len(shapeIDs) - shapeIDidx - return count -} - -// maxLevelForEdge reports the maximum level for a given edge. -func maxLevelForEdge(edge Edge) int { - // Compute the maximum cell size for which this edge is considered long. - // The calculation does not need to be perfectly accurate, so we use Norm - // rather than Angle for speed. - cellSize := edge.V0.Sub(edge.V1.Vector).Norm() * cellSizeToLongEdgeRatio - // Now return the first level encountered during subdivision where the - // average cell size is at most cellSize. - return AvgEdgeMetric.MinLevel(cellSize) -} - -// removeShapeInternal does the actual work for removing a given shape from the index. -func (s *ShapeIndex) removeShapeInternal(removed *removedShape, allEdges [][]faceEdge, t *tracker) { - // TODO(roberts): finish the implementation of this. -} diff --git a/vendor/github.com/golang/geo/s2/shapeutil.go b/vendor/github.com/golang/geo/s2/shapeutil.go deleted file mode 100644 index 64245dfa1..000000000 --- a/vendor/github.com/golang/geo/s2/shapeutil.go +++ /dev/null @@ -1,228 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// CrossingType defines different ways of reporting edge intersections. -type CrossingType int - -const ( - // CrossingTypeInterior reports intersections that occur at a point - // interior to both edges (i.e., not at a vertex). - CrossingTypeInterior CrossingType = iota - - // CrossingTypeAll reports all intersections, even those where two edges - // intersect only because they share a common vertex. - CrossingTypeAll - - // CrossingTypeNonAdjacent reports all intersections except for pairs of - // the form (AB, BC) where both edges are from the same ShapeIndex. - CrossingTypeNonAdjacent -) - -// rangeIterator is a wrapper over ShapeIndexIterator with extra methods -// that are useful for merging the contents of two or more ShapeIndexes. -type rangeIterator struct { - it *ShapeIndexIterator - // The min and max leaf cell ids covered by the current cell. If done() is - // true, these methods return a value larger than any valid cell id. - rangeMin CellID - rangeMax CellID -} - -// newRangeIterator creates a new rangeIterator positioned at the first cell of the given index. -func newRangeIterator(index *ShapeIndex) *rangeIterator { - r := &rangeIterator{ - it: index.Iterator(), - } - r.refresh() - return r -} - -func (r *rangeIterator) cellID() CellID { return r.it.CellID() } -func (r *rangeIterator) indexCell() *ShapeIndexCell { return r.it.IndexCell() } -func (r *rangeIterator) next() { r.it.Next(); r.refresh() } -func (r *rangeIterator) done() bool { return r.it.Done() } - -// seekTo positions the iterator at the first cell that overlaps or follows -// the current range minimum of the target iterator, i.e. such that its -// rangeMax >= target.rangeMin. -func (r *rangeIterator) seekTo(target *rangeIterator) { - r.it.seek(target.rangeMin) - // If the current cell does not overlap target, it is possible that the - // previous cell is the one we are looking for. This can only happen when - // the previous cell contains target but has a smaller CellID. - if r.it.Done() || r.it.CellID().RangeMin() > target.rangeMax { - if r.it.Prev() && r.it.CellID().RangeMax() < target.cellID() { - r.it.Next() - } - } - r.refresh() -} - -// seekBeyond positions the iterator at the first cell that follows the current -// range minimum of the target iterator. i.e. the first cell such that its -// rangeMin > target.rangeMax. -func (r *rangeIterator) seekBeyond(target *rangeIterator) { - r.it.seek(target.rangeMax.Next()) - if !r.it.Done() && r.it.CellID().RangeMin() <= target.rangeMax { - r.it.Next() - } - r.refresh() -} - -// refresh updates the iterators min and max values. -func (r *rangeIterator) refresh() { - r.rangeMin = r.cellID().RangeMin() - r.rangeMax = r.cellID().RangeMax() -} - -// referencePointForShape is a helper function for implementing various Shapes -// ReferencePoint functions. -// -// Given a shape consisting of closed polygonal loops, the interior of the -// shape is defined as the region to the left of all edges (which must be -// oriented consistently). This function then chooses an arbitrary point and -// returns true if that point is contained by the shape. -// -// Unlike Loop and Polygon, this method allows duplicate vertices and -// edges, which requires some extra care with definitions. The rule that we -// apply is that an edge and its reverse edge cancel each other: the result -// is the same as if that edge pair were not present. Therefore shapes that -// consist only of degenerate loop(s) are either empty or full; by convention, -// the shape is considered full if and only if it contains an empty loop (see -// laxPolygon for details). -// -// Determining whether a loop on the sphere contains a point is harder than -// the corresponding problem in 2D plane geometry. It cannot be implemented -// just by counting edge crossings because there is no such thing as a point -// at infinity that is guaranteed to be outside the loop. -// -// This function requires that the given Shape have an interior. -func referencePointForShape(shape Shape) ReferencePoint { - if shape.NumEdges() == 0 { - // A shape with no edges is defined to be full if and only if it - // contains at least one chain. - return OriginReferencePoint(shape.NumChains() > 0) - } - // Define a "matched" edge as one that can be paired with a corresponding - // reversed edge. Define a vertex as "balanced" if all of its edges are - // matched. In order to determine containment, we must find an unbalanced - // vertex. Often every vertex is unbalanced, so we start by trying an - // arbitrary vertex. - edge := shape.Edge(0) - - if ref, ok := referencePointAtVertex(shape, edge.V0); ok { - return ref - } - - // That didn't work, so now we do some extra work to find an unbalanced - // vertex (if any). Essentially we gather a list of edges and a list of - // reversed edges, and then sort them. The first edge that appears in one - // list but not the other is guaranteed to be unmatched. - n := shape.NumEdges() - var edges = make([]Edge, n) - var revEdges = make([]Edge, n) - for i := 0; i < n; i++ { - edge := shape.Edge(i) - edges[i] = edge - revEdges[i] = Edge{V0: edge.V1, V1: edge.V0} - } - - sortEdges(edges) - sortEdges(revEdges) - - for i := 0; i < n; i++ { - if edges[i].Cmp(revEdges[i]) == -1 { // edges[i] is unmatched - if ref, ok := referencePointAtVertex(shape, edges[i].V0); ok { - return ref - } - } - if revEdges[i].Cmp(edges[i]) == -1 { // revEdges[i] is unmatched - if ref, ok := referencePointAtVertex(shape, revEdges[i].V0); ok { - return ref - } - } - } - - // All vertices are balanced, so this polygon is either empty or full except - // for degeneracies. By convention it is defined to be full if it contains - // any chain with no edges. - for i := 0; i < shape.NumChains(); i++ { - if shape.Chain(i).Length == 0 { - return OriginReferencePoint(true) - } - } - - return OriginReferencePoint(false) -} - -// referencePointAtVertex reports whether the given vertex is unbalanced, and -// returns a ReferencePoint indicating if the point is contained. -// Otherwise returns false. -func referencePointAtVertex(shape Shape, vTest Point) (ReferencePoint, bool) { - var ref ReferencePoint - - // Let P be an unbalanced vertex. Vertex P is defined to be inside the - // region if the region contains a particular direction vector starting from - // P, namely the direction p.Ortho(). This can be calculated using - // ContainsVertexQuery. - - containsQuery := NewContainsVertexQuery(vTest) - n := shape.NumEdges() - for e := 0; e < n; e++ { - edge := shape.Edge(e) - if edge.V0 == vTest { - containsQuery.AddEdge(edge.V1, 1) - } - if edge.V1 == vTest { - containsQuery.AddEdge(edge.V0, -1) - } - } - containsSign := containsQuery.ContainsVertex() - if containsSign == 0 { - return ref, false // There are no unmatched edges incident to this vertex. - } - ref.Point = vTest - ref.Contained = containsSign > 0 - - return ref, true -} - -// containsBruteForce reports whether the given shape contains the given point. -// Most clients should not use this method, since its running time is linear in -// the number of shape edges. Instead clients should create a ShapeIndex and use -// ContainsPointQuery, since this strategy is much more efficient when many -// points need to be tested. -// -// Polygon boundaries are treated as being semi-open (see ContainsPointQuery -// and VertexModel for other options). -func containsBruteForce(shape Shape, point Point) bool { - if shape.Dimension() != 2 { - return false - } - - refPoint := shape.ReferencePoint() - if refPoint.Point == point { - return refPoint.Contained - } - - crosser := NewEdgeCrosser(refPoint.Point, point) - inside := refPoint.Contained - for e := 0; e < shape.NumEdges(); e++ { - edge := shape.Edge(e) - inside = inside != crosser.EdgeOrVertexCrossing(edge.V0, edge.V1) - } - return inside -} diff --git a/vendor/github.com/golang/geo/s2/shapeutil_edge_iterator.go b/vendor/github.com/golang/geo/s2/shapeutil_edge_iterator.go deleted file mode 100644 index 2a0d82361..000000000 --- a/vendor/github.com/golang/geo/s2/shapeutil_edge_iterator.go +++ /dev/null @@ -1,72 +0,0 @@ -// Copyright 2020 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// EdgeIterator is an iterator that advances through all edges in an ShapeIndex. -// This is different to the ShapeIndexIterator, which advances through the cells in the -// ShapeIndex. -type EdgeIterator struct { - index *ShapeIndex - shapeID int32 - numEdges int32 - edgeID int32 -} - -// NewEdgeIterator creates a new edge iterator for the given index. -func NewEdgeIterator(index *ShapeIndex) *EdgeIterator { - e := &EdgeIterator{ - index: index, - shapeID: -1, - edgeID: -1, - } - - e.Next() - return e -} - -// ShapeID returns the current shape ID. -func (e *EdgeIterator) ShapeID() int32 { return e.shapeID } - -// EdgeID returns the current edge ID. -func (e *EdgeIterator) EdgeID() int32 { return e.edgeID } - -// ShapeEdgeID returns the current (shapeID, edgeID). -func (e *EdgeIterator) ShapeEdgeID() ShapeEdgeID { return ShapeEdgeID{e.shapeID, e.edgeID} } - -// Edge returns the current edge. -func (e *EdgeIterator) Edge() Edge { - return e.index.Shape(e.shapeID).Edge(int(e.edgeID)) -} - -// Done reports if the iterator is positioned at or after the last index edge. -func (e *EdgeIterator) Done() bool { return e.shapeID >= int32(len(e.index.shapes)) } - -// Next positions the iterator at the next index edge. -func (e *EdgeIterator) Next() { - e.edgeID++ - for ; e.edgeID >= e.numEdges; e.edgeID++ { - e.shapeID++ - if e.shapeID >= int32(len(e.index.shapes)) { - break - } - shape := e.index.Shape(e.shapeID) - if shape == nil { - e.numEdges = 0 - } else { - e.numEdges = int32(shape.NumEdges()) - } - e.edgeID = -1 - } -} diff --git a/vendor/github.com/golang/geo/s2/stuv.go b/vendor/github.com/golang/geo/s2/stuv.go deleted file mode 100644 index 7663bb398..000000000 --- a/vendor/github.com/golang/geo/s2/stuv.go +++ /dev/null @@ -1,427 +0,0 @@ -// Copyright 2014 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import ( - "math" - - "github.com/golang/geo/r3" -) - -// -// This file contains documentation of the various coordinate systems used -// throughout the library. Most importantly, S2 defines a framework for -// decomposing the unit sphere into a hierarchy of "cells". Each cell is a -// quadrilateral bounded by four geodesics. The top level of the hierarchy is -// obtained by projecting the six faces of a cube onto the unit sphere, and -// lower levels are obtained by subdividing each cell into four children -// recursively. Cells are numbered such that sequentially increasing cells -// follow a continuous space-filling curve over the entire sphere. The -// transformation is designed to make the cells at each level fairly uniform -// in size. -// -////////////////////////// S2 Cell Decomposition ///////////////////////// -// -// The following methods define the cube-to-sphere projection used by -// the Cell decomposition. -// -// In the process of converting a latitude-longitude pair to a 64-bit cell -// id, the following coordinate systems are used: -// -// (id) -// An CellID is a 64-bit encoding of a face and a Hilbert curve position -// on that face. The Hilbert curve position implicitly encodes both the -// position of a cell and its subdivision level (see s2cellid.go). -// -// (face, i, j) -// Leaf-cell coordinates. "i" and "j" are integers in the range -// [0,(2**30)-1] that identify a particular leaf cell on the given face. -// The (i, j) coordinate system is right-handed on each face, and the -// faces are oriented such that Hilbert curves connect continuously from -// one face to the next. -// -// (face, s, t) -// Cell-space coordinates. "s" and "t" are real numbers in the range -// [0,1] that identify a point on the given face. For example, the point -// (s, t) = (0.5, 0.5) corresponds to the center of the top-level face -// cell. This point is also a vertex of exactly four cells at each -// subdivision level greater than zero. -// -// (face, si, ti) -// Discrete cell-space coordinates. These are obtained by multiplying -// "s" and "t" by 2**31 and rounding to the nearest unsigned integer. -// Discrete coordinates lie in the range [0,2**31]. This coordinate -// system can represent the edge and center positions of all cells with -// no loss of precision (including non-leaf cells). In binary, each -// coordinate of a level-k cell center ends with a 1 followed by -// (30 - k) 0s. The coordinates of its edges end with (at least) -// (31 - k) 0s. -// -// (face, u, v) -// Cube-space coordinates in the range [-1,1]. To make the cells at each -// level more uniform in size after they are projected onto the sphere, -// we apply a nonlinear transformation of the form u=f(s), v=f(t). -// The (u, v) coordinates after this transformation give the actual -// coordinates on the cube face (modulo some 90 degree rotations) before -// it is projected onto the unit sphere. -// -// (face, u, v, w) -// Per-face coordinate frame. This is an extension of the (face, u, v) -// cube-space coordinates that adds a third axis "w" in the direction of -// the face normal. It is always a right-handed 3D coordinate system. -// Cube-space coordinates can be converted to this frame by setting w=1, -// while (u,v,w) coordinates can be projected onto the cube face by -// dividing by w, i.e. (face, u/w, v/w). -// -// (x, y, z) -// Direction vector (Point). Direction vectors are not necessarily unit -// length, and are often chosen to be points on the biunit cube -// [-1,+1]x[-1,+1]x[-1,+1]. They can be be normalized to obtain the -// corresponding point on the unit sphere. -// -// (lat, lng) -// Latitude and longitude (LatLng). Latitudes must be between -90 and -// 90 degrees inclusive, and longitudes must be between -180 and 180 -// degrees inclusive. -// -// Note that the (i, j), (s, t), (si, ti), and (u, v) coordinate systems are -// right-handed on all six faces. -// -// -// There are a number of different projections from cell-space (s,t) to -// cube-space (u,v): linear, quadratic, and tangent. They have the following -// tradeoffs: -// -// Linear - This is the fastest transformation, but also produces the least -// uniform cell sizes. Cell areas vary by a factor of about 5.2, with the -// largest cells at the center of each face and the smallest cells in -// the corners. -// -// Tangent - Transforming the coordinates via Atan makes the cell sizes -// more uniform. The areas vary by a maximum ratio of 1.4 as opposed to a -// maximum ratio of 5.2. However, each call to Atan is about as expensive -// as all of the other calculations combined when converting from points to -// cell ids, i.e. it reduces performance by a factor of 3. -// -// Quadratic - This is an approximation of the tangent projection that -// is much faster and produces cells that are almost as uniform in size. -// It is about 3 times faster than the tangent projection for converting -// cell ids to points or vice versa. Cell areas vary by a maximum ratio of -// about 2.1. -// -// Here is a table comparing the cell uniformity using each projection. Area -// Ratio is the maximum ratio over all subdivision levels of the largest cell -// area to the smallest cell area at that level, Edge Ratio is the maximum -// ratio of the longest edge of any cell to the shortest edge of any cell at -// the same level, and Diag Ratio is the ratio of the longest diagonal of -// any cell to the shortest diagonal of any cell at the same level. -// -// Area Edge Diag -// Ratio Ratio Ratio -// ----------------------------------- -// Linear: 5.200 2.117 2.959 -// Tangent: 1.414 1.414 1.704 -// Quadratic: 2.082 1.802 1.932 -// -// The worst-case cell aspect ratios are about the same with all three -// projections. The maximum ratio of the longest edge to the shortest edge -// within the same cell is about 1.4 and the maximum ratio of the diagonals -// within the same cell is about 1.7. -// -// For Go we have chosen to use only the Quadratic approach. Other language -// implementations may offer other choices. - -const ( - // maxSiTi is the maximum value of an si- or ti-coordinate. - // It is one shift more than maxSize. The range of valid (si,ti) - // values is [0..maxSiTi]. - maxSiTi = maxSize << 1 -) - -// siTiToST converts an si- or ti-value to the corresponding s- or t-value. -// Value is capped at 1.0 because there is no DCHECK in Go. -func siTiToST(si uint32) float64 { - if si > maxSiTi { - return 1.0 - } - return float64(si) / float64(maxSiTi) -} - -// stToSiTi converts the s- or t-value to the nearest si- or ti-coordinate. -// The result may be outside the range of valid (si,ti)-values. Value of -// 0.49999999999999994 (math.NextAfter(0.5, -1)), will be incorrectly rounded up. -func stToSiTi(s float64) uint32 { - if s < 0 { - return uint32(s*maxSiTi - 0.5) - } - return uint32(s*maxSiTi + 0.5) -} - -// stToUV converts an s or t value to the corresponding u or v value. -// This is a non-linear transformation from [-1,1] to [-1,1] that -// attempts to make the cell sizes more uniform. -// This uses what the C++ version calls 'the quadratic transform'. -func stToUV(s float64) float64 { - if s >= 0.5 { - return (1 / 3.) * (4*s*s - 1) - } - return (1 / 3.) * (1 - 4*(1-s)*(1-s)) -} - -// uvToST is the inverse of the stToUV transformation. Note that it -// is not always true that uvToST(stToUV(x)) == x due to numerical -// errors. -func uvToST(u float64) float64 { - if u >= 0 { - return 0.5 * math.Sqrt(1+3*u) - } - return 1 - 0.5*math.Sqrt(1-3*u) -} - -// face returns face ID from 0 to 5 containing the r. For points on the -// boundary between faces, the result is arbitrary but deterministic. -func face(r r3.Vector) int { - f := r.LargestComponent() - switch { - case f == r3.XAxis && r.X < 0: - f += 3 - case f == r3.YAxis && r.Y < 0: - f += 3 - case f == r3.ZAxis && r.Z < 0: - f += 3 - } - return int(f) -} - -// validFaceXYZToUV given a valid face for the given point r (meaning that -// dot product of r with the face normal is positive), returns -// the corresponding u and v values, which may lie outside the range [-1,1]. -func validFaceXYZToUV(face int, r r3.Vector) (float64, float64) { - switch face { - case 0: - return r.Y / r.X, r.Z / r.X - case 1: - return -r.X / r.Y, r.Z / r.Y - case 2: - return -r.X / r.Z, -r.Y / r.Z - case 3: - return r.Z / r.X, r.Y / r.X - case 4: - return r.Z / r.Y, -r.X / r.Y - } - return -r.Y / r.Z, -r.X / r.Z -} - -// xyzToFaceUV converts a direction vector (not necessarily unit length) to -// (face, u, v) coordinates. -func xyzToFaceUV(r r3.Vector) (f int, u, v float64) { - f = face(r) - u, v = validFaceXYZToUV(f, r) - return f, u, v -} - -// faceUVToXYZ turns face and UV coordinates into an unnormalized 3 vector. -func faceUVToXYZ(face int, u, v float64) r3.Vector { - switch face { - case 0: - return r3.Vector{1, u, v} - case 1: - return r3.Vector{-u, 1, v} - case 2: - return r3.Vector{-u, -v, 1} - case 3: - return r3.Vector{-1, -v, -u} - case 4: - return r3.Vector{v, -1, -u} - default: - return r3.Vector{v, u, -1} - } -} - -// faceXYZToUV returns the u and v values (which may lie outside the range -// [-1, 1]) if the dot product of the point p with the given face normal is positive. -func faceXYZToUV(face int, p Point) (u, v float64, ok bool) { - switch face { - case 0: - if p.X <= 0 { - return 0, 0, false - } - case 1: - if p.Y <= 0 { - return 0, 0, false - } - case 2: - if p.Z <= 0 { - return 0, 0, false - } - case 3: - if p.X >= 0 { - return 0, 0, false - } - case 4: - if p.Y >= 0 { - return 0, 0, false - } - default: - if p.Z >= 0 { - return 0, 0, false - } - } - - u, v = validFaceXYZToUV(face, p.Vector) - return u, v, true -} - -// faceXYZtoUVW transforms the given point P to the (u,v,w) coordinate frame of the given -// face where the w-axis represents the face normal. -func faceXYZtoUVW(face int, p Point) Point { - // The result coordinates are simply the dot products of P with the (u,v,w) - // axes for the given face (see faceUVWAxes). - switch face { - case 0: - return Point{r3.Vector{p.Y, p.Z, p.X}} - case 1: - return Point{r3.Vector{-p.X, p.Z, p.Y}} - case 2: - return Point{r3.Vector{-p.X, -p.Y, p.Z}} - case 3: - return Point{r3.Vector{-p.Z, -p.Y, -p.X}} - case 4: - return Point{r3.Vector{-p.Z, p.X, -p.Y}} - default: - return Point{r3.Vector{p.Y, p.X, -p.Z}} - } -} - -// faceSiTiToXYZ transforms the (si, ti) coordinates to a (not necessarily -// unit length) Point on the given face. -func faceSiTiToXYZ(face int, si, ti uint32) Point { - return Point{faceUVToXYZ(face, stToUV(siTiToST(si)), stToUV(siTiToST(ti)))} -} - -// xyzToFaceSiTi transforms the (not necessarily unit length) Point to -// (face, si, ti) coordinates and the level the Point is at. -func xyzToFaceSiTi(p Point) (face int, si, ti uint32, level int) { - face, u, v := xyzToFaceUV(p.Vector) - si = stToSiTi(uvToST(u)) - ti = stToSiTi(uvToST(v)) - - // If the levels corresponding to si,ti are not equal, then p is not a cell - // center. The si,ti values of 0 and maxSiTi need to be handled specially - // because they do not correspond to cell centers at any valid level; they - // are mapped to level -1 by the code at the end. - level = maxLevel - findLSBSetNonZero64(uint64(si|maxSiTi)) - if level < 0 || level != maxLevel-findLSBSetNonZero64(uint64(ti|maxSiTi)) { - return face, si, ti, -1 - } - - // In infinite precision, this test could be changed to ST == SiTi. However, - // due to rounding errors, uvToST(xyzToFaceUV(faceUVToXYZ(stToUV(...)))) is - // not idempotent. On the other hand, the center is computed exactly the same - // way p was originally computed (if it is indeed the center of a Cell); - // the comparison can be exact. - if p.Vector == faceSiTiToXYZ(face, si, ti).Normalize() { - return face, si, ti, level - } - - return face, si, ti, -1 -} - -// uNorm returns the right-handed normal (not necessarily unit length) for an -// edge in the direction of the positive v-axis at the given u-value on -// the given face. (This vector is perpendicular to the plane through -// the sphere origin that contains the given edge.) -func uNorm(face int, u float64) r3.Vector { - switch face { - case 0: - return r3.Vector{u, -1, 0} - case 1: - return r3.Vector{1, u, 0} - case 2: - return r3.Vector{1, 0, u} - case 3: - return r3.Vector{-u, 0, 1} - case 4: - return r3.Vector{0, -u, 1} - default: - return r3.Vector{0, -1, -u} - } -} - -// vNorm returns the right-handed normal (not necessarily unit length) for an -// edge in the direction of the positive u-axis at the given v-value on -// the given face. -func vNorm(face int, v float64) r3.Vector { - switch face { - case 0: - return r3.Vector{-v, 0, 1} - case 1: - return r3.Vector{0, -v, 1} - case 2: - return r3.Vector{0, -1, -v} - case 3: - return r3.Vector{v, -1, 0} - case 4: - return r3.Vector{1, v, 0} - default: - return r3.Vector{1, 0, v} - } -} - -// faceUVWAxes are the U, V, and W axes for each face. -var faceUVWAxes = [6][3]Point{ - {Point{r3.Vector{0, 1, 0}}, Point{r3.Vector{0, 0, 1}}, Point{r3.Vector{1, 0, 0}}}, - {Point{r3.Vector{-1, 0, 0}}, Point{r3.Vector{0, 0, 1}}, Point{r3.Vector{0, 1, 0}}}, - {Point{r3.Vector{-1, 0, 0}}, Point{r3.Vector{0, -1, 0}}, Point{r3.Vector{0, 0, 1}}}, - {Point{r3.Vector{0, 0, -1}}, Point{r3.Vector{0, -1, 0}}, Point{r3.Vector{-1, 0, 0}}}, - {Point{r3.Vector{0, 0, -1}}, Point{r3.Vector{1, 0, 0}}, Point{r3.Vector{0, -1, 0}}}, - {Point{r3.Vector{0, 1, 0}}, Point{r3.Vector{1, 0, 0}}, Point{r3.Vector{0, 0, -1}}}, -} - -// faceUVWFaces are the precomputed neighbors of each face. -var faceUVWFaces = [6][3][2]int{ - {{4, 1}, {5, 2}, {3, 0}}, - {{0, 3}, {5, 2}, {4, 1}}, - {{0, 3}, {1, 4}, {5, 2}}, - {{2, 5}, {1, 4}, {0, 3}}, - {{2, 5}, {3, 0}, {1, 4}}, - {{4, 1}, {3, 0}, {2, 5}}, -} - -// uvwAxis returns the given axis of the given face. -func uvwAxis(face, axis int) Point { - return faceUVWAxes[face][axis] -} - -// uvwFaces returns the face in the (u,v,w) coordinate system on the given axis -// in the given direction. -func uvwFace(face, axis, direction int) int { - return faceUVWFaces[face][axis][direction] -} - -// uAxis returns the u-axis for the given face. -func uAxis(face int) Point { - return uvwAxis(face, 0) -} - -// vAxis returns the v-axis for the given face. -func vAxis(face int) Point { - return uvwAxis(face, 1) -} - -// Return the unit-length normal for the given face. -func unitNorm(face int) Point { - return uvwAxis(face, 2) -} diff --git a/vendor/github.com/golang/geo/s2/util.go b/vendor/github.com/golang/geo/s2/util.go deleted file mode 100644 index 7cab746d8..000000000 --- a/vendor/github.com/golang/geo/s2/util.go +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -import "github.com/golang/geo/s1" - -// roundAngle returns the value rounded to nearest as an int32. -// This does not match C++ exactly for the case of x.5. -func roundAngle(val s1.Angle) int32 { - if val < 0 { - return int32(val - 0.5) - } - return int32(val + 0.5) -} - -// minAngle returns the smallest of the given values. -func minAngle(x s1.Angle, others ...s1.Angle) s1.Angle { - min := x - for _, y := range others { - if y < min { - min = y - } - } - return min -} - -// maxAngle returns the largest of the given values. -func maxAngle(x s1.Angle, others ...s1.Angle) s1.Angle { - max := x - for _, y := range others { - if y > max { - max = y - } - } - return max -} - -// minChordAngle returns the smallest of the given values. -func minChordAngle(x s1.ChordAngle, others ...s1.ChordAngle) s1.ChordAngle { - min := x - for _, y := range others { - if y < min { - min = y - } - } - return min -} - -// maxChordAngle returns the largest of the given values. -func maxChordAngle(x s1.ChordAngle, others ...s1.ChordAngle) s1.ChordAngle { - max := x - for _, y := range others { - if y > max { - max = y - } - } - return max -} - -// minFloat64 returns the smallest of the given values. -func minFloat64(x float64, others ...float64) float64 { - min := x - for _, y := range others { - if y < min { - min = y - } - } - return min -} - -// maxFloat64 returns the largest of the given values. -func maxFloat64(x float64, others ...float64) float64 { - max := x - for _, y := range others { - if y > max { - max = y - } - } - return max -} - -// minInt returns the smallest of the given values. -func minInt(x int, others ...int) int { - min := x - for _, y := range others { - if y < min { - min = y - } - } - return min -} - -// maxInt returns the largest of the given values. -func maxInt(x int, others ...int) int { - max := x - for _, y := range others { - if y > max { - max = y - } - } - return max -} - -// clampInt returns the number closest to x within the range min..max. -func clampInt(x, min, max int) int { - if x < min { - return min - } - if x > max { - return max - } - return x -} diff --git a/vendor/github.com/golang/geo/s2/wedge_relations.go b/vendor/github.com/golang/geo/s2/wedge_relations.go deleted file mode 100644 index d637bb68c..000000000 --- a/vendor/github.com/golang/geo/s2/wedge_relations.go +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package s2 - -// WedgeRel enumerates the possible relation between two wedges A and B. -type WedgeRel int - -// Define the different possible relationships between two wedges. -// -// Given an edge chain (x0, x1, x2), the wedge at x1 is the region to the -// left of the edges. More precisely, it is the set of all rays from x1x0 -// (inclusive) to x1x2 (exclusive) in the *clockwise* direction. -const ( - WedgeEquals WedgeRel = iota // A and B are equal. - WedgeProperlyContains // A is a strict superset of B. - WedgeIsProperlyContained // A is a strict subset of B. - WedgeProperlyOverlaps // A-B, B-A, and A intersect B are non-empty. - WedgeIsDisjoint // A and B are disjoint. -) - -// WedgeRelation reports the relation between two non-empty wedges -// A=(a0, ab1, a2) and B=(b0, ab1, b2). -func WedgeRelation(a0, ab1, a2, b0, b2 Point) WedgeRel { - // There are 6 possible edge orderings at a shared vertex (all - // of these orderings are circular, i.e. abcd == bcda): - // - // (1) a2 b2 b0 a0: A contains B - // (2) a2 a0 b0 b2: B contains A - // (3) a2 a0 b2 b0: A and B are disjoint - // (4) a2 b0 a0 b2: A and B intersect in one wedge - // (5) a2 b2 a0 b0: A and B intersect in one wedge - // (6) a2 b0 b2 a0: A and B intersect in two wedges - // - // We do not distinguish between 4, 5, and 6. - // We pay extra attention when some of the edges overlap. When edges - // overlap, several of these orderings can be satisfied, and we take - // the most specific. - if a0 == b0 && a2 == b2 { - return WedgeEquals - } - - // Cases 1, 2, 5, and 6 - if OrderedCCW(a0, a2, b2, ab1) { - // The cases with this vertex ordering are 1, 5, and 6, - if OrderedCCW(b2, b0, a0, ab1) { - return WedgeProperlyContains - } - - // We are in case 5 or 6, or case 2 if a2 == b2. - if a2 == b2 { - return WedgeIsProperlyContained - } - return WedgeProperlyOverlaps - - } - // We are in case 2, 3, or 4. - if OrderedCCW(a0, b0, b2, ab1) { - return WedgeIsProperlyContained - } - - if OrderedCCW(a0, b0, a2, ab1) { - return WedgeIsDisjoint - } - return WedgeProperlyOverlaps -} - -// WedgeContains reports whether non-empty wedge A=(a0, ab1, a2) contains B=(b0, ab1, b2). -// Equivalent to WedgeRelation == WedgeProperlyContains || WedgeEquals. -func WedgeContains(a0, ab1, a2, b0, b2 Point) bool { - // For A to contain B (where each loop interior is defined to be its left - // side), the CCW edge order around ab1 must be a2 b2 b0 a0. We split - // this test into two parts that test three vertices each. - return OrderedCCW(a2, b2, b0, ab1) && OrderedCCW(b0, a0, a2, ab1) -} - -// WedgeIntersects reports whether non-empty wedge A=(a0, ab1, a2) intersects B=(b0, ab1, b2). -// Equivalent but faster than WedgeRelation != WedgeIsDisjoint -func WedgeIntersects(a0, ab1, a2, b0, b2 Point) bool { - // For A not to intersect B (where each loop interior is defined to be - // its left side), the CCW edge order around ab1 must be a0 b2 b0 a2. - // Note that it's important to write these conditions as negatives - // (!OrderedCCW(a,b,c,o) rather than Ordered(c,b,a,o)) to get correct - // results when two vertices are the same. - return !(OrderedCCW(a0, b2, b0, ab1) && OrderedCCW(b0, a2, a0, ab1)) -} |