ForHosting KIT · Developer Utilities

Pixel Sampling and Resolution Check Calculator

This pixel sampling calculator connects three practical specifications: camera pixel size, telescope focal length, and atmospheric seeing.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

It calculates the angular image scale in arcseconds per pixel, converts the seeing disc into pixels across its full width at half maximum, and reports whether the combination is undersampled, well-sampled, or oversampled. The result helps you judge whether a camera and optical system preserve the detail that the sky can realistically deliver before you change equipment, add a reducer, or increase focal length.

Turn camera and telescope specifications into image scale

Pixel size alone does not determine resolution, and focal length alone does not determine how finely a camera records the sky. Their combination sets the image scale. The calculator uses the standard small-angle relation: 206.265 multiplied by pixel size in micrometres, divided by focal length in millimetres. The result is arcseconds per pixel. A smaller value means each pixel covers a narrower angle and therefore samples the projected image more finely. Enter the effective focal length of the complete imaging train, not merely the telescope's printed native focal length. A reducer, Barlow lens, or other focal modifier changes the effective value and can move the setup into a different sampling class. Likewise, use the physical pixel pitch for the active capture mode. Hardware or software binning may change the effective pitch and should be represented by multiplying the native pixel size by the binning factor. The returned image scale is rounded for stable display, while the classification uses the unrounded calculation so a value near a boundary is judged consistently. This makes the result useful both for quick equipment comparisons and repeatable automated checks.

Interpret seeing through the Nyquist criterion

Seeing describes the atmosphere's blurring of a point source, normally as a full width at half maximum in arcseconds. Dividing that seeing value by the image scale gives the number of pixels across the seeing FWHM. Nyquist sampling requires at least two samples across the smallest feature being represented, so a result below two pixels is classified as undersampled. Such a setup can lose spatial information and produce blocky or square-looking stars even when focus and tracking are good. A result from two through four pixels is reported as well-sampled: it meets Nyquist while retaining a practical amount of signal per pixel. More than four pixels is classified as oversampled. Oversampling is not automatically a defect, but it spreads a seeing-limited star across more pixels without creating atmospheric detail that was never present. The output also includes the largest image scale that still meets the two-pixel Nyquist boundary. Compare that threshold with the calculated scale to see how much margin the setup has. Seeing must be positive because zero or negative atmospheric FWHM has no physical meaning and would make the comparison invalid.

Use the classification as a planning guide

Treat the classification as a focused planning measurement rather than a promise of final image quality. If the result is undersampled, a longer effective focal length or smaller pixels can increase sampling, while drizzle processing may recover some information when many suitably dithered exposures are available. If it is oversampled, a reducer, larger pixels, or binning can improve signal per effective pixel and reduce storage and processing demands. A well-sampled result indicates a balanced match to the seeing value entered, but guiding, focus, optical aberrations, mount vibration, and target altitude can still broaden stars. Use a representative local seeing figure rather than an exceptional best night unless you are designing specifically for those rare conditions. It can also be helpful to calculate several scenarios, such as typical seeing and excellent seeing, because the same fixed setup can move between classifications as conditions change. The API price is $0.002 per request, and the deterministic output makes it suitable for equipment comparison tables, observatory configuration tools, and capture-plan checks. No network lookup is performed, so the calculator uses exactly the physical values you provide and does not silently substitute a regional forecast or generic estimate.

What you can do with it

Match a new camera to a telescope

Compare a sensor's pixel pitch with the telescope's effective focal length before choosing an imaging camera.

Evaluate a reducer or Barlow

Recalculate sampling after changing effective focal length and see whether the optical modifier produces a better match to local seeing.

Plan binning for difficult conditions

Test the effective pixel size of a binned capture mode to decide whether it avoids unnecessary oversampling.

FAQ

What does the classification mean?

Undersampled means fewer than two pixels span the seeing FWHM, well-sampled means two through four pixels, and oversampled means more than four pixels.

Why is two pixels the minimum?

The Nyquist criterion requires at least two samples across the smallest resolved feature to preserve its spatial information.

Is oversampling always bad?

No. It can support processing and good star shapes, but beyond the seeing limit it usually spreads the same signal across more pixels without revealing additional atmospheric detail.

Which focal length should I enter?

Enter the effective focal length after accounting for any reducer, field corrector with magnification, Barlow lens, or other focal modifier.

How should binning be represented?

Multiply the native pixel size by the binning factor. For example, 2-by-2 binning makes the effective linear pixel pitch twice the native pitch.

What happens if seeing is zero or negative?

The request returns an invalid input error because a non-positive seeing FWHM is not physically meaningful.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/astro/pixel-sampling

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/astro/pixel-sampling \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"pixel_size_um":3.76,"focal_length_mm":800,"seeing_arcsec":2.2}'

const res = await fetch("https://api.kit.forhosting.com/astro/pixel-sampling", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "pixel_size_um": 3.76,
    "focal_length_mm": 800,
    "seeing_arcsec": 2.2
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/astro/pixel-sampling",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "pixel_size_um": 3.76,
    "focal_length_mm": 800,
    "seeing_arcsec": 2.2
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/pixel-sampling", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"pixel_size_um":3.76,"focal_length_mm":800,"seeing_arcsec":2.2}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"pixel_size_um":3.76,"focal_length_mm":800,"seeing_arcsec":2.2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/pixel-sampling", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "pixel_size_um": 3.76,
  "focal_length_mm": 800,
  "seeing_arcsec": 2.2
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "astro.pixel_sampling",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →