ForHosting KIT · Images

Estimate panorama canvas width from overlapping photos, free

Before you stitch a panorama, it helps to know how wide the finished canvas will be.

● BetaFree · in your browser

Use it from WebAPIEmailTelegramApp soon

This free calculator takes the pixel dimensions of each overlapping shot and the estimated horizontal overlap between consecutive frames, then returns the resulting panorama width, the total overlap in pixels, and the panorama height when every image declares one. It runs entirely in your browser, costs nothing for interactive use, and the same computation is available through the API at $0.002 per request when you need it inside a pipeline.

How the panorama width is estimated

A stitched panorama is not simply the sum of the individual photo widths, because consecutive frames overlap. This tool walks your list of images from left to right, exactly in the order you will stitch them. For each adjacent pair it computes the shared region: the overlap percentage you provide, applied to the narrower of the two widths. Using the narrower width is the conservative, physically sensible choice — the overlapping strip can never be wider than either of the two images that share it. That overlap in pixels is then subtracted as the next frame is laid down, so the running total grows by only the new, non-duplicated strip of each photo. The result is the estimated final canvas width in pixels. Because the math is a plain sum of products, the estimate is exact for the percentages you give it; the only uncertainty lives in how well your overlap guesses match what the camera actually captured. For handheld shooting, overlaps between 20% and 40% are typical, while a panoramic head on a tripod lets you plan tighter, more predictable values.

What to enter and what you get back

The input is a list of image records in stitch order. Each record needs a width in pixels; the height is optional, and overlap_pct is the horizontal overlap that image shares with the next one, expressed as a percentage from 0 up to but not including 100. The last image never has a next neighbor, so its overlap value is ignored. The output gives you image_count, the panorama_width estimate, total_overlap_px (how many pixels are duplicated across all seams), sum_widths_px (the naive total if you ignored overlap), and panorama_height whenever every record declares a height — taken as the maximum, since the canvas must fit the tallest frame. An overlap of 100% or more is rejected with a clear error, because two frames that overlap completely add no new information and usually signal a mistaken input. All values are rounded to six decimal places so results are stable and comparable across runs.

Planning tips for better stitches

Use this estimate before you shoot or before you commit disk space to a huge canvas. If you know your lens, sensor size, and the rotation angle between shots, you can derive the overlap percentage from the horizontal field of view: the fraction of the frame that repeats equals one minus the angular step divided by the field of view. Feed that same percentage to every seam for a uniform sweep, or vary it per pair when you changed your step mid-sequence. Keep at least 15% overlap so stitching software has enough matching features, and prefer 30% or more in low-texture scenes such as sky or water. If the estimate comes out far wider than your editor or printer supports, reduce the number of frames, increase the overlap so each frame contributes less new area, or plan to downscale the final canvas. Because this calculator is deterministic and instant, you can iterate on frame counts and overlaps freely until the projected size fits your target.

What you can do with it

Pre-shoot planning for landscape panoramas

A photographer planning a five-frame sweep of a skyline enters each frame's width and the intended 30% overlap to confirm the final canvas will be wide enough for a large print before leaving home.

Sizing canvas and storage for gigapixel work

A studio building a gigapixel mosaic of dozens of telephoto frames estimates the stitched width to check memory, scratch disk, and export limits in their stitching software ahead of the session.

Sanity-checking a stitching pipeline

A developer batch-processing drone photo sequences calls the API at $0.002 per request to predict output dimensions, flagging sequences whose overlap inputs would produce an impossibly narrow or wide result.

FAQ

Why is my panorama not just the sum of all image widths?

Because consecutive frames overlap. The duplicated strip between each pair is subtracted, so the final width is the sum of the widths minus every seam's overlap in pixels.

How is the overlap between two images computed?

Your overlap percentage is applied to the narrower of the two widths in each adjacent pair, since the shared region cannot be wider than either image. That pixel value is then subtracted as the next frame is added.

What happens if I enter an overlap of 100% or more?

The request is rejected as invalid input. A complete overlap means the second image adds no new area, which contradicts the idea of stitching and almost always indicates a data entry mistake.

Does the order of the images matter?

Yes. Records are processed in stitch order, left to right, and each overlap_pct describes the seam between that image and the next one. The last image's overlap value is ignored.

Can I estimate the panorama height too?

Yes. When every image record includes a height, the result includes panorama_height, taken as the maximum height so the canvas fits the tallest frame. If any height is missing, the field is omitted.

Is the tool free, and does it run online?

Interactive use runs entirely in your browser for free — nothing is uploaded. The identical computation is also exposed through the API at $0.002 per request for scripted pipelines.

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/image/stitch-panorama-estimate

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/image/stitch-panorama-estimate \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"images":[{"width":4000,"height":3000,"overlap_pct":30},{"width":4000,"height":3000,"overlap_pct":25},{"width":4000,"height":3000}]}'

const res = await fetch("https://api.kit.forhosting.com/image/stitch-panorama-estimate", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "images": [
      {
        "width": 4000,
        "height": 3000,
        "overlap_pct": 30
      },
      {
        "width": 4000,
        "height": 3000,
        "overlap_pct": 25
      },
      {
        "width": 4000,
        "height": 3000
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/stitch-panorama-estimate",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "images": [
        {
            "width": 4000,
            "height": 3000,
            "overlap_pct": 30
        },
        {
            "width": 4000,
            "height": 3000,
            "overlap_pct": 25
        },
        {
            "width": 4000,
            "height": 3000
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/stitch-panorama-estimate", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"images":[{"width":4000,"height":3000,"overlap_pct":30},{"width":4000,"height":3000,"overlap_pct":25},{"width":4000,"height":3000}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"images":[{"width":4000,"height":3000,"overlap_pct":30},{"width":4000,"height":3000,"overlap_pct":25},{"width":4000,"height":3000}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/stitch-panorama-estimate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "images": [
    {
      "width": 4000,
      "height": 3000,
      "overlap_pct": 30
    },
    {
      "width": 4000,
      "height": 3000,
      "overlap_pct": 25
    },
    {
      "width": 4000,
      "height": 3000
    }
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.stitch_panorama_estimate",
  "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.

Limits

max_items 200

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 →