# Pointerbench-Sheets

**A 500-example GUI grounding benchmark for spreadsheets.** Given a spreadsheet
screenshot and a short instruction (e.g. *"Click cell E33"*, *"Click the orange
cell"*, *"Click the Revenue column header"*, *"Drag to resize column C"*), a model must output the pixel
coordinate to click. Scored exactly like [ScreenSpot](https://github.com/njucckevin/SeeClick):
**a click is correct if it lands inside the target's bounding box.**

![teaser](assets/teaser.png)

## Why spreadsheets?

General GUI-grounding suites (ScreenSpot, ScreenSpot-v2, ScreenSpot-Pro) are
broad but **thin on spreadsheets**, yet spreadsheets are where grounding is
hardest: hundreds of near-identical small cells, dense grids, colored fills,
header rows, scroll positions that rarely start at `A1`, and click targets that
are not ordinary objects at all. Resizing a column means clicking the thin line
between columns; selecting a cell corner means landing on one grid intersection;
following "three cells below A5" means reasoning over grid coordinates, not OCR
tokens. Pointerbench-Sheets isolates this spreadsheet-specific
grounding skill across four real spreadsheet UI skins plus a chrome-free grid.

## What's inside

- **500** examples, one instruction per image.
- **1024×768** PNG screenshots, fully synthetic (no scraping, no PII).
- **5 UI styles**: Excel, Excel (white), Google Sheets, LibreOffice Calc, and a
  bare chrome-free grid.
- **16 task categories**:

  | category           | data_type | instruction example                       |
  | ------------------ | --------- | ------------------------------------------ |
  | `cell_ref`         | cell      | *Click cell C12.*                          |
  | `cell_ref_content` | cell      | *Click cell C12 containing "Madrid".*      |
  | `cell_content`     | cell      | *Click the cell containing "Madrid".*      |
  | `col_header`       | header    | *Click the column D header.*               |
  | `row_header`       | header    | *Click the row 18 header.*                 |
  | `cell_color`       | color     | *Click the orange cell.*                   |
  | `col_resize_handle`| edge      | *Click the divider after column D.*        |
  | `row_resize_handle`| edge      | *Click the lower border of row 18.*        |
  | `cell_right_edge`  | edge      | *Click the right edge of cell C12.*        |
  | `cell_bottom_edge` | edge      | *Click the bottom edge of cell C12.*       |
  | `cell_top_left_corner` | corner | *Click the top-left corner of cell C12.*   |
  | `cell_top_right_corner` | corner | *Click the top-right corner of cell C12.*  |
  | `cell_bottom_left_corner` | corner | *Click the bottom-left corner of cell C12.* |
  | `cell_bottom_right_corner` | corner | *Click the bottom-right corner of cell C12.* |
  | `cell_relative_row` | relative | *Click the cell 3 rows below D18.*          |
  | `cell_relative_offset` | relative | *From B7, move 3 columns right and 1 row down.* |

- Randomized realism: per-sheet font family/size, per-column text color / bold /
  alignment, colored fills (single cell / row / column / stripe), banded rows, a
  selected-cell distractor, and **random row + column scroll offsets** (the
  window does not always start at `A1`).
- ~10% of instructions are in German (`language` field), the rest English.

## Schema

Each line of `data/test/metadata.jsonl` (HuggingFace `imagefolder` layout):

```json
{
  "file_name": "0000.png",
  "id": "pbs_0000",
  "instruction": "Click cell E33.",
  "bbox": [596, 376, 681, 395],
  "point": [638, 385],
  "data_type": "cell",
  "category": "cell_ref",
  "ui_style": "excel",
  "language": "en",
  "image_size": [1024, 768]
}
```

- **`bbox`**: ground-truth target, **`[x1, y1, x2, y2]` in absolute pixels**
  (top-left, bottom-right) on the 1024×768 image. A prediction is correct iff it
  lands inside this box.
- **`point`**: the box center (a convenient single-point reference).
- **`data_type`**: coarse ScreenSpot-style class (`cell` / `header` / `color` / `edge` / `corner` / `relative`).
- **`category`**: the fine-grained task kind.
- **`ui_style`**: the rendered app skin.

## Quickstart

### Load the data

Via 🤗 `datasets` (after the set is pushed to the Hub):

```python
from datasets import load_dataset
ds = load_dataset("YOUR_ORG/pointerbench-sheets", split="test")
ex = ds[0]
ex["image"]        # PIL.Image, 1024x768
ex["instruction"]  # "Click cell E33."
ex["bbox"]         # [x1, y1, x2, y2]
```

Or locally with the imagefolder loader:

```python
from datasets import load_dataset
ds = load_dataset("imagefolder", data_dir="data", split="test")
```

Or with no dependencies at all, read `data/test/metadata.jsonl` and open the
sibling PNGs yourself.

### Evaluate

1. Print the recommended system prompt with `python eval.py --show-system-prompt`,
   or edit it for your inference stack while keeping the 1024x768 coordinate
   frame fixed.
2. Run your model on every example's `instruction` + image and collect a
   predicted click point (absolute pixels on the 1024×768 image).
3. Write predictions as JSONL, one object per example:

   ```json
   {"id": "pbs_0000", "point": [612, 388]}
   ```

4. Score (pure standard library, no dependencies):

   ```bash
   python eval.py --predictions preds.jsonl
   ```

   ```
   Pointerbench-Sheets: 500 examples
   ============================================
   Accuracy: 73.40%   (367/500)

   By category:
     cell_color          61.11%   (n=72)
     cell_ref            81.46%   (n=178)
     ...
   ```

The scorer reports overall accuracy plus per-category, per-UI-style, and
per-data-type breakdowns. `--json report.json` writes the full report.

### Turning model output into a point

Models emit clicks in many shapes; map them to `[x, y]` pixels before scoring.
For example, a `<click>x,y</click>` tag or a normalized `0-1` / `0-999` point:

```python
import re
def to_point(text, w=1024, h=768):
    m = re.search(r"(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)", text)
    x, y = float(m.group(1)), float(m.group(2))
    if max(x, y) <= 1.0:   x, y = x * w, y * h          # normalized 0-1
    elif max(x, y) <= 999: x, y = x / 999 * w, y / 999 * h  # 0-999 grid
    return [round(x), round(y)]
```

## Baselines

| Model                         | Accuracy | Notes                     |
| ----------------------------- | -------- | ------------------------- |
| Center-click (512, 384)       | 0.6%     | sanity floor              |
| _your model here_             | n/a      | open a PR                 |

## Construction & reproducibility

Examples are rendered programmatically (pure PIL, no browser, no real files),
so every ground-truth box is pixel-exact. The set is **held out**: it is built
with a generation seed disjoint from any training data, so no benchmark sheet is
reused for training. The generator and the exact build command live in the
[source repo](https://github.com/YOUR_ORG/YOUR_GENERATOR_REPO); see
[`REPRODUCE.md`](REPRODUCE.md).

## Limitations

- Fully synthetic: realistic but not screenshots of real workbooks.
- Fixed 1024×768 resolution; instructions in English/German only.
- Targets are cells, headers, colored regions, grid/resize edges, cell corners,
  and relative cell offsets, not in-sheet charts, shapes, or app chrome
  (menus/toolbars are decorative and never targets).

## Citation

```bibtex
@misc{pointerbench_sheets_2026,
  title  = {Pointerbench-Sheets: A GUI Grounding Benchmark for Spreadsheets},
  author = {Pointerbench-Sheets contributors},
  year   = {2026},
  url    = {https://github.com/YOUR_ORG/pointerbench-sheets}
}
```

## License

- **Data** (images + annotations): [CC BY 4.0](LICENSE).
- **Code** (`eval.py`): MIT.