// Like GetSimpleCovering(), but accepts a starting S2CellId rather than a
// starting point and cell level. Returns all edge-connected cells at the
// same level as "start" that intersect "region", in arbitrary order.
public static void FloodFill(IS2Region region, S2CellId start, List <S2CellId> output)
{
var all = new List <(S2CellId, int)>();
var frontier = new List <S2CellId>();
output.Clear();
all.Add((start, start.GetHashCode()));
frontier.Add(start);
while (frontier.Any())
{
S2CellId id = frontier.Last();
frontier.RemoveAt(frontier.Count - 1);
if (!region.MayIntersect(new S2Cell(id)))
{
continue;
}
output.Add(id);
var neighbors = new S2CellId[4];
id.EdgeNeighbors(neighbors);
for (int edge = 0; edge < 4; ++edge)
{
var nbr = neighbors[edge];
var hash = nbr.GetHashCode();
all.Add((nbr, hash));
if (hash != 0)
{
frontier.Add(nbr);
}
}
}
}
public void Test_S2CellId_Neighbors()
{
// Check the edge neighbors of face 1.
var out_faces = new[] { 5, 3, 2, 0 };
var face_nbrs = new S2CellId[4];
S2CellId.FromFace(1).EdgeNeighbors(face_nbrs);
for (int i = 0; i < 4; ++i)
{
Assert.True(face_nbrs[i].IsFace());
Assert.Equal(out_faces[i], (int)face_nbrs[i].Face());
}
// Check the edge neighbors of the corner cells at all levels. This case is
// trickier because it requires projecting onto adjacent faces.
const int kMaxIJ = S2CellId.kMaxSize - 1;
for (int level = 1; level <= S2.kMaxCellLevel; ++level)
{
S2CellId id2 = S2CellId.FromFaceIJ(1, 0, 0).Parent(level);
var nbrs2 = new S2CellId[4];
id2.EdgeNeighbors(nbrs2);
// These neighbors were determined manually using the face and axis
// relationships defined in s2coords.cc.
int size_ij = S2CellId.SizeIJ(level);
Assert.Equal(S2CellId.FromFaceIJ(5, kMaxIJ, kMaxIJ).Parent(level), nbrs2[0]);
Assert.Equal(S2CellId.FromFaceIJ(1, size_ij, 0).Parent(level), nbrs2[1]);
Assert.Equal(S2CellId.FromFaceIJ(1, 0, size_ij).Parent(level), nbrs2[2]);
Assert.Equal(S2CellId.FromFaceIJ(0, kMaxIJ, 0).Parent(level), nbrs2[3]);
}
// Check the vertex neighbors of the center of face 2 at level 5.
var nbrs = new List <S2CellId>();
new S2CellId(new S2Point(0, 0, 1)).AppendVertexNeighbors(5, nbrs);
nbrs.Sort();
for (int i = 0; i < 4; ++i)
{
Assert.Equal(S2CellId.FromFaceIJ(
2, (1 << 29) - ((i < 2) ? 1 : 0), (1 << 29) - ((i == 0 || i == 3) ? 1 : 0))
.Parent(5), nbrs[i]);
}
nbrs.Clear();
// Check the vertex neighbors of the corner of faces 0, 4, and 5.
S2CellId id1 = S2CellId.FromFacePosLevel(0, 0, S2.kMaxCellLevel);
id1.AppendVertexNeighbors(0, nbrs);
nbrs.Sort();
Assert.Equal(3, nbrs.Count);
Assert.Equal(S2CellId.FromFace(0), nbrs[0]);
Assert.Equal(S2CellId.FromFace(4), nbrs[1]);
Assert.Equal(S2CellId.FromFace(5), nbrs[2]);
// Check that AppendAllNeighbors produces results that are consistent
// with AppendVertexNeighbors for a bunch of random cells.
for (var i = 0; i < 1000; ++i)
{
S2CellId id2 = S2Testing.GetRandomCellId();
if (id2.IsLeaf())
{
id2 = id2.Parent();
}
// TestAllNeighbors computes approximately 2**(2*(diff+1)) cell ids,
// so it's not reasonable to use large values of "diff".
int max_diff = Math.Min(5, S2.kMaxCellLevel - id2.Level() - 1);
int level = id2.Level() + S2Testing.Random.Uniform(max_diff + 1);
TestAllNeighbors(id2, level);
}
}
