void |
S2ShapeUtil.AreaCentroidMeasure.accept(S2Point a,
S2Point b,
S2Point c) |
|
void |
S2ShapeUtil.AreaMeasure.accept(S2Point a,
S2Point b,
S2Point c) |
|
void |
S2ShapeUtil.CentroidMeasure.accept(S2Point a,
S2Point b,
S2Point c) |
|
void |
S2ShapeUtil.TriangleConsumer.accept(S2Point a,
S2Point b,
S2Point c) |
|
S2Point |
S2Point.add(S2Point p) |
Returns add(this,p).
|
static S2Point |
S2Point.add(S2Point p1,
S2Point p2) |
Returns the component-wise addition of 'p1' and 'p2'.
|
S2Point.Builder |
S2Point.Builder.add(S2Point point) |
Adds point.
|
void |
S2PointIndex.add(S2Point point,
Data data) |
|
void |
S2ShapeUtil.S2EdgeVectorShape.add(S2Point a,
S2Point b) |
Adds an edge to the vector.
|
boolean |
S2PolygonBuilder.addEdge(S2Point v0,
S2Point v1) |
Adds the given edge to the polygon builder and returns true if the edge was actually added to
the edge graph.
|
void |
S2EdgeUtil.XYZPruner.addEdgeToBounds(S2Point from,
S2Point to) |
Accumulate a bounding rectangle from provided edges.
|
void |
S2ContainsVertexQuery.addIncoming(S2Point v) |
Adds an edge from 'v' incoming to 'target'.
|
private void |
S2Polygon.EdgeClipper.addIntersection(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S2Shape bShape,
int crossing,
java.util.List<ParametrizedS2Point> intersections) |
Given two edges A and B such that robustCrossing(A, B) >= 0, determines if they intersect and
adds any intersection point to intersections .
|
void |
S2ContainsVertexQuery.addOutgoing(S2Point v) |
Adds an edge outgoing from 'target' to 'v'.
|
S2Cap |
S2Cap.addPoint(S2Point p) |
Increase the cap radius if necessary to include the given point.
|
void |
S2ConvexHullQuery.addPoint(S2Point point) |
Adds a point to the input geometry.
|
void |
S2EdgeUtil.RectBounder.addPoint(S2Point b) |
This method is called to add each vertex to the chain.
|
private void |
S2EdgeUtil.RectBounder.addPoint(S2Point b,
S2LatLng bLatLng) |
Internal implementation of addPoint that takes both the point and latLng representation, by
whichever path provided them, and expands the bounds accordingly.
|
S2LatLngRect |
S2LatLngRect.addPoint(S2Point p) |
Returns a new rectangle that includes this rectangle and the given point, expanding this
rectangle to include the point by the minimum amount possible.
|
S2LatLngRect.Builder |
S2LatLngRect.Builder.addPoint(S2Point p) |
|
(package private) boolean |
S2Point.aequal(S2Point that,
double margin) |
Compare two vectors, return true if all their components are within a difference of margin.
|
static double |
S2.angle(S2Point a,
S2Point b,
S2Point c) |
Return the angle at the vertex B in the triangle ABC.
|
double |
S2Point.angle(S2Point va) |
Return the angle between two vectors in radians
|
private static void |
S2TextFormat.appendVertex(S2Point p,
java.lang.StringBuilder out) |
|
static boolean |
S2.approxEquals(S2Point a,
S2Point b) |
|
static boolean |
S2.approxEquals(S2Point a,
S2Point b,
double maxError) |
Return true if two points are within the given distance of each other (mainly useful for
testing).
|
static double |
S2.area(S2Point a,
S2Point b,
S2Point c) |
Returns the area of triangle ABC.
|
private S2Loop |
S2PolygonBuilder.assembleLoop(S2Point v0,
S2Point v1,
java.util.List<S2Edge> unusedEdges) |
We start at the given edge and assemble a loop taking left turns whenever possible.
|
private static BigPoint |
S2Predicates.big(S2Point p) |
Returns a BigDecimal-based representation of 'p'.
|
boolean |
S2LatLngRectBase.boundaryIntersects(S2Point v0,
S2Point v1) |
Returns true if the boundary of this rectangle intersects the given geodesic edge (v0, v1).
|
(package private) boolean |
S2Loop.bruteForceContains(S2Point p) |
|
private static boolean |
S2EdgeUtil.ccw(S2Point a,
S2Point b,
S2Point c) |
Deprecated.
|
private static double |
S2Cell.chordDist2(S2Point uvw,
double u,
double v) |
Returns the squared chord distance from uvw to position uv .
|
private static S2Point |
S2Predicates.circumcenter(S2Point a,
S2Point b,
S2Point c,
double[] error) |
If triangle ABC has positive sign, returns its circumcenter.
|
(package private) static int |
S2EdgeUtil.clipDestination(S2Point a,
S2Point b,
S2Point nScaled,
S2Point aTangent,
S2Point bTangent,
double uvScale,
R2Vector uv) |
This helper function does two things.
|
void |
S2EdgeIndex.clipEdge(S2Point a0,
S2Point a1,
boolean addSharedEdges,
java.util.Collection<ParametrizedS2Point> intersections) |
Adds points where the edge index intersects the edge [a0, a1] to intersections .
|
void |
S2Polygon.EdgeClipper.clipEdge(S2Point a0,
S2Point a1,
java.util.List<ParametrizedS2Point> intersections) |
Finds all points where the polygon B intersects the edge (a0, a1), and add the corresponding
parameter values (in the range [0,1]) to intersections .
|
static boolean |
S2EdgeUtil.clipToFace(S2Point a,
S2Point b,
int face,
R2Vector aUv,
R2Vector bUv) |
Given an edge AB and a face, return the (u,v) coordinates for the portion of AB that intersects
that face.
|
static boolean |
S2EdgeUtil.clipToPaddedFace(S2Point aXyz,
S2Point bXyz,
int face,
double padding,
R2Vector aUv,
R2Vector bUv) |
As S2EdgeUtil.clipToFace(S2Point, S2Point, int, R2Vector, R2Vector) , 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).
|
(package private) static S2Point |
S2EdgeUtil.closestAcceptableEndpoint(S2Point a0,
S2Point a1,
S2Point aNorm,
S2Point b0,
S2Point b1,
S2Point bNorm,
S2Point x) |
Finds the closest acceptable endpoint to a given point.
|
private static S2Point |
S2Predicates.closestVertex(S2Point x,
S2Point a,
S2Point b,
double[] dx2) |
Returns "a" or "b", whichever is closer to "x".
|
int |
S2ConvexHullQuery.OrderedCcwAround.compare(S2Point x,
S2Point y) |
|
(package private) static int |
S2Predicates.compareDistance(S2Point x,
S2Point y,
double r2) |
Returns -1, 0, or +1 according to whether the distance XY is less than, equal to, or greater
than the squared chord distance "r2" respectively.
|
static int |
S2Predicates.compareDistances(S2Point x,
S2Point a,
S2Point b) |
Returns -1, 0, or +1 according to whether AX < BX, A == B, or AX > BX respectively.
|
(package private) static int |
S2Predicates.compareEdgeDirections(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Returns -1, 0, or +1 according to whether the normal of edge AB has negative, zero, or positive
dot product with the normal of edge CD.
|
static int |
S2Predicates.compareEdgeDistance(S2Point x,
S2Point a,
S2Point b,
double r2) |
Returns -1, 0, or +1 according to whether the distance from the point X to the edge AB is less
than, equal to, or greater than the squared chord distance "r2" respectively.
|
private static boolean |
S2EdgeUtil.compareEdges(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1) |
Returns true if (a0,a1) is less than (b0,b1) with respect to a total ordering on edges that is
invariant under edge reversals.
|
int |
S2Point.compareTo(S2Point other) |
|
private static S2CellId |
S2EdgeIndex.containingCell(S2Point pa,
S2Point pb) |
Returns the smallest cell containing both points, or Sentinel if they are not all on the same
face.
|
private static S2CellId |
S2EdgeIndex.containingCell(S2Point pa,
S2Point pb,
S2Point pc,
S2Point pd) |
Returns the smallest cell containing all four points, or S2CellId.sentinel() if they
are not all on the same face.
|
boolean |
S2Cap.contains(S2Point p) |
|
boolean |
S2Cell.contains(S2Point p) |
|
boolean |
S2CellUnion.contains(S2Point p) |
The point 'p' does not need to be normalized.
|
boolean |
S2ContainsPointQuery.contains(S2Point p) |
|
boolean |
S2LatLngRectBase.contains(S2Point p) |
The point 'p' does not need to be normalized.
|
private boolean |
S2Loop.contains(S2Iterator<S2ShapeIndex.Cell> it,
S2Point p) |
Given an iterator that is already positioned at the S2ShapeIndexCell containing p ,
returns contains(p).
|
boolean |
S2Loop.contains(S2Point p) |
Returns true if the point is contained by the loop.
|
boolean |
S2Point.contains(S2Point other) |
|
boolean |
S2PointRegion.contains(S2Point p) |
|
private boolean |
S2Polygon.contains(S2Iterator<S2ShapeIndex.Cell> it,
S2Point p) |
Given an iterator that is already positioned at the S2ShapeIndex.Cell containing p ,
return contains(p) .
|
boolean |
S2Polygon.contains(S2Point p) |
The point p does not need to be normalized.
|
boolean |
S2Polyline.contains(S2Point point) |
|
boolean |
S2Region.contains(S2Point p) |
Returns true if and only if the given point is contained by the region.
|
boolean |
S2RegionIntersection.contains(S2Point point) |
Returns true if all the regions fully contain the point.
|
boolean |
S2RegionUnion.contains(S2Point point) |
Only returns true if one of the regions contains the point.
|
boolean |
S2ShapeIndexRegion.contains(S2Point p) |
Returns true if the given point is contained by any two-dimensional shape (i.e., polygon).
|
static boolean |
S2ShapeUtil.containsBruteForce(S2Shape shape,
S2Point point) |
Returns true if the given shape contains the given point.
|
(package private) static S2Point |
S2EdgeUtil.correctIntersectionSign(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S2Point intersectionResult) |
Returns intersection result with sign corrected (if necessary).
|
private static double |
S2Predicates.cosDistance(S2Point x,
S2Point y) |
Returns cos(XY).
|
static S2Shape.ReferencePoint |
S2Shape.ReferencePoint.create(S2Point p,
boolean contained) |
Creates a referenced point at position 'p', with known containment 'contained'.
|
static <Data> S2PointIndex.Entry<Data> |
S2PointIndex.createEntry(S2Point point,
Data data) |
Convenience method to create an index entry from the given point and data value.
|
S2Point |
S2Point.crossProd(S2Point p) |
Returns crossProd(this,p).
|
static S2Point |
S2Point.crossProd(S2Point p1,
S2Point p2) |
Returns the R3 vector cross product of 'p1' and 'p2'.
|
double |
S2Point.crossProdNorm(S2Point va) |
Returns the norm of the cross product, S2Point.crossProd(this, va).norm() .
|
private static double |
S2EdgeUtil.diffMag2(S2Point a,
S2Point b) |
Returns the squared distance from a to b .
|
static S2Point |
S2Point.div(S2Point p,
double m) |
Returns the component-wise division of 'p' by 'm'.
|
(package private) java.math.BigDecimal |
BigPoint.dotProd(S2Point that) |
Returns the vector dot product of 'this' with 'that'.
|
double |
S2Point.dotProd(S2Point that) |
Returns the vector dot product of 'this' with 'that'.
|
void |
S2ShapeIndex.InteriorTracker.drawTo(S2Point focus) |
Moves the focus to the given point.
|
static int |
S2Predicates.edgeCircumcenterSign(S2Point p,
S2Point q,
S2Point a,
S2Point b,
S2Point c) |
Returns sign(P, Q, Z) where Z is the circumcenter of triangle ABC.
|
private static boolean |
S2EdgeIndex.edgeIntersectsCellBoundary(S2Point a,
S2Point b,
S2Cell cell) |
Returns true if the edge and the cell (including boundary) intersect.
|
boolean |
S2EdgeUtil.EdgeCrosser.edgeOrVertexCrossing(S2Point d) |
|
boolean |
S2EdgeUtil.EdgeCrosser.edgeOrVertexCrossing(S2Point c,
S2Point d) |
|
static boolean |
S2EdgeUtil.edgeOrVertexCrossing(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
A convenience function that calls robustCrossing() to handle cases where all four vertices are
distinct, and VertexCrossing() to handle cases where two or more vertices are the same.
|
boolean |
S2Point.equalsPoint(S2Point that) |
Returns true if this point is equal to that .
|
private void |
S2PolygonBuilder.eraseEdge(S2Point v0,
S2Point v1) |
|
static int |
S2Predicates.CompareDistance.exact(S2Point x,
S2Point y,
double r2) |
|
static int |
S2Predicates.CompareDistances.exact(S2Point x,
S2Point a,
S2Point b) |
Returns a BigDecimal-based test result, which is slow but handle all input.
|
static int |
S2Predicates.CompareEdgeDirections.exact(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Returns a BigDecimal-based test result.
|
static int |
S2Predicates.CompareEdgeDistance.exact(S2Point x,
S2Point a,
S2Point b,
double r2) |
Returns a BigDecimal-based test result, which is exact but very slow.
|
static int |
S2Predicates.EdgeCircumcenterSign.exact(S2Point p,
S2Point q,
S2Point a,
S2Point b,
S2Point c,
int abc) |
Returns a BigDecimal-based test result.
|
static int |
S2Predicates.Sign.exact(S2Point a,
S2Point b,
S2Point c,
boolean perturb) |
Computes the determinant using exact arithmetic and/or symbolic permutations.
|
static S2Predicates.Excluded |
S2Predicates.VoronoiSiteExclusion.exact(S2Point a,
S2Point b,
S2Point p,
S2Point q,
double r2) |
|
(package private) static int |
S2Predicates.CompareEdgeDistance.exactLineEndpoints(S2Point x,
S2Point a,
S2Point b,
double r2) |
Returns a BigDecimal-based test result assuming the projection of X is onto A or B.
|
static int |
S2Predicates.Sign.expensive(S2Point a,
S2Point b,
S2Point c,
boolean perturb) |
Returns the sign of the determinant using more expensive techniques.
|
static S2Point |
S2Point.fabs(S2Point p) |
Returns the component-wise absolute point from 'p'.
|
static R2Vector |
S2Projections.faceXyzToUv(int face,
S2Point p) |
If the dot product of p with the given face normal is positive, set the corresponding u and v
values (which may lie outside the range [-1,1]) and return true.
|
static S2Point |
S2Projections.faceXyzToUvw(int face,
S2Point p) |
Returns the given point P transformed to the (u,v,w) coordinate frame of the given face (where
the w-axis represents the face normal).
|
protected void |
S2EdgeIndex.findCandidateCrossings(S2Point a,
S2Point b,
java.util.List<java.lang.Integer> candidateCrossings) |
Appends to "candidateCrossings" all edge references which may cross the given edge.
|
S2ClosestPointQuery.Result<T> |
S2ClosestPointQuery.findClosestPoint(S2Point target) |
|
java.util.List<S2ClosestPointQuery.Result<T>> |
S2ClosestPointQuery.findClosestPoints(S2Point target) |
|
void |
S2ClosestPointQuery.findClosestPoints(java.util.List<S2ClosestPointQuery.Result<T>> results,
S2Point target) |
|
java.util.List<S2ClosestPointQuery.Result<T>> |
S2ClosestPointQuery.findClosestPointsToEdge(S2Point a,
S2Point b) |
Returns the closest points to the given edge AB.
|
void |
S2ClosestPointQuery.findClosestPointsToEdge(java.util.List<S2ClosestPointQuery.Result<T>> results,
S2Point a,
S2Point b) |
|
(package private) int |
S2Loop.findVertex(S2Point p) |
Return the index of a vertex at point "p", or -1 if not found.
|
static S2Cap |
S2Cap.fromAxisAngle(S2Point axis,
S1Angle angle) |
Create a cap given its axis and the cap opening angle, i.e.
|
static S2Cap |
S2Cap.fromAxisArea(S2Point axis,
double area) |
Create a cap given its axis and its area in steradians.
|
static S2Cap |
S2Cap.fromAxisChord(S2Point center,
S1ChordAngle radius) |
Creates a cap where the radius is expressed as an S1ChordAngle.
|
static S2Cap |
S2Cap.fromAxisHeight(S2Point axis,
double height) |
Create a cap given its axis and the cap height, i.e.
|
static Matrix3x3 |
Matrix3x3.fromCols(S2Point... columns) |
Constructs a matrix from a series of column vectors.
|
static S2LatLngRect |
S2LatLngRect.fromEdge(S2Point a,
S2Point b) |
Returns a latitude-longitude rectangle that contains the edge from "a" to "b".
|
(package private) static S2Point |
S2.fromFrame(Matrix3x3 frame,
S2Point q) |
Converts 'p' from the basis given in 'frame'.
|
static S2CellId |
S2CellId.fromPoint(S2Point p) |
Return the leaf cell containing the given point (a direction vector, not necessarily unit
length).
|
S1ChordAngle |
S2Cell.getBoundaryDistance(S2Point target) |
Returns the distance from the cell boundary to the given point.
|
void |
S2EdgeIndex.DataEdgeIterator.getCandidates(S2Point a,
S2Point b) |
Initializes the iterator to iterate over a set of candidates that may cross the edge (a,b).
|
java.util.Map<S2Shape,S2EdgeQuery.Edges> |
S2EdgeQuery.getCandidates(S2Point a,
S2Point b) |
Given a query edge AB, returns a map from the indexed shapes to a superset of the edges for
each shape that intersect AB.
|
S2EdgeQuery.Edges |
S2EdgeQuery.getCandidates(S2Point a,
S2Point b,
S2Shape shape) |
Given a query edge AB and a shape shape , returns a superset of the edges of
shape that intersect AB.
|
(package private) boolean |
S2EdgeQuery.getCells(S2Point a,
R2Vector aVector,
S2Point b,
R2Vector bVector,
S2PaddedCell root,
java.util.List<S2ShapeIndex.Cell> cells) |
Adds all cells to cells that might intersect the query edge from a to b
and the cell root .
|
private void |
S2EdgeQuery.getCells(S2Point a,
S2Point b) |
Sets cells to the set of index cells intersected by an edge AB.
|
boolean |
S2EdgeQuery.getCells(S2Point a,
S2Point b,
S2PaddedCell root,
java.util.List<S2ShapeIndex.Cell> cells) |
|
static S2Point |
S2EdgeUtil.getClosestPoint(S2Point x,
S2Point a,
S2Point b) |
Returns the point on edge AB closest to X.
|
static S2Point |
S2EdgeUtil.getClosestPoint(S2Point x,
S2Point a,
S2Point b,
S2Point aCrossB) |
|
java.lang.Iterable<S2Shape> |
S2ContainsPointQuery.getContainingShapes(S2Point p) |
A convenience function that returns all the shapes that contain p .
|
private int |
S2EdgeIndex.getCovering(S2Point a,
S2Point b,
boolean thickenEdge,
java.util.ArrayList<S2CellId> edgeCovering) |
Computes a cell covering of an edge.
|
java.util.Map<S2Shape,S2EdgeQuery.Edges> |
S2EdgeQuery.getCrossings(S2Point a,
S2Point b) |
Returns edges for each shape that either crosses AB or shares a vertex with AB.
|
S2EdgeQuery.Edges |
S2EdgeQuery.getCrossings(S2Point a,
S2Point b,
S2Shape shape) |
Returns edges from a given shape that either cross AB or share a vertex with AB.
|
S1ChordAngle |
S2Cell.getDistance(S2Point targetXyz) |
Returns the distance from the given point to the cell.
|
static S1ChordAngle |
S2EdgeUtil.getDistance(S2Point p,
S2Edge e) |
Gets the distance from p to e .
|
static S1Angle |
S2EdgeUtil.getDistance(S2Point x,
S2Point a,
S2Point b) |
Return the minimum distance from X to any point on the edge AB.
|
static S1Angle |
S2EdgeUtil.getDistance(S2Point x,
S2Point a,
S2Point b,
S2Point aCrossB) |
A slightly more efficient version of getDistance() where the cross product of the two endpoints
has been precomputed.
|
S1Angle |
S2Loop.getDistance(S2Point p) |
Returns the shortest distance from a point P to this loop, given as the angle formed between P,
the origin and the nearest point on the loop to P.
|
double |
S2Point.getDistance(S2Point that) |
Returns the distance in 3D coordinates from this to that.
|
S1Angle |
S2Polygon.getDistance(S2Point p) |
Returns the shortest distance from a point P to this polygon, given as the angle formed between
P, the origin, and the nearest point on the polygon to P.
|
double |
S2Point.getDistance2(S2Point that) |
Returns the square of the distance in 3D coordinates from this to that.
|
static double |
S2EdgeUtil.getDistanceFraction(S2Point x,
S2Point a0,
S2Point a1) |
Given a point X and an edge AB, return the distance ratio AX / (AX + BX).
|
private double |
S2Cell.getDistanceInternal(S2Point targetXyz,
boolean toInterior) |
Returns the chord distance to targetXyz, with interior distance 0 iff toInterior is true.
|
static double |
S2EdgeUtil.getDistanceRadians(S2Point x,
S2Point a,
S2Point b,
S2Point aCrossB) |
A more efficient version of getDistance() where the cross product of the endpoints has been
precomputed and the result is returned as a direct radian measure rather than wrapping it in an
S1Angle.
|
S1ChordAngle |
S2Cell.getDistanceToEdge(S2Point a,
S2Point b) |
Returns the minimum distance from the cell to the given edge AB, or zero if the edge intersects
the cell interior.
|
(package private) static int |
S2ShapeIndex.getEdgeMaxLevel(S2Point va,
S2Point vb,
double cellSizeToLongEdgeRatio) |
Returns the first level for which the given edge will be considered "long", i.e.
|
(package private) static void |
S2EdgeUtil.getEdgePairClosestPoints(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S2Point[] result) |
Updates the results with points that achieve the minimum distance between edges a0a1
and b0b1, where a is a point on a0a1 and b is a point on b0b1.
|
static S1ChordAngle |
S2EdgeUtil.getEdgePairDistance(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1) |
Gets distance between edges with no minimum distance.
|
static S1ChordAngle |
S2EdgeUtil.getEdgePairMaxDistance(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S1ChordAngle maxDist) |
|
static S1ChordAngle |
S2EdgeUtil.getEdgePairMinDistance(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S1ChordAngle minDist) |
|
private void |
S2EdgeIndex.getEdgesInChildrenCells(S2Point a,
S2Point b,
java.util.List<S2CellId> cover,
java.util.Set<java.lang.Integer> candidateCrossings) |
Appends to candidateCrossings the edges that are fully contained in an S2 covering of edge.
|
(package private) static int |
S2EdgeUtil.getExitAxis(S2Point n) |
Given cube face F and a directed line L (represented by its CCW normal N in the (u,v,w)
coordinates of F), compute the axis of the cube face edge where L exits the face: return 0 if L
exits through the u=-1 or u=+1 edge, and 1 if L exits through the v=-1 or v=+1 edge.
|
(package private) static void |
S2EdgeUtil.getExitPoint(S2Point n,
int axis,
R2Vector result) |
Given a cube face F, a directed line L (represented by its CCW normal N in the (u,v,w)
coordinates of F), and result of S2EdgeUtil.getExitAxis(S2Point) , set result to the (u,v)
coordinates of the point where L exits the cube face.
|
(package private) static int |
S2EdgeUtil.getFaceSegments(S2Point a,
S2Point b,
S2EdgeUtil.FaceSegment[] segments) |
Subdivide the given edge AB at every point where it crosses the boundary between two S2 cube
faces, returning the number of FaceSegments entries used (all entries must be prefilled).
|
static Matrix3x3 |
S2.getFrame(S2Point p0) |
Returns a right-handed coordinate frame (three orthonormal vectors) based on a single point,
which will become the third axis.
|
private static S1Angle |
S2LatLngRectBase.getInteriorMaxDistance(R1Interval aLat,
S2Point b) |
Return 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.
|
static S2Point |
S2EdgeUtil.getIntersection(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1) |
Given two edges AB and CD such that robustCrossing() is true, return their intersection point.
|
(package private) static S2Point |
S2EdgeUtil.getIntersection(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S2EdgeUtil.ResultError resultError) |
|
(package private) static S2Point |
S2EdgeUtil.getIntersectionApprox(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S2EdgeUtil.ResultError resultError) |
Returns the approximate intersection point of the edges (a0,a1) and (b0,b1), and writes to
resultError a bound on its error.
|
private static S2Point |
S2EdgeUtil.getIntersectionApproxSorted(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1,
S2EdgeUtil.ResultError resultError) |
Returns the approximate intersection point of the edges (a0,a1) and (b0,b1), and writes to
resultError a bound on its error.
|
(package private) static S2Point |
S2EdgeUtil.getIntersectionExact(S2Point a0,
S2Point a1,
S2Point b0,
S2Point b1) |
Compute the intersection point of (a0, a1) and (b0, b1) using exact arithmetic.
|
S1ChordAngle |
S2Cell.getMaxDistance(S2Point target) |
Returns the maximum distance from the cell (including its interior) to the given point.
|
S1ChordAngle |
S2Cell.getMaxDistance(S2Point a,
S2Point b) |
Returns the maximum distance from the cell (including its interior) to the given edge AB.
|
S1ChordAngle |
S2ClosestPointQuery.EdgeTarget.getMinDistance(S2Point x,
S1ChordAngle minDist) |
|
S1ChordAngle |
S2ClosestPointQuery.PointTarget.getMinDistance(S2Point x,
S1ChordAngle minDist) |
|
S1ChordAngle |
S2ClosestPointQuery.Target.getMinDistance(S2Point point,
S1ChordAngle distance) |
Returns the smaller of distance and a new distance from target to point .
|
int |
S2Polyline.getNearestEdgeIndex(S2Point point) |
Given a point, returns the index of the start point of the (first) edge on the polyline that is
closest to the given point.
|
(package private) static int |
S2EdgeUtil.getNextFace(int face,
R2Vector exit,
int axis,
S2Point n,
int targetFace) |
Return the next face that should be visited by getFaceSegments, 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).
|
(package private) static double |
S2EdgeUtil.getProjection(S2Point x,
S2Point aNormal,
double aNormalLen,
S2Point a0,
S2Point a1,
S2EdgeUtil.ResultError resultError) |
|
private static java.lang.Boolean |
S2ShapeUtil.getReferencePointAtVertex(S2Shape shape,
S2Point vtest) |
Returns null if 'vtest' is balanced (see definition above), otherwise 'vtest' is unbalanced and
the return value indicates whether it is contained by 'shape'.
|
static void |
S2RegionCoverer.getSimpleCovering(S2Region region,
S2Point start,
int level,
java.util.ArrayList<S2CellId> output) |
Given a connected region and a starting point, return a set of cells at the given level that
cover the region.
|
private static S2Loop |
S2ConvexHullQuery.getSingleEdgeLoop(S2Point a,
S2Point b) |
Construct a loop consisting of the two vertices and their midpoint.
|
private static S2Loop |
S2ConvexHullQuery.getSinglePointLoop(S2Point p) |
Constructs a 3-vertex polygon consisting of "p" and two nearby vertices.
|
static S2Predicates.Excluded |
S2Predicates.getVoronoiSiteExclusion(S2Point a,
S2Point b,
S2Point p,
S2Point q,
double r2) |
This is a specialized method that is used to compute the intersection of an edge PQ with the
Voronoi diagram of a set of points, where each Voronoi region is intersected with a disc of
fixed radius "r".
|
static S2EdgeUtil.WedgeRelation |
S2EdgeUtil.getWedgeRelation(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
Returns the relation from wedge A to B.
|
static double |
S2.girardArea(S2Point a,
S2Point b,
S2Point c) |
Returns the area of the triangle computed using Girard's formula.
|
boolean |
S2PolygonBuilder.hasEdge(S2Point v0,
S2Point v1) |
Returns true if the given directed edge [v0 -> v1] is present in the directed edge graph.
|
void |
S2EdgeUtil.EdgeCrosser.init(S2Point a,
S2Point b) |
|
boolean |
S2Cap.interiorContains(S2Point p) |
Return true if and only if the given point is contained in the interior of the region (i.e.
|
boolean |
S2LatLngRectBase.interiorContains(S2Point p) |
Returns true if and only if the given point is contained in the interior of the region (i.e.
|
static S2Point |
S2EdgeUtil.interpolate(double t,
S2Point a,
S2Point b) |
Return the point X along the line segment AB whose distance from A is the given fraction "t" of
the distance AB.
|
static S2Point |
S2EdgeUtil.interpolateAtDistance(S1Angle ax,
S2Point a,
S2Point b) |
|
static S2Point |
S2EdgeUtil.interpolateAtDistance(S1Angle ax,
S2Point a,
S2Point b,
S1Angle ab) |
|
boolean |
S2Cap.intersects(S2Cell cell,
S2Point[] vertices) |
Return true if the cap intersects 'cell', given that the cap vertices have already been
checked.
|
boolean |
S2EdgeUtil.LongitudePruner.intersects(S2Point v1) |
Returns true if the edge (v0, v1) intersects the given longitude interval, and then saves
'v1' to be used as the next 'v0'.
|
boolean |
S2EdgeUtil.XYZPruner.intersects(S2Point v1) |
Returns true if the edge going from the last point to this point passes through the pruner
bounding box, otherwise returns false.
|
(package private) static boolean |
S2EdgeUtil.intersectsFace(S2Point n) |
Returns true if a given directed line L intersects the cube face F.
|
static boolean |
S2LatLngRectBase.intersectsLatEdge(S2Point a,
S2Point b,
double lat,
S1Interval lng) |
Returns true if the edge AB intersects the given edge of constant latitude.
|
static boolean |
S2LatLngRectBase.intersectsLngEdge(S2Point a,
S2Point b,
R1Interval lat,
double lng) |
Returns true if the edge AB intersects the given edge of constant longitude.
|
(package private) static boolean |
S2EdgeUtil.intersectsOppositeEdges(S2Point n) |
Given a directed line L intersecting a cube face F, return true if L intersects two opposite
edges of F (including the case where L passes exactly through a corner vertex of F).
|
boolean |
S2Shape.MutableEdge.isEndpoint(S2Point point) |
Returns true iff 'point' is either endpoint of this edge.
|
static boolean |
S2.isUnitLength(S2Point p) |
Return true if the given point is approximately unit length (this is mainly useful for
assertions).
|
static S1Angle |
S2LatLng.latitude(S2Point p) |
|
static boolean |
S2EdgeUtil.lenientCrossing(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Returns true if ab possibly crosses cd, by clipping tiny angles to zero.
|
private boolean |
S2ConvexHullQuery.OrderedCcwAround.lessThan(S2Point x,
S2Point y) |
|
boolean |
S2Point.lessThan(S2Point vb) |
|
(package private) int |
S2Projections.levelIfCenter(S2Projections.FaceSiTi fst,
S2Point p) |
If p is exactly a cell center, returns the level of the cell, -1 otherwise.
|
boolean |
S2Iterator.locate(S2Point targetPoint) |
Positions the iterator at the index cell containing "target" and returns true, or if no such
cell exists in the index, the iterator is positioned arbitrarily and this method returns false.
|
static S1Angle |
S2LatLng.longitude(S2Point p) |
|
static S2Loop |
S2Loop.makeRegularLoop(S2Point center,
S1Angle radius,
int numVertices) |
Create a circle of points with a given center, radius, and number of vertices.
|
static java.util.List<S2Point> |
S2Loop.makeRegularVertices(S2Point center,
S1Angle radius,
int numVertices) |
|
static S2Point |
S2Point.minus(S2Point p1,
S2Point p2) |
Returns sub(this,p).
|
(package private) static int |
S2EdgeUtil.moveOriginToValidFace(int face,
S2Point a,
S2Point ab,
R2Vector aUv) |
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.
|
void |
S2ShapeIndex.InteriorTracker.moveTo(S2Point b) |
Moves the focus to the given point.
|
static S2Point |
S2Point.mul(S2Point p,
double m) |
Returns the component-wise multiplication of 'p' with 'm'.
|
private static S2Point |
S2Predicates.ndCross(S2Point a,
S2Point b) |
Returns (a-b).crossProd(a+b), which eliminates almost all of the error due to "x" and "y" being
not quite unit length.
|
static S2Point |
S2Point.neg(S2Point p) |
Returns the component-wise negation of 'p', i.e.
|
static S2Point |
S2Point.normalize(S2Point p) |
Returns a copy of 'p' rescaled to be unit-length.
|
static boolean |
S2Predicates.orderedCCW(S2Point a,
S2Point b,
S2Point c,
S2Point o) |
Return true if the edges OA, OB, and OC are encountered in that order while sweeping CCW around
the point O.
|
static S2Point |
S2.ortho(S2Point a) |
Returns a unit-length vector that is orthogonal to a .
|
static S2Point |
S2.planarCentroid(S2Point a,
S2Point b,
S2Point c) |
Return the centroid of the planar triangle ABC.
|
S2Point |
S2Polygon.project(S2Point p) |
Returns a point on the polygon that is closest to point P.
|
S2Point |
S2Polyline.project(S2Point queryPoint) |
Returns the point on the polyline closest to queryPoint .
|
S2Point |
S2Polyline.projectToEdge(S2Point point,
int index) |
Given a point p and the index of the start point of an edge of this polyline, returns the point
on that edge that is closest to p.
|
boolean |
S2PointIndex.remove(S2Point point,
Data data) |
|
void |
S2EdgeUtil.CloserResult.replaceIfCloser(S2Point x,
S2Point y) |
|
void |
S2EdgeUtil.EdgeCrosser.restartAt(S2Point c) |
Call this method when your chain 'jumps' to a new place.
|
int |
S2EdgeUtil.EdgeCrosser.robustCrossing(S2Point d) |
|
int |
S2EdgeUtil.EdgeCrosser.robustCrossing(S2Point c,
S2Point d) |
|
static int |
S2EdgeUtil.robustCrossing(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Like SimpleCrossing, except that points that lie exactly on a line are arbitrarily classified
as being on one side or the other (according to the rules of sign).
|
private int |
S2EdgeUtil.EdgeCrosser.robustCrossingInternal(S2Point d) |
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).
|
private int |
S2EdgeUtil.EdgeCrosser.robustCrossingInternal2(S2Point d) |
|
static S2Point |
S2.robustCrossProd(S2Point a,
S2Point b) |
Return a vector "c" that is orthogonal to the given unit-length vectors "a" and "b".
|
(package private) static S2Point |
S2.rotate(S2Point p,
Matrix3x3 r) |
Returns a normalized copy p after rotating it by the rotation matrix r .
|
S2Point |
S2Point.rotate(S2Point axis,
double radians) |
Rotates this point around an arbitrary axis.
|
static double |
S2Point.scalarTripleProduct(S2Point a,
S2Point b,
S2Point c) |
Returns the scalar triple product, a.dotProd(b.crossProd(c)) .
|
void |
S2Shape.MutableEdge.set(S2Point start,
S2Point end) |
|
void |
S2EdgeUtil.XYZPruner.setFirstIntersectPoint(S2Point v0) |
|
boolean |
S2ContainsPointQuery.S2VertexModel.shapeContains(S2Point cellCenter,
S2ShapeIndex.S2ClippedShape clipped,
S2Point p) |
Returns true if the clipped portion of a shape 'clipped' from a cell with center 'cellCenter'
contains the point 'p' according to this vertex model.
|
boolean |
S2ContainsPointQuery.shapeContains(S2Shape shape,
S2Point p) |
|
static int |
Platform.sign(S2Point a,
S2Point b,
S2Point c) |
Returns the sign of the determinant of the matrix constructed from the three column vectors
a , b , and c .
|
private static int |
S2EdgeUtil.EdgeCrosser.sign(S2Point a,
S2Point b,
S2Point c,
S2Point aCrossB) |
Helper that checks the sign of ABC, using a precomputed cross product for AxB.
|
static int |
S2Predicates.sign(S2Point a,
S2Point b,
S2Point c) |
Returns +1 if the points A, B, C are counterclockwise, -1 if the points are clockwise, and 0 if
any two points are the same.
|
static int |
S2Predicates.Sign.sign(S2Point a,
S2Point b,
S2Point c,
boolean perturb) |
Returns the sign of the turn ABC.
|
static double |
S2.signedArea(S2Point a,
S2Point b,
S2Point c) |
Like area(), but returns a positive value for counterclockwise triangles and a negative value
otherwise.
|
static boolean |
S2.simpleCrossing(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Return true if edge AB crosses CD at a point that is interior to both edges.
|
static boolean |
S2EdgeUtil.simpleCrossing(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Return true if edge AB crosses CD at a point that is interior to both edges.
|
private static double |
S2Predicates.sin2Distance(S2Point x,
S2Point y) |
Returns sin^2(XY), where XY=x.angle(y).
|
static S2Point.Shape |
S2Point.Shape.singleton(S2Point point) |
|
private S2Point |
S2PolygonBuilder.snapPointToLevel(S2Point p,
int level) |
Returns a new point, snapped to the center of the cell containing the given point at the
specified level.
|
private static S2Point |
S2Polyline.snapPointToLevel(S2Point p,
int level) |
Returns a new point, snapped to the center of the cell containing the given point at the
specified level.
|
static int |
S2Predicates.CompareDistances.sos(S2Point a,
S2Point b) |
Given that the exact test returned 0, returns a Simulation of Simplicity symbolic
perturbation-based test result to select a consistent non-zero result.
|
static int |
S2Predicates.EdgeCircumcenterSign.sos(S2Point p,
S2Point q,
S2Point a,
S2Point b,
S2Point c) |
Given the exact test resulted in 0, returns a Simulation of Simplicity-based test result,
that can only result in zero if P == Q, A == B, B == C, or C == A (the result will be nonzero
if these pairs are exactly proportional to each other but not equal.)
|
static int |
S2Predicates.Sign.stable(S2Point a,
S2Point b,
S2Point c) |
Compute the determinant in a numerically stable way.
|
S2Point |
S2Point.sub(S2Point p) |
Returns sub(this,p).
|
static S2Point |
S2Point.sub(S2Point p1,
S2Point p2) |
Returns the component-wise subtraction of 'p1' and 'p2'.
|
boolean |
S2ContainsPointQuery.EdgeVisitor.test(S2Shape shape,
int edgeId,
S2Point a,
S2Point b) |
Returns true if the next edge should be received, or false to terminate early.
|
int |
S2EdgeUtil.WedgeContains.test(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
Given two edge chains, this function returns +1 if the region to the left of A contains the
region to the left of B, and 0 otherwise.
|
int |
S2EdgeUtil.WedgeContainsOrCrosses.test(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
Given two edge chains (see WedgeRelation above), this function returns +1 if A contains B, 0
if B contains A or the two wedges do not intersect, and -1 if the edge chains A and B cross
each other (i.e.
|
int |
S2EdgeUtil.WedgeContainsOrIntersects.test(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
Given two edge chains (see WedgeRelation above), this function returns +1 if A contains B, 0
if A and B are disjoint, and -1 if A intersects but does not contain B.
|
int |
S2EdgeUtil.WedgeIntersects.test(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
Given two edge chains (see WedgeRelation above), this function returns -1 if the region to
the left of A intersects the region to the left of B, and 0 otherwise.
|
int |
S2EdgeUtil.WedgeProcessor.test(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
A wedge processor's test method accepts two edge chains A=(a0,a1,a2) and B=(b0,b1,b2) where
a1==b1, and returns either -1, 0, or 1 to indicate the relationship between the region to the
left of A and the region to the left of B.
|
void |
S2ShapeIndex.InteriorTracker.testEdge(int shapeId,
S2Point start,
S2Point end) |
Tests whether the given edge of the given shape may cross the line segment between the old
and new focus locations (see S2ShapeIndex.InteriorTracker.drawTo(S2Point) ), and if there is a crossing the
shape's containment of the focus is toggled.
|
(package private) static S2Point |
S2.toFrame(Matrix3x3 frame,
S2Point p) |
Converts 'p' to the basis given in 'frame'.
|
static java.lang.String |
S2TextFormat.toString(S2Point s2Point) |
Convert an S2Point to the S2TextFormat string representation documented above.
|
(package private) static int |
S2EdgeUtil.EdgeCrosser.triage(S2Point ab,
S2Point c) |
Returns the sign of the determinant of the column matrix ABC, given the precomputed cross
product AB.
|
static int |
S2Predicates.CompareDistance.triage(S2Point x,
S2Point y,
double r2) |
|
static int |
S2Predicates.CompareEdgeDirections.triage(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Returns a cosine-based test result.
|
static int |
S2Predicates.CompareEdgeDistance.triage(S2Point x,
S2Point a,
S2Point b,
double r2) |
Returns -1, 0, or +1 according to whether the distance from the point X to the edge AB is
less than, equal to, or greater than "r2" respectively, and may return 0 if the relation is
indeterminate.
|
static int |
S2Predicates.EdgeCircumcenterSign.triage(S2Point p,
S2Point q,
S2Point a,
S2Point b,
S2Point c,
int abc) |
Returns a double-based test result.
|
static int |
S2Predicates.Sign.triage(S2Point a,
S2Point b,
S2Point c) |
This version of Sign returns +1 if the points are definitely CCW, -1 if they are definitely
CW, and 0 if two points are identical or the result is uncertain.
|
static S2Predicates.Excluded |
S2Predicates.VoronoiSiteExclusion.triage(S2Point a,
S2Point b,
S2Point p,
S2Point q,
double r2) |
A site exclusion test using double arithmetic.
|
static int |
S2Predicates.CompareDistance.triageCos(S2Point x,
S2Point y,
double r2) |
Returns a cosine-based test result.
|
static int |
S2Predicates.CompareDistances.triageCos(S2Point x,
S2Point a,
S2Point b) |
Returns a cosine-based test result.
|
(package private) static int |
S2Predicates.CompareEdgeDistance.triageLineCos2(S2Point x,
double r2,
S2Point n,
double n1,
double n2) |
Like triageLineSin2, but this method computes the squared cosines of the distances involved.
|
(package private) static int |
S2Predicates.CompareEdgeDistance.triageLineEndpoints(S2Point x,
S2Point a,
S2Point b,
double r2) |
Returns the min test result from XA and XB, assuming the projection is A or B.
|
(package private) static int |
S2Predicates.CompareEdgeDistance.triageLineInterior(S2Point x,
S2Point a,
S2Point b,
double r2,
S2Point n,
double n1,
double n2) |
Returns the min test result from XA and XB, assuming the projection is between A and B.
|
(package private) static int |
S2Predicates.CompareEdgeDistance.triageLineSin2(S2Point x,
S2Point a,
S2Point b,
double r2,
S2Point n,
double n1,
double n2) |
Returns -1, 0, or +1 according to whether the distance from "x" to the great circle through
(a, b) is less than, equal to, or greater than the given squared chord length "r2".
|
static int |
S2Predicates.CompareDistance.triageSin2(S2Point x,
S2Point y,
double r2) |
Returns a sine-based test result, which has very good accuracy for small angles, although it
only handles angles below 90 degrees.
|
static int |
S2Predicates.CompareDistances.triageSin2(S2Point x,
S2Point a,
S2Point b) |
Returns the test result using a more accurate sine strategy, which only allows angles either
both below -90 or both above +90 degrees.
|
static S2Point |
S2.trueCentroid(S2Point a,
S2Point b) |
Returns the true centroid of the spherical geodesic edge AB multiplied by the length of the
edge AB.
|
static S2Point |
S2.trueCentroid(S2Point a,
S2Point b,
S2Point c) |
Returns the true centroid of the spherical triangle ABC multiplied by the signed area of
spherical triangle ABC.
|
static double |
S2.turnAngle(S2Point a,
S2Point b,
S2Point c) |
Returns the exterior angle at the vertex B in the triangle ABC.
|
private boolean |
S2Cell.uEdgeIsClosest(S2Point p,
boolean vEnd) |
Given a point p and either the lower or upper edge of the S2Cell (specified by
setting vEnd to false or true respectively), returns true if p is closer to the
interior of that edge than it is to either endpoint.
|
double |
S2Polyline.uninterpolate(S2Point queryPoint) |
Projects the query point to the nearest part of the polyline, and returns the fraction of the
polyline's total length traveled along the polyline from vertex 0 to the projected point.
|
static S1ChordAngle |
S2EdgeUtil.updateMaxDistance(S2Point x,
S2Point a,
S2Point b,
S1ChordAngle maxDistance) |
Returns the maximum of the distance from x to any point on edge AB and the given
maxDistance .
|
static S1ChordAngle |
S2EdgeUtil.updateMinDistance(S2Point p,
S2Edge e,
S1ChordAngle minDistance) |
Gets the minimum of the distance from a to e and minDistance .
|
static S1ChordAngle |
S2EdgeUtil.updateMinDistance(S2Point x,
S2Point a,
S2Point b,
S1ChordAngle minDistance) |
Return the minimum of the distance from x to any point on edge ab and the given
minDistance .
|
static R2Vector |
S2Projections.validFaceXyzToUv(int face,
S2Point p) |
Given a *valid* face for the given point p (meaning that dot product of p with the face normal
is positive), return the corresponding u and v values (which may lie outside the range [-1,1]).
|
(package private) static void |
S2Projections.validFaceXyzToUv(int face,
S2Point p,
R2Vector result) |
|
private boolean |
S2Cell.vEdgeIsClosest(S2Point p,
boolean uEnd) |
Given a point p and either the left or right edge of the S2Cell (specified by
setting uEnd to false or true respectively), returns true if p is closer to the
interior of that edge than it is to either endpoint.
|
private double |
S2Cell.vertexChordDist2(S2Point uvw,
S2Cell.DoubleBinaryOperator reducer) |
|
static boolean |
S2EdgeUtil.vertexCrossing(S2Point a,
S2Point b,
S2Point c,
S2Point d) |
Given two edges AB and CD where at least two vertices are identical (i.e.
|
(package private) boolean |
S2ContainsPointQuery.visitContainingShapes(S2Point p,
S2ContainsPointQuery.ShapeVisitor visitor) |
Visits each shape that contains p under the specified S2ContainsPointQuery.S2VertexModel exactly
once, and returns true, or terminates early and returns false if any invocation of ShapeVisitor#apply(S2Shape) returns false.
|
(package private) boolean |
S2ContainsPointQuery.visitIncidentEdges(S2Point p,
S2ContainsPointQuery.EdgeVisitor visitor,
S2Shape.MutableEdge tmp) |
Visits each edge in the index that is incident to p exactly once, and returns true, or
terminates early and returns false if visitor returns false.
|
(package private) static boolean |
S2Loop.wedgeContainsSemiwedge(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b2,
boolean bReversed) |
Returns true if the wedge (a0, ab1, a2) contains the edge (ab1, b2), where [a0, ab1, a2] are a
subset of the vertices of loop A, and [ab1, ab2, b2] are a subset of the vertices of loop B.
|
boolean |
S2Loop.CompareBoundaryRelation.wedgesCross(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
|
boolean |
S2Loop.ContainsRelation.wedgesCross(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
|
boolean |
S2Loop.IntersectsRelation.wedgesCross(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
|
boolean |
S2Loop.LoopRelation.wedgesCross(S2Point a0,
S2Point ab1,
S2Point a2,
S2Point b0,
S2Point b2) |
Given a vertex ab1 that is shared between the two loops, returns true if the two
associated wedges (a0, ab1, b2) and (b0, ab1, b2) are equivalent to an edge crossing.
|
static int |
S2Projections.xyzToFace(S2Point p) |
Returns the face containing the given direction vector (for points on the boundary between
faces, the result is arbitrary but repeatable.)
|
(package private) S2Projections.FaceSiTi |
S2Projections.xyzToFaceSiTi(S2Point p) |
Convert a direction vector (not necessarily unit length) to (face, si, ti) coordinates.
|
double |
S2Projections.UvTransform.xyzToU(S2Point p) |
Returns the 'u' coordinate of the [u, v] point projected onto a cube face from the given [x,
y, z] position.
|
double |
S2Projections.UvTransform.xyzToV(S2Point p) |
Returns the 'v' coordinate of the [u, v] point projected onto a cube face from the given [x,
y, z] position.
|