Most upscalers are tuned to look impressive in a demo, which means over-sharpened edges and invented texture. On a listing that reads as a fake product. Here is the honest order.
If you still have the item and a window, a new phone photo beats any upscale. Upscaling is for stock already sold, discontinued lines, and supplier catalogues where the original file is long gone.
| Platform behaviour | Practical target |
|---|---|
| Minimum long edge | usually 1000 to 1600 px |
| Preferred long edge | 1600 to 2000 px |
| Rejection risk | below minimum, plus heavy compression |
| Zoom inspection | buyers do zoom, so halos are visible |
Notice the numbers. A 900px phone export only needs one 2x step to clear a 1600px requirement. Chasing 4K from a phone sensor adds file weight without adding information.
Brand marks and small print are the first casualty. The usual explanation is that pushing past 2x damages the letterform, but that is not what a measurement shows — the deciding variable is how many pixels tall the letters were in the original file. Below about 10 px of cap height nothing recovers them; above about 12 px the enlargement is safe at any factor. The next section measures it.
The advice further up this page says that past 2x a letterform "becomes a shape that resembles the letter without being it", and that if a logo smears you should "drop to 1.5x rather than pushing". Both halves of that are testable, so I tested them, and the first half is wrong in an instructive way.
The problem with the claim is that it blames the scale factor. Scale factor is the one variable you control. What decides whether a label survives is how many pixels tall the letters were in the file you started with, and that number is usually set by how far away the photographer stood. Below, cap height means the height of a capital letter in the source image, in pixels.
Everything is rendered from one supersampled master and box-downsampled, so the source and the reference sit on exactly the same pixel grid. That matters: if you build the reference by resampling the upscaled image, you are measuring your own resampler. Three renders per measurement:
The score is ink-mask IoU against the native render. 1,000 means the upscale is indistinguishable from having captured at the target resolution; 0,333 means two thirds of the letter shapes are wrong. The mask threshold is the midpoint between paper and ink, so this measures shape, not brightness.
One control before any of the numbers mean anything. Building the native render twice — once from a 16x master, once from a 64x master — does not give identical images, so I scored those two builds against each other. The agreement runs from 0,904 to 0,986 across the twelve size/factor combinations, and it is worst at 7 px cap height (0,904) where a single pixel of glyph edge is half the stroke. That is the ceiling: a score can never exceed what the reference itself agrees with on a rebuild. So read the tables below as "how much of the available agreement did this recover", and treat anything above about 0,90 as being close enough to the limit that the remaining gap is mostly the measurement's own noise rather than a difference you could see.
The 7 px row is worth dwelling on for a second, because it is the row that would poison a naive reading. Its ceiling is 0,904 and lanczos reaches 0,669 — 74% of what was achievable. That looks like a respectable score in isolation. It is not: 0,669 means a third of the glyph area lands on the wrong side of the ink threshold, which is the difference between a readable label and a smudge.
Lanczos at 2x, one string of digits and letters, six different source cap heights. IoU after upscaling, against the native render at the same output size:
| Source cap height | Ink px in source | bilinear | bicubic | lanczos | ceiling |
|---|---|---|---|---|---|
| 5 px | 38 | 0,130 | 0,320 | 0,333 | 0,981 |
| 7 px | 80 | 0,477 | 0,602 | 0,669 | 0,904 |
| 9 px | 129 | 0,723 | 0,797 | 0,858 | 0,978 |
| 12 px | 197 | 0,905 | 0,912 | 0,941 | 0,976 |
| 16 px | 425 | 0,933 | 0,937 | 0,955 | 0,973 |
| 22 px | 764 | 0,968 | 0,966 | 0,972 | 0,984 |
The move from 5 px to 22 px cap height is worth 0,639 IoU. Now hold the source still and change only the scale factor:
| Source cap height | 2x | 3x | 4x | spread |
|---|---|---|---|---|
| 5 px | 0,333 | 0,406 | 0,357 | 0,073 |
| 7 px | 0,669 | 0,707 | 0,715 | 0,047 |
| 9 px | 0,858 | 0,864 | 0,792 | 0,072 |
| 12 px | 0,941 | 0,952 | 0,933 | 0,020 |
| 16 px | 0,955 | 0,937 | 0,948 | 0,019 |
| 22 px | 0,972 | 0,957 | 0,974 | 0,017 |
The largest spread any scale factor produces, anywhere in the table, is 0,073. Cap height is worth 8,7 times more than the choice of 2x versus 3x versus 4x. Notice also that the spread shrinks as cap height grows: at 22 px, 2x and 4x are within 0,002 of each other. The 3x column is the worst of the three at every cap height above 12 px, which is a rounding coincidence of where pixel centres land, not a rule — the differences are inside the measurement's own noise.
A single table hides where the cliff is, so the same measurement run at every integer cap height from 6 to 16, on two different strings. The second string is there to check that the result is a property of the size and not of one particular arrangement of glyphs:
| String | IoU at 6 px | IoU at 9 px | IoU at 16 px | cap height for IoU 0,90 |
|---|---|---|---|---|
SIZE 42 | 0,667 | 0,858 | 0,955 | 9,83 px |
MADE IN VN | 0,596 | 0,878 | 0,937 | 9,43 px |
Two different strings, both crossing 0,90 IoU within half a pixel of each other. That is a real threshold and it is about 10 px of cap height in the source. Under it, upscaling produces something that reads as writing at a glance and not as writing on inspection — which is exactly the "resembles the letter without being it" effect, except it is a function of capture size, not of pushing past 2x. Over it, no kernel choice matters much and the enlargement is safe.
The page used to say: if the logo smears, drop to 1.5x. That advice implies 1.5x preserves something 2x destroys. Here is the same final output size reached two ways — one 2x step, versus a 1.5x step followed by a 1,333x touch-up — scored against the same native reference:
cap 2x direct via 1.5x difference
5 0,333 0,333 +0,0000
7 0,669 0,671 +0,0028
9 0,858 0,863 +0,0054
12 0,941 0,941 +0,0000
16 0,955 0,956 +0,0006
The best the detour ever buys is 0,0054 IoU at 9 px cap height, which is a third of the spread caused by picking a different kernel at that same size. In two of the five cases it buys literally nothing. Dropping to 1.5x does not preserve small print; it just gives you a smaller file that you then enlarge again, and the second enlargement throws away whatever the first one saved. If a label is unreadable after 2x, it was under 10 px of cap height in the file, and the fix is a new capture, not a different multiplier.
Unsharp mask after a 2x lanczos upscale, radius 1,0. The two columns that matter are the IoU gain and what it costs in halo — overshoot brighter than the paper, as a percentage of the full paper-to-ink range:
| Source cap height | IoU, sharpening off | IoU, 100% unsharp | gain | halo, off | halo, 100% |
|---|---|---|---|---|---|
| 5 px | 0,333 | 0,536 | +0,2026 | 10,4% | 26,4% |
| 9 px | 0,858 | 0,813 | −0,0445 | 21,7% | 45,5% |
| 16 px | 0,955 | 0,954 | −0,0017 | 13,4% | 32,4% |
At 5 px cap height sharpening is a large win — it adds 0,20 IoU, the single biggest improvement in this whole article. At 9 px it loses 0,045, and at 16 px it does nothing. The mechanism is simple: at 5 px the glyphs are so blurred that thickening them pulls the mask back toward the true shape, and at 9 px they are already roughly right, so thickening them pushes the mask past the reference into the halo. This is why sharpening small print feels like it works when you check a logo you already know how to read, and why it makes a product look counterfeit when a buyer who does not know the logo checks it at zoom.
Halo roughly doubles to triples in every case. On a white-background listing that halo is against a bright field, which is where it reads as a reflective rim rather than as crispness.
Chaining 2x twice is the same as 4x once. Scored against the same native 4x reference, the difference is under 0,002 at every cap height tested: 0,715 versus 0,714 at 7 px, 0,933 versus 0,935 at 12 px, 0,974 versus 0,974 at 22 px. If a tool only offers 2x steps, take two of them and stop worrying.
JPEG quality does not behave monotonically. A cap-12 source saved at three qualities, then upscaled 2x with lanczos:
| Saved at | IoU after 2x | ink mass retained | halo |
|---|---|---|---|
| q95 | 0,939 | 100,0% | 14,56% |
| q85 | 0,945 | 100,1% | 19,31% |
| q70 | 0,931 | 100,0% | 22,28% |
q85 beats q95 by 0,006 IoU. That is not a recommendation to save at 85 — the halo cost rises by 4,75 points, which is four times the IoU difference, and it is in the direction a buyer can see. The honest reading is that the IoU difference is inside the noise, and that ink mass is preserved at every quality (100,0 to 100,1%), so compression at these settings redistributes the label's edges into ringing rather than deleting them. Ringing is the thing that shows up as a light outline, and the halo column is where you see it.
Print measurement is not abstract, so here is the same measurement converted into a decision you can make before the shutter. A small legal line on a product label is about 1,2 mm tall, and the frame covers about 300 mm of the actual product across its long edge. That gives pixels per millimetre, then cap height, then the IoU the 2x upscale will produce:
| Capture long edge | px per mm | cap height in source | IoU after 2x | verdict |
|---|---|---|---|---|
| 1000 px | 3,33 | 4,00 px | 0,667 | too small |
| 1600 px | 5,33 | 6,40 px | 0,667 | too small |
| 2000 px | 6,67 | 8,00 px | 0,881 | too small |
| 3000 px | 10,00 | 12,00 px | 0,941 | usable |
| 4000 px | 13,33 | 16,00 px | 0,955 | usable |
Read the third column, not the first. A 2.000 px capture and a 4.000 px capture differ by a factor of two in file size and by 0,07 IoU — but the 2.000 px one lands at 8 px cap height, which is on the wrong side of the 10 px knee. The two rows that clear the threshold are the two where the label got at least 12 px, and you can reach that from a 1.600 px file by simply standing closer or framing tighter. Which is the whole finding restated as a camera instruction: zoom and position buy more label legibility than resolution, because they raise cap height directly, while resolution spends itself over the whole scene.
Two caveats on that table, stated rather than buried. The assumptions are a 1,2 mm line and a 300 mm frame width; if your product fills a fifth of the frame instead of a tenth, every cap height doubles and the verdict moves up a row. And the IoU column is interpolated on the measured cap-height sweep, so it inherits that ceiling — a row showing 0,955 sits within 0,02 of the best the reference agrees with itself, which is why the last two rows read as a plateau rather than a trend.
Self-contained, no input files. Needs numpy and Pillow. The cap-height sweep uses boxes of 150x60 pixels, which is small on purpose so that 4x stays cheap:
#!/usr/bin/env python3
"""Copy-paste reproduction of the cap-height table. No input files, no /tmp."""
import numpy as np
from PIL import Image, ImageDraw, ImageFont
FONT = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
PAPER, INK, SS, CANVAS = 0.70, 0.04, 16, (150, 60)
THR = (PAPER + INK) / 2
def cap_font(cap):
"""Font size whose 'H' is <cap> px tall. Hinting drifts, so iterate."""
f = ImageFont.truetype(FONT, 400)
b = f.getbbox("H")
size = 400 * cap / (b[3] - b[1])
for _ in range(5):
f = ImageFont.truetype(FONT, max(1, round(size)))
b = f.getbbox("H")
size = size * cap / (b[3] - b[1])
return ImageFont.truetype(FONT, max(1, round(size)))
def at(cap, k):
"""Render 'SIZE 42' at k x, from one SS-supersampled master."""
f = cap_font(cap * SS)
im = Image.new("L", (CANVAS[0] * SS, CANVAS[1] * SS), round(PAPER * 255))
d = ImageDraw.Draw(im)
b = d.textbbox((0, 0), "SIZE 42", font=f)
d.text(((im.width - (b[2] - b[0])) // 2 - b[0],
(im.height - (b[3] - b[1])) // 2 - b[1]), "SIZE 42", font=f,
fill=round(INK * 255))
return im.resize((CANVAS[0] * k, CANVAS[1] * k), Image.BOX)
def arr(im):
return np.asarray(im, dtype=np.float32) / 255.0
def iou(a, b):
ma, mb = a < THR, b < THR
return (ma & mb).sum() / (ma | mb).sum()
for cap in (5, 7, 9, 12, 16, 22):
src, nat = at(cap, 1), at(cap, 2)
out = [f"{cap:2d}px"]
for flt in (Image.BILINEAR, Image.BICUBIC, Image.LANCZOS):
up = src.resize((src.width * 2, src.height * 2), flt)
out.append(f"{iou(arr(up), arr(nat)):.3f}")
print(" ".join(out))
Expected output, three decimals, columns are bilinear, bicubic, lanczos:
5px 0.130 0.320 0.333
7px 0.477 0.602 0.669
9px 0.723 0.797 0.858
12px 0.905 0.912 0.941
16px 0.933 0.937 0.955
22px 0.968 0.966 0.972
Most want a long edge of 1600 to 2000 px and reject below 1000. A phone photo usually clears that with one 2x step.
Over-sharpening and invented texture. Halos form on edges and logos turn into letter-shaped artifacts.
About 10 px of capital-letter height in the source. Below that, measured ink-mask IoU against a native render stays under 0,90 whatever kernel or factor you pick. Above about 12 px, 2x and 4x land within 0,002 of each other.
Reshoot if the item is still available. Upscale for sold stock, discontinued lines and archive catalogues.
Barely. It helps when the file is under the marketplace minimum, not when it already passes.
The crisp preset used here is one of eight in UpgoLAB, browser based, free during launch, no watermark, photos to 4 MP. Other angles: tool comparison and blurry video guide.