Function testCrossingEdgeQueryAllCrossings

s2/crossing_edge_query_test.go:85–224

(t *testing.T, edges []Edge)

}

func testCrossingEdgeQueryAllCrossings(t *testing.T, edges []Edge) {
	s := &edgeVectorShape{}
	for _, edge := range edges {
		s.Add(edge.V0, edge.V1)
	}

	// Force more subdivision than usual to make the test more challenging.
	index := NewShapeIndex()
	index.maxEdgesPerCell = 1
	index.Add(s)

	// To check that candidates are being filtered reasonably, we count the
	// total number of candidates that the total number of edge pairs that
	// either intersect or are very close to intersecting.
	var numCandidates, numNearbyPairs int

	for _, edge := range edges {
		a := edge.V0
		b := edge.V1

		query := NewCrossingEdgeQuery(index)
		candidates := query.candidates(a, b, s)

		// Verify that the EdgeMap version of candidates returns the same result.
		edgeMap := query.candidatesEdgeMap(a, b)
		if len(edgeMap) != 1 {
			t.Errorf("there should be only one shape in this map, got %d", len(edgeMap))
			// Skip the next part of the check since we expect only 1
			// value, and you can't get just the first entry in a map.
			continue
		}
		for k, v := range edgeMap {
			if Shape(s) != k {
				t.Errorf("element(%v) of edgeMap should be this shape", k)
			}
			if !reflect.DeepEqual(candidates, v) {
				t.Errorf("edgeMap candidates for this shape = %v, want %v", v, candidates)
			}
		}
		if len(candidates) == 0 {
			t.Errorf("candidates should not be empty")
		}

		// Now check the actual candidates.
		// Check the results are sorted
		for k, v := range candidates {
			if k < len(candidates)-1 {
				if v > candidates[k+1] {
					t.Errorf("candidates was not sorted. candidates[%d] = %v > candidates[%d] = %v", k, v, k+1, candidates[k+1])
				}
			}
		}
		if got := candidates[0]; got < 0 {
			t.Errorf("the first element should not have a negative edge id")
		}
		if got, want := candidates[len(candidates)-1], s.NumEdges(); got >= want {
			t.Errorf("candidates[%d] = %v, want < %v", len(candidates)-1, got, want)
		}