scoooba

← All how-to pages

How-to 03 · Scoring, no account

The random-point overlay, by hand

The course does not require any software. Point intercept needs a set of random points and a person willing to look at each one — and for a first Site Entry this is the sensible default. It has no version to record and cannot drift, which is not nothing.

The points come first, and once

The points must be random and they must be recorded — a point list or an annotated frame goes in the archive so the same spots can be scored again. Generate them once per frame and keep the list. Do not eyeball "random" positions; a person spreading points by hand avoids the boring parts of the frame, and that is a bias in the direction of whatever is interesting.

Option A — a script that draws the points on the frame

A dozen lines of Python. It opens the frame, scatters N points at random, draws them, saves the annotated copy and writes the point list. Install Pillow once (pip install pillow); Python itself comes with everything else.

import random, csv, sys
from PIL import Image, ImageDraw

src   = sys.argv[1]                     # e.g. IMG_4471.JPG  (a scoring copy, never the record)
n     = int(sys.argv[2]) if len(sys.argv) > 2 else 50
seed  = int(sys.argv[3]) if len(sys.argv) > 3 else 1

random.seed(seed)                        # write the seed in the Entry: same seed, same points
im = Image.open(src).convert("RGB")
w, h = im.size
pts = [(random.randint(0, w - 1), random.randint(0, h - 1)) for _ in range(n)]

d = ImageDraw.Draw(im)
r = max(6, w // 250)
for i, (x, y) in enumerate(pts, 1):
    d.ellipse([x - r, y - r, x + r, y + r], outline=(255, 60, 30), width=3)
    d.text((x + r + 3, y - r), str(i), fill=(255, 60, 30))

stem = src.rsplit(".", 1)[0]
im.save(f"{stem}_points{n}_seed{seed}.jpg", quality=92)
with open(f"{stem}_points{n}_seed{seed}.csv", "w", newline="") as f:
    wr = csv.writer(f); wr.writerow(["point", "x_px", "y_px", "label"])
    for i, (x, y) in enumerate(pts, 1):
        wr.writerow([i, x, y, ""])
print(f"{n} points on {src} ({w}x{h}), seed {seed}")

Run it as python overlay.py IMG_4471.JPG 50 1. It writes two files beside the frame: the annotated image you score from, and a CSV with one row per point and an empty label column for you to fill. Both go in the archive; the CSV is the point-position record Section 12 asks for. Record the seed and the point count in the Entry — with them, anyone can regenerate exactly the same points on the same file.

A point that lands on a reference chart is re-drawn: delete its row, add one more with a new random position (change the seed for that one point, or just generate 55 and take the first 50 that are not on a chart, noting which were skipped). Count the re-draws in Section 4.

Option B — a printed transparency

Where there is no computer at all: print the frame at a fixed size, print a sheet of random points at the same size on a transparency, and lay one over the other. Generate the points with the script above on a blank white image of the same pixel size, or with any random-number source, and keep the sheet — it is the point list. Tape the two together so the registration cannot slip between your pass and your buddy's.

Scoring

  1. Work through the points in order. At each, answer one question: what is directly underneath this point? Write the class in the CSV's label column, or on a tally sheet numbered 1 to 50.
  2. The classes are the course's: hard coral, soft coral, dead coral, macroalgae, coralline algae, turf algae, other invertebrates, sand, rubble, rock — and indeterminate for a point the frame cannot support. A point on bleached tissue is hard coral. Never assign an unclear point to whichever seems likelier.
  3. Count each class. 16 of 50 on hard coral is 32 %. Read the sampling Standard Error from the table for that cover and point count, and write both in Section 4. A class seen at fewer than three points is reported as a count, not a percentage with a ±.
  4. Your buddy scores the same points from the same annotated image or the same transparency, on their own sheet, without conferring. Both figures go in Section 4 side by side. Where you disagree, that is information about the frame, and it is reported rather than averaged.

What goes in the archive

  • The camera's file, untouched — still the record.
  • The annotated scoring copy and the point CSV (or the transparency, scanned or kept), named to match the frame.
  • Both scorers' filled label lists.
  • In Section 12: "manual point intercept, overlay script seed s, n points" as the scoring tool. There is no model and no version.

The script above was run with Python 3.12 and Pillow 12 in September 2026. It is deliberately small; if it breaks on a future Pillow, the method — random points, recorded positions, one class per point, two independent scorers — is in the Course Guide and does not depend on it.