private static S1ChordAngle GetMaxDistanceToEdgeBruteForce(S2Cell cell, S2Point a, S2Point b)
{
// If any antipodal endpoint is within the cell, the max distance is Pi.
if (cell.Contains(-a) || cell.Contains(-b))
{
return(S1ChordAngle.Straight);
}
S1ChordAngle max_dist = S1ChordAngle.Negative;
for (int i = 0; i < 4; ++i)
{
S2Point v0 = cell.Vertex(i);
S2Point v1 = cell.Vertex(i + 1);
// If the antipodal edge crosses through the cell, max distance is Pi.
if (S2.CrossingSign(-a, -b, v0, v1) >= 0)
{
return(S1ChordAngle.Straight);
}
S2.UpdateMaxDistance(a, v0, v1, ref max_dist);
S2.UpdateMaxDistance(b, v0, v1, ref max_dist);
S2.UpdateMaxDistance(v0, a, b, ref max_dist);
}
return(max_dist);
}
private static S1ChordAngle GetDistanceToEdgeBruteForce(S2Cell cell, S2Point a, S2Point b)
{
if (cell.Contains(a) || cell.Contains(b))
{
return(S1ChordAngle.Zero);
}
S1ChordAngle min_dist = S1ChordAngle.Infinity;
for (int i = 0; i < 4; ++i)
{
S2Point v0 = cell.Vertex(i);
S2Point v1 = cell.Vertex(i + 1);
// If the edge crosses through the cell, max distance is 0.
if (S2.CrossingSign(a, b, v0, v1) >= 0)
{
return(S1ChordAngle.Zero);
}
S2.UpdateMinDistance(a, v0, v1, ref min_dist);
S2.UpdateMinDistance(b, v0, v1, ref min_dist);
S2.UpdateMinDistance(v0, a, b, ref min_dist);
}
return(min_dist);
}
private static S1ChordAngle GetMaxDistanceToPointBruteForce(S2Cell cell, S2Point target)
{
if (cell.Contains(-target))
{
return(S1ChordAngle.Straight);
}
S1ChordAngle max_distance = S1ChordAngle.Negative;
for (int i = 0; i < 4; ++i)
{
S2.UpdateMaxDistance(target, cell.Vertex(i),
cell.Vertex(i + 1), ref max_distance);
}
return(max_distance);
}
public void testCellOps(S2LatLngRect r, S2Cell cell, int level)
{
// Test the relationship between the given rectangle and cell:
// 0 == no intersection, 1 == MayIntersect, 2 == Intersects,
// 3 == Vertex Containment, 4 == Contains
var vertexContained = false;
for (var i = 0; i < 4; ++i)
{
if (r.Contains(cell.GetVertexRaw(i))
|| (!r.IsEmpty && cell.Contains(r.GetVertex(i).ToPoint())))
{
vertexContained = true;
}
}
assertEquals(r.MayIntersect(cell), level >= 1);
assertEquals(r.Intersects(cell), level >= 2);
assertEquals(vertexContained, level >= 3);
assertEquals(r.Contains(cell), level >= 4);
}
private static void TestCellOps(S2LatLngRect r, S2Cell cell, int level)
{
// Test the relationship between the given rectangle and cell:
// 0 == no intersection, 1 == MayIntersect, 2 == Intersects,
// 3 == Vertex Containment, 4 == Contains
bool vertex_contained = false;
for (int i = 0; i < 4; ++i)
{
if (r.Contains(cell.VertexRaw(i)) ||
(!r.IsEmpty() && cell.Contains(r.Vertex(i).ToPoint())))
{
vertex_contained = true;
}
}
Assert.Equal(r.MayIntersect(cell), level >= 1);
Assert.Equal(r.Intersects(cell), level >= 2);
Assert.Equal(vertex_contained, level >= 3);
Assert.Equal(r.Contains(cell), level >= 4);
}
public void testCellOps(S2LatLngRect r, S2Cell cell, int level)
{
// Test the relationship between the given rectangle and cell:
// 0 == no intersection, 1 == MayIntersect, 2 == Intersects,
// 3 == Vertex Containment, 4 == Contains
var vertexContained = false;
for (var i = 0; i < 4; ++i)
{
if (r.Contains(cell.GetVertexRaw(i)) ||
(!r.IsEmpty && cell.Contains(r.GetVertex(i).ToPoint())))
{
vertexContained = true;
}
}
assertEquals(r.MayIntersect(cell), level >= 1);
assertEquals(r.Intersects(cell), level >= 2);
assertEquals(vertexContained, level >= 3);
assertEquals(r.Contains(cell), level >= 4);
}
public void testSubdivide(S2Cell cell)
{
gatherStats(cell);
if (cell.IsLeaf)
{
return;
}
var children = new S2Cell[4];
for (var i = 0; i < children.Length; ++i)
{
children[i] = new S2Cell();
}
Assert.True(cell.Subdivide(children));
var childId = cell.Id.ChildBegin;
double exactArea = 0;
double approxArea = 0;
double averageArea = 0;
for (var i = 0; i < 4; ++i, childId = childId.Next)
{
exactArea += children[i].ExactArea();
approxArea += children[i].ApproxArea();
averageArea += children[i].AverageArea();
// Check that the child geometry is consistent with its cell id.
JavaAssert.Equal(children[i].Id, childId);
Assert.True(children[i].Center.ApproxEquals(childId.ToPoint(), 1e-15));
var direct = new S2Cell(childId);
JavaAssert.Equal(children[i].Face, direct.Face);
JavaAssert.Equal(children[i].Level, direct.Level);
JavaAssert.Equal(children[i].Orientation, direct.Orientation);
JavaAssert.Equal(children[i].CenterRaw, direct.CenterRaw);
for (var k = 0; k < 4; ++k)
{
JavaAssert.Equal(children[i].GetVertexRaw(k), direct.GetVertexRaw(k));
JavaAssert.Equal(children[i].GetEdgeRaw(k), direct.GetEdgeRaw(k));
}
// Test Contains() and MayIntersect().
Assert.True(cell.Contains(children[i]));
Assert.True(cell.MayIntersect(children[i]));
Assert.True(!children[i].Contains(cell));
Assert.True(cell.Contains(children[i].CenterRaw));
for (var j = 0; j < 4; ++j)
{
Assert.True(cell.Contains(children[i].GetVertexRaw(j)));
if (j != i)
{
Assert.True(!children[i].Contains(children[j].CenterRaw));
Assert.True(!children[i].MayIntersect(children[j]));
}
}
// Test GetCapBound and GetRectBound.
var parentCap = cell.CapBound;
var parentRect = cell.RectBound;
if (cell.Contains(new S2Point(0, 0, 1)) ||
cell.Contains(new S2Point(0, 0, -1)))
{
Assert.True(parentRect.Lng.IsFull);
}
var childCap = children[i].CapBound;
var childRect = children[i].RectBound;
Assert.True(childCap.Contains(children[i].Center));
Assert.True(childRect.Contains(children[i].CenterRaw));
Assert.True(parentCap.Contains(children[i].Center));
Assert.True(parentRect.Contains(children[i].CenterRaw));
for (var j = 0; j < 4; ++j)
{
Assert.True(childCap.Contains(children[i].GetVertex(j)));
Assert.True(childRect.Contains(children[i].GetVertex(j)));
Assert.True(childRect.Contains(children[i].GetVertexRaw(j)));
Assert.True(parentCap.Contains(children[i].GetVertex(j)));
if (!parentRect.Contains(children[i].GetVertex(j)))
{
Console.WriteLine("cell: " + cell + " i: " + i + " j: " + j);
Console.WriteLine("Children " + i + ": " + children[i]);
Console.WriteLine("Parent rect: " + parentRect);
Console.WriteLine("Vertex raw(j) " + children[i].GetVertex(j));
Console.WriteLine("Latlng of vertex: " + new S2LatLng(children[i].GetVertex(j)));
Console.WriteLine("RectBound: " + cell.RectBound);
}
Assert.True(parentRect.Contains(children[i].GetVertex(j)));
if (!parentRect.Contains(children[i].GetVertexRaw(j)))
{
Console.WriteLine("cell: " + cell + " i: " + i + " j: " + j);
Console.WriteLine("Children " + i + ": " + children[i]);
Console.WriteLine("Parent rect: " + parentRect);
Console.WriteLine("Vertex raw(j) " + children[i].GetVertexRaw(j));
Console.WriteLine("Latlng of vertex: " + new S2LatLng(children[i].GetVertexRaw(j)));
Console.WriteLine("RectBound: " + cell.RectBound);
}
Assert.True(parentRect.Contains(children[i].GetVertexRaw(j)));
if (j != i)
{
// The bounding caps and rectangles should be tight enough so that
// they exclude at least two vertices of each adjacent cell.
var capCount = 0;
var rectCount = 0;
for (var k = 0; k < 4; ++k)
{
if (childCap.Contains(children[j].GetVertex(k)))
{
++capCount;
}
if (childRect.Contains(children[j].GetVertexRaw(k)))
{
++rectCount;
}
}
Assert.True(capCount <= 2);
if (childRect.LatLo.Radians > -S2.PiOver2 &&
childRect.LatHi.Radians < S2.PiOver2)
{
// Bounding rectangles may be too large at the poles because the
// pole itself has an arbitrary fixed longitude.
Assert.True(rectCount <= 2);
}
}
}
// Check all children for the first few levels, and then sample randomly.
// Also subdivide one corner cell, one edge cell, and one center cell
// so that we have a better chance of sample the minimum metric values.
var forceSubdivide = false;
var center = S2Projections.GetNorm(children[i].Face);
var edge = center + S2Projections.GetUAxis(children[i].Face);
var corner = edge + S2Projections.GetVAxis(children[i].Face);
for (var j = 0; j < 4; ++j)
{
var p = children[i].GetVertexRaw(j);
if (p.Equals(center) || p.Equals(edge) || p.Equals(corner))
{
forceSubdivide = true;
}
}
if (forceSubdivide || cell.Level < (DEBUG_MODE ? 5 : 6) ||
random(DEBUG_MODE ? 10 : 4) == 0)
{
testSubdivide(children[i]);
}
}
// Check sum of child areas equals parent area.
//
// For ExactArea(), the best relative error we can expect is about 1e-6
// because the precision of the unit vector coordinates is only about 1e-15
// and the edge length of a leaf cell is about 1e-9.
//
// For ApproxArea(), the areas are accurate to within a few percent.
//
// For AverageArea(), the areas themselves are not very accurate, but
// the average area of a parent is exactly 4 times the area of a child.
Assert.True(Math.Abs(Math.Log(exactArea / cell.ExactArea())) <= Math
.Abs(Math.Log(1 + 1e-6)));
Assert.True(Math.Abs(Math.Log(approxArea / cell.ApproxArea())) <= Math
.Abs(Math.Log(1.03)));
Assert.True(Math.Abs(Math.Log(averageArea / cell.AverageArea())) <= Math
.Abs(Math.Log(1 + 1e-15)));
}
static void TestSubdivide(S2Cell cell)
{
GatherStats(cell);
if (cell.IsLeaf())
{
return;
}
var children = new S2Cell[4];
Assert.True(cell.Subdivide(children));
S2CellId child_id = cell.Id.ChildBegin();
double exact_area = 0;
double approx_area = 0;
double average_area = 0;
for (int i = 0; i < 4; ++i, child_id = child_id.Next())
{
exact_area += children[i].ExactArea();
approx_area += children[i].ApproxArea();
average_area += children[i].AverageArea();
// Check that the child geometry is consistent with its cell ID.
Assert.Equal(child_id, children[i].Id);
Assert.True(S2.ApproxEquals(children[i].Center(), child_id.ToPoint()));
S2Cell direct = new(child_id);
Assert.Equal(direct.Face, children[i].Face);
Assert.Equal(direct.Level, children[i].Level);
Assert.Equal(direct.Orientation, children[i].Orientation);
Assert.Equal(direct.CenterRaw(), children[i].CenterRaw());
for (int k = 0; k < 4; ++k)
{
Assert.Equal(direct.VertexRaw(k), children[i].VertexRaw(k));
Assert.Equal(direct.EdgeRaw(k), children[i].EdgeRaw(k));
}
// Test Contains() and MayIntersect().
Assert.True(cell.Contains(children[i]));
Assert.True(cell.MayIntersect(children[i]));
Assert.False(children[i].Contains(cell));
Assert.True(cell.Contains(children[i].CenterRaw()));
for (int j = 0; j < 4; ++j)
{
Assert.True(cell.Contains(children[i].VertexRaw(j)));
if (j != i)
{
Assert.False(children[i].Contains(children[j].CenterRaw()));
Assert.False(children[i].MayIntersect(children[j]));
}
}
// Test GetCapBound and GetRectBound.
S2Cap parent_cap = cell.GetCapBound();
S2LatLngRect parent_rect = cell.GetRectBound();
if (cell.Contains(new S2Point(0, 0, 1)) || cell.Contains(new S2Point(0, 0, -1)))
{
Assert.True(parent_rect.Lng.IsFull());
}
S2Cap child_cap = children[i].GetCapBound();
S2LatLngRect child_rect = children[i].GetRectBound();
Assert.True(child_cap.Contains(children[i].Center()));
Assert.True(child_rect.Contains(children[i].CenterRaw()));
Assert.True(parent_cap.Contains(children[i].Center()));
Assert.True(parent_rect.Contains(children[i].CenterRaw()));
for (int j = 0; j < 4; ++j)
{
Assert.True(child_cap.Contains(children[i].Vertex(j)));
Assert.True(child_rect.Contains(children[i].Vertex(j)));
Assert.True(child_rect.Contains(children[i].VertexRaw(j)));
Assert.True(parent_cap.Contains(children[i].Vertex(j)));
Assert.True(parent_rect.Contains(children[i].Vertex(j)));
Assert.True(parent_rect.Contains(children[i].VertexRaw(j)));
if (j != i)
{
// The bounding caps and rectangles should be tight enough so that
// they exclude at least two vertices of each adjacent cell.
int cap_count = 0;
int rect_count = 0;
for (int k = 0; k < 4; ++k)
{
if (child_cap.Contains(children[j].Vertex(k)))
{
++cap_count;
}
if (child_rect.Contains(children[j].VertexRaw(k)))
{
++rect_count;
}
}
Assert.True(cap_count <= 2);
if (child_rect.LatLo().Radians > -S2.M_PI_2 &&
child_rect.LatHi().Radians < S2.M_PI_2)
{
// Bounding rectangles may be too large at the poles because the
// pole itself has an arbitrary fixed longitude.
Assert.True(rect_count <= 2);
}
}
}
// Check all children for the first few levels, and then sample randomly.
// We also always subdivide the cells containing a few chosen points so
// that we have a better chance of sampling the minimum and maximum metric
// values. kMaxSizeUV is the absolute value of the u- and v-coordinate
// where the cell size at a given level is maximal.
double kMaxSizeUV = 0.3964182625366691;
R2Point[] special_uv =
{
new R2Point(S2.DoubleEpsilon, S2.DoubleEpsilon), // Face center
new R2Point(S2.DoubleEpsilon, 1), // Edge midpoint
new R2Point(1, 1), // Face corner
new R2Point(kMaxSizeUV, kMaxSizeUV), // Largest cell area
new R2Point(S2.DoubleEpsilon, kMaxSizeUV), // Longest edge/diagonal
};
bool force_subdivide = false;
foreach (R2Point uv in special_uv)
{
if (children[i].BoundUV.Contains(uv))
{
force_subdivide = true;
}
}
var debugFlag =
#if s2debug
true;
#else
false;
#endif
if (force_subdivide ||
cell.Level < (debugFlag ? 5 : 6) ||
S2Testing.Random.OneIn(debugFlag ? 5 : 4))
{
TestSubdivide(children[i]);
}
}
// Check sum of child areas equals parent area.
//
// For ExactArea(), the best relative error we can expect is about 1e-6
// because the precision of the unit vector coordinates is only about 1e-15
// and the edge length of a leaf cell is about 1e-9.
//
// For ApproxArea(), the areas are accurate to within a few percent.
//
// For AverageArea(), the areas themselves are not very accurate, but
// the average area of a parent is exactly 4 times the area of a child.
Assert.True(Math.Abs(Math.Log(exact_area / cell.ExactArea())) <= Math.Abs(Math.Log((1 + 1e-6))));
Assert.True(Math.Abs(Math.Log((approx_area / cell.ApproxArea()))) <= Math.Abs(Math.Log((1.03))));
Assert.True(Math.Abs(Math.Log((average_area / cell.AverageArea()))) <= Math.Abs(Math.Log((1 + 1e-15))));
}
public void testSubdivide(S2Cell cell)
{
gatherStats(cell);
if (cell.IsLeaf)
{
return;
}
var children = new S2Cell[4];
for (var i = 0; i < children.Length; ++i)
{
children[i] = new S2Cell();
}
Assert.True(cell.Subdivide(children));
var childId = cell.Id.ChildBegin;
double exactArea = 0;
double approxArea = 0;
double averageArea = 0;
for (var i = 0; i < 4; ++i, childId = childId.Next)
{
exactArea += children[i].ExactArea();
approxArea += children[i].ApproxArea();
averageArea += children[i].AverageArea();
// Check that the child geometry is consistent with its cell id.
JavaAssert.Equal(children[i].Id, childId);
Assert.True(children[i].Center.ApproxEquals(childId.ToPoint(), 1e-15));
var direct = new S2Cell(childId);
JavaAssert.Equal(children[i].Face, direct.Face);
JavaAssert.Equal(children[i].Level, direct.Level);
JavaAssert.Equal(children[i].Orientation, direct.Orientation);
JavaAssert.Equal(children[i].CenterRaw, direct.CenterRaw);
for (var k = 0; k < 4; ++k)
{
JavaAssert.Equal(children[i].GetVertexRaw(k), direct.GetVertexRaw(k));
JavaAssert.Equal(children[i].GetEdgeRaw(k), direct.GetEdgeRaw(k));
}
// Test Contains() and MayIntersect().
Assert.True(cell.Contains(children[i]));
Assert.True(cell.MayIntersect(children[i]));
Assert.True(!children[i].Contains(cell));
Assert.True(cell.Contains(children[i].CenterRaw));
for (var j = 0; j < 4; ++j)
{
Assert.True(cell.Contains(children[i].GetVertexRaw(j)));
if (j != i)
{
Assert.True(!children[i].Contains(children[j].CenterRaw));
Assert.True(!children[i].MayIntersect(children[j]));
}
}
// Test GetCapBound and GetRectBound.
var parentCap = cell.CapBound;
var parentRect = cell.RectBound;
if (cell.Contains(new S2Point(0, 0, 1))
|| cell.Contains(new S2Point(0, 0, -1)))
{
Assert.True(parentRect.Lng.IsFull);
}
var childCap = children[i].CapBound;
var childRect = children[i].RectBound;
Assert.True(childCap.Contains(children[i].Center));
Assert.True(childRect.Contains(children[i].CenterRaw));
Assert.True(parentCap.Contains(children[i].Center));
Assert.True(parentRect.Contains(children[i].CenterRaw));
for (var j = 0; j < 4; ++j)
{
Assert.True(childCap.Contains(children[i].GetVertex(j)));
Assert.True(childRect.Contains(children[i].GetVertex(j)));
Assert.True(childRect.Contains(children[i].GetVertexRaw(j)));
Assert.True(parentCap.Contains(children[i].GetVertex(j)));
if (!parentRect.Contains(children[i].GetVertex(j)))
{
Console.WriteLine("cell: " + cell + " i: " + i + " j: " + j);
Console.WriteLine("Children " + i + ": " + children[i]);
Console.WriteLine("Parent rect: " + parentRect);
Console.WriteLine("Vertex raw(j) " + children[i].GetVertex(j));
Console.WriteLine("Latlng of vertex: " + new S2LatLng(children[i].GetVertex(j)));
Console.WriteLine("RectBound: " + cell.RectBound);
}
Assert.True(parentRect.Contains(children[i].GetVertex(j)));
if (!parentRect.Contains(children[i].GetVertexRaw(j)))
{
Console.WriteLine("cell: " + cell + " i: " + i + " j: " + j);
Console.WriteLine("Children " + i + ": " + children[i]);
Console.WriteLine("Parent rect: " + parentRect);
Console.WriteLine("Vertex raw(j) " + children[i].GetVertexRaw(j));
Console.WriteLine("Latlng of vertex: " + new S2LatLng(children[i].GetVertexRaw(j)));
Console.WriteLine("RectBound: " + cell.RectBound);
}
Assert.True(parentRect.Contains(children[i].GetVertexRaw(j)));
if (j != i)
{
// The bounding caps and rectangles should be tight enough so that
// they exclude at least two vertices of each adjacent cell.
var capCount = 0;
var rectCount = 0;
for (var k = 0; k < 4; ++k)
{
if (childCap.Contains(children[j].GetVertex(k)))
{
++capCount;
}
if (childRect.Contains(children[j].GetVertexRaw(k)))
{
++rectCount;
}
}
Assert.True(capCount <= 2);
if (childRect.LatLo.Radians > -S2.PiOver2
&& childRect.LatHi.Radians < S2.PiOver2)
{
// Bounding rectangles may be too large at the poles because the
// pole itself has an arbitrary fixed longitude.
Assert.True(rectCount <= 2);
}
}
}
// Check all children for the first few levels, and then sample randomly.
// Also subdivide one corner cell, one edge cell, and one center cell
// so that we have a better chance of sample the minimum metric values.
var forceSubdivide = false;
var center = S2Projections.GetNorm(children[i].Face);
var edge = center + S2Projections.GetUAxis(children[i].Face);
var corner = edge + S2Projections.GetVAxis(children[i].Face);
for (var j = 0; j < 4; ++j)
{
var p = children[i].GetVertexRaw(j);
if (p.Equals(center) || p.Equals(edge) || p.Equals(corner))
{
forceSubdivide = true;
}
}
if (forceSubdivide || cell.Level < (DEBUG_MODE ? 5 : 6)
|| random(DEBUG_MODE ? 10 : 4) == 0)
{
testSubdivide(children[i]);
}
}
// Check sum of child areas equals parent area.
//
// For ExactArea(), the best relative error we can expect is about 1e-6
// because the precision of the unit vector coordinates is only about 1e-15
// and the edge length of a leaf cell is about 1e-9.
//
// For ApproxArea(), the areas are accurate to within a few percent.
//
// For AverageArea(), the areas themselves are not very accurate, but
// the average area of a parent is exactly 4 times the area of a child.
Assert.True(Math.Abs(Math.Log(exactArea/cell.ExactArea())) <= Math
.Abs(Math.Log(1 + 1e-6)));
Assert.True(Math.Abs(Math.Log(approxArea/cell.ApproxArea())) <= Math
.Abs(Math.Log(1.03)));
Assert.True(Math.Abs(Math.Log(averageArea/cell.AverageArea())) <= Math
.Abs(Math.Log(1 + 1e-15)));
}
