public void Test_S2ShapeIndexRegion_GetCapBound()
{
var id = S2CellId.FromDebugString("3/0123012301230123012301230123");
// Add a polygon that is slightly smaller than the cell being tested.
MutableS2ShapeIndex index = new();
index.Add(NewPaddedCell(id, -kPadding));
S2Cap cell_bound = new S2Cell(id).GetCapBound();
S2Cap index_bound = index.MakeS2ShapeIndexRegion().GetCapBound();
Assert.True(index_bound.Contains(cell_bound));
// Note that S2CellUnion.GetCapBound returns a slightly larger bound than
// S2Cell.GetBound even when the cell union consists of a single S2CellId.
Assert.True(index_bound.RadiusAngle() <= 1.00001 * cell_bound.RadiusAngle());
}
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 Test_S2Cap_Basic()
{
// Test basic properties of empty and full caps.
S2Cap empty = S2Cap.Empty;
S2Cap full = S2Cap.Full;
Assert.True(empty.IsValid());
Assert.True(empty.IsEmpty());
Assert.True(empty.Complement().IsFull());
Assert.True(full.IsValid());
Assert.True(full.IsFull());
Assert.True(full.Complement().IsEmpty());
Assert.Equal(2, full.Height());
Assert2.DoubleEqual(180.0, full.Radius.Degrees());
// Test ==/!=.
Assert.Equal(full, full);
Assert.Equal(empty, empty);
Assert.NotEqual(full, empty);
// Test the S1Angle constructor using out-of-range arguments.
Assert.True(new S2Cap(new S2Point(1, 0, 0), S1Angle.FromRadians(-20)).IsEmpty());
Assert.True(new S2Cap(new S2Point(1, 0, 0), S1Angle.FromRadians(5)).IsFull());
Assert.True(new S2Cap(new S2Point(1, 0, 0), S1Angle.Infinity).IsFull());
// Check that the default S2Cap is identical to Empty().
var default_empty = S2Cap.Empty;
Assert.True(default_empty.IsValid());
Assert.True(default_empty.IsEmpty());
Assert.Equal(empty.Center, default_empty.Center);
Assert.Equal(empty.Height(), default_empty.Height());
// Containment and intersection of empty and full caps.
Assert.True(empty.Contains(empty));
Assert.True(full.Contains(empty));
Assert.True(full.Contains(full));
Assert.False(empty.InteriorIntersects(empty));
Assert.True(full.InteriorIntersects(full));
Assert.False(full.InteriorIntersects(empty));
// Singleton cap containing the x-axis.
S2Cap xaxis = S2Cap.FromPoint(new S2Point(1, 0, 0));
Assert.True(xaxis.Contains(new S2Point(1, 0, 0)));
Assert.False(xaxis.Contains(new S2Point(1, 1e-20, 0)));
Assert.Equal(0, xaxis.Radius.Radians());
// Singleton cap containing the y-axis.
S2Cap yaxis = S2Cap.FromPoint(new S2Point(0, 1, 0));
Assert.False(yaxis.Contains(xaxis.Center));
Assert.Equal(0, xaxis.Height());
// Check that the complement of a singleton cap is the full cap.
S2Cap xcomp = xaxis.Complement();
Assert.True(xcomp.IsValid());
Assert.True(xcomp.IsFull());
Assert.True(xcomp.Contains(xaxis.Center));
// Check that the complement of the complement is *not* the original.
Assert.True(xcomp.Complement().IsValid());
Assert.True(xcomp.Complement().IsEmpty());
Assert.False(xcomp.Complement().Contains(xaxis.Center));
// Check that very small caps can be represented accurately.
// Here "kTinyRad" is small enough that unit vectors perturbed by this
// amount along a tangent do not need to be renormalized.
S2Cap tiny = new(new S2Point(1, 2, 3).Normalize(), S1Angle.FromRadians(kTinyRad));
var tangent = tiny.Center.CrossProd(new S2Point(3, 2, 1)).Normalize();
Assert.True(tiny.Contains(tiny.Center + 0.99 * kTinyRad * tangent));
Assert.False(tiny.Contains(tiny.Center + 1.01 * kTinyRad * tangent));
// Basic tests on a hemispherical cap.
S2Cap hemi = S2Cap.FromCenterHeight(new S2Point(1, 0, 1).Normalize(), 1);
Assert.Equal(-hemi.Center, hemi.Complement().Center);
Assert.Equal(1, hemi.Complement().Height());
Assert.True(hemi.Contains(new S2Point(1, 0, 0)));
Assert.False(hemi.Complement().Contains(new S2Point(1, 0, 0)));
Assert.True(hemi.Contains(new S2Point(1, 0, -(1 - kEps)).Normalize()));
Assert.False(hemi.InteriorContains(new S2Point(1, 0, -(1 + kEps)).Normalize()));
// A concave cap. Note that the error bounds for point containment tests
// increase with the cap angle, so we need to use a larger error bound
// here. (It would be painful to do this everywhere, but this at least
// gives an example of how to compute the maximum error.)
S2Point center = GetLatLngPoint(80, 10);
S1ChordAngle radius = new(S1Angle.FromDegrees(150));
double max_error =
radius.GetS2PointConstructorMaxError() +
radius.S1AngleConstructorMaxError +
3 * S2.DoubleEpsilon; // GetLatLngPoint() error
S2Cap concave = new(center, radius);
S2Cap concave_min = new(center, radius.PlusError(-max_error));
S2Cap concave_max = new(center, radius.PlusError(max_error));
Assert.True(concave_max.Contains(GetLatLngPoint(-70, 10)));
Assert.False(concave_min.Contains(GetLatLngPoint(-70, 10)));
Assert.True(concave_max.Contains(GetLatLngPoint(-50, -170)));
Assert.False(concave_min.Contains(GetLatLngPoint(-50, -170)));
// Cap containment tests.
Assert.False(empty.Contains(xaxis));
Assert.False(empty.InteriorIntersects(xaxis));
Assert.True(full.Contains(xaxis));
Assert.True(full.InteriorIntersects(xaxis));
Assert.False(xaxis.Contains(full));
Assert.False(xaxis.InteriorIntersects(full));
Assert.True(xaxis.Contains(xaxis));
Assert.False(xaxis.InteriorIntersects(xaxis));
Assert.True(xaxis.Contains(empty));
Assert.False(xaxis.InteriorIntersects(empty));
Assert.True(hemi.Contains(tiny));
Assert.True(hemi.Contains(new S2Cap(new S2Point(1, 0, 0), S1Angle.FromRadians(S2.M_PI_4 - kEps))));
Assert.False(hemi.Contains(new S2Cap(new S2Point(1, 0, 0), S1Angle.FromRadians(S2.M_PI_4 + kEps))));
Assert.True(concave.Contains(hemi));
Assert.True(concave.InteriorIntersects(hemi.Complement()));
Assert.False(concave.Contains(S2Cap.FromCenterHeight(-concave.Center, 0.1)));
}