Fewer / more lines (but with lower thresholds, the lines may be worse, since they will be accepted with fewer "votes"). The code is only a reference solution; the aim is to understand the effect of the parameters, so different parameters are accepted.

• Lower T → more lines, lower quality. At T = 40 the checkerboard returns 1338 "lines"; most are near-duplicates of real grid lines plus diagonals through the square corners that happen to collect 40 votes.
• Higher T → fewer, longer lines. At T = 120 you get 31 lines (the grid); at T = 300 only 6 survive; at T = 400 just 2. Short receding lines at the top of the board lose out first because they contain fewer edge pixels.
• The threshold is in units of edge pixels, so it must be tuned per image and per resolution. A 640-px-long edge can score ~640 votes; a 100-px edge can never pass T = 120 however perfect it is.
• Canny first. Hough needs a sparse binary input. Feeding it a grayscale image (every pixel votes) floods the accumulator.

board_edge = cv2.Canny(checkerboard, 50, 250, apertureSize=3, L2gradient=True)
lines = cv2.HoughLines(board_edge, 1, np.pi/180, 120)          # (rho, theta) per line
color_board = cv2.cvtColor(checkerboard, cv2.COLOR_GRAY2RGB)
for rho, theta in lines[:, 0]:
    a, b = np.cos(theta), np.sin(theta); x0, y0 = a*rho, b*rho
    pt1 = (int(x0 + 1000*(-b)), int(y0 + 1000*a)); pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*a))
    cv2.line(color_board, pt1, pt2, (255, 0, 0), 2)

Official solution output: original · Canny edge map · 31 detected lines at T = 120.

for it in range(ransac_iterations):
    # (1) randomly sample n = 2 points
    all_indices = np.arange(x_noise.shape[0]); np.random.shuffle(all_indices)
    sample_points = data[all_indices[:2], :]; test_points = data[all_indices[2:], :]

    # (2) fit a line model to the sampled points
    m, c = find_line_model(sample_points)

    # (3) count the inliers: distance to the line < ransac_threshold
    num = 0; x_list, y_list = [], []
    for x0, y0 in test_points:
        if find_dist_to_line(m, c, x0, y0) < ransac_threshold:
            x_list.append(x0); y_list.append(y0); num += 1

    if num / float(n_samples) > ratio:            # keep the best model
        ratio, model_m, model_c = num / float(n_samples), m, c
    if num > n_samples * ransac_ratio:             # good enough → stop
        print('The model is found !'); break

• Compare least squares on all points with the consensus fit. Outliers can distort the all-point fit.
• Refit on the consensus to reduce sample noise. Outliers inside the tolerance can bias the refit, so improvement is not guaranteed. The live demo uses orthogonal least squares and counts all points; the notebook uses y-on-x regression and excludes the sampled pair.
• Expected iterations: $w=0.6,\ s=2$ → $w^2=0.36$ → $N=\ln(0.01)/\ln(0.64)\approx 11$ for 99 % confidence, consistent with finding it at iteration 7 here.
• Threshold $t$ should match the noise: $t = 3\sigma$ keeps 99.7 % of true inliers. Too small and $w$ collapses; too large and outliers get counted.

Both of these are a bit more difficult than the box scene, so they may require a different ratio (which changes the number of good matches and percentage of false matches). They may also require a higher number of RANSAC iterations to find a correct solution. Different parameters are accepted.

• Ratio τ trades quantity for purity. Flinders: at τ = 0.7 there are 29 "good" matches but only 9 are correct (w ≈ 0.31); at τ = 0.6 there are 9 with 6 correct (w ≈ 0.67). Lowering τ makes RANSAC's job easier but leaves very few points to fit $\mathbf H$ — there is a floor at 4.
• Raising τ when there are too few matches. The tower at τ = 0.7 keeps only 9 matches (6 correct); the solution relaxes to 0.8 to get 39 (15 correct). Fewer than ~8 inliers makes $\mathbf H$ unstable even when RANSAC succeeds.
• More attempts increase the chance of a clean sample. They do not guarantee an accurate homography: repeated or poorly spread features can still produce degenerate geometry.
• OpenCV's RANSAC is randomised, so re-running the same cell gives different inlier counts (15–17 for the tower). Use the "run 50 trials" button above to see the spread.

Official solution: Flinders, τ = 0.6, maxIters = 500 → 6 inliers; bottom: scene warped into the close-up frame.

Official solution: Old Arts, τ = 0.8, maxIters = 200 → 17 inliers.

(i) log(0.01) / log(0.999) = 4603.   (ii) Re-estimate using all inliers.

• Any log base works because the bases cancel in the ratio; use natural or base-10 consistently.
• The result rounds up to an integer number of iterations; 4603 is the ceiling of approximately 4602.87.
• Common slip: using $w=0.1$ with $s=1$ (N = 44) or forgetting that the sample must be entirely clean.