Berechne diese Größe im Code.
Berechne diese Größe im Code.
```python Python
import math
def count_image_tokens(width: int, height: int) -> int:
"""Visual tokens consumed by an image: one token per 28x28 pixel patch."""
return math.ceil(width / 28) * math.ceil(height / 28)
def resized_size(
width: int,
height: int,
max_edge: int = 1568,
max_tokens: int = 1568,
) -> tuple[int, int]:
"""The size Claude resizes an image to before padding.
Defaults are for the standard resolution tier. For high-resolution-tier
models, use max_edge=2576 and max_tokens=4784. Returns (width, height).
Images that already fit within the limits are returned unchanged.
"""
def fits(w: int, h: int) -> bool:
return (
math.ceil(w / 28) * 28 <= max_edge
and math.ceil(h / 28) * 28 <= max_edge
and count_image_tokens(w, h) <= max_tokens
)
if fits(width, height):
return (width, height)
if height > width:
resized_h, resized_w = resized_size(height, width, max_edge, max_tokens)
return (resized_w, resized_h)
# Binärsuche entlang der langen Kante nach der größten seitenverhältnis-
# treuen Größe, die passt.
aspect_ratio = width / height
lo, hi = 1, width # lo always fits; hi never fits
while lo + 1 < hi:
mid = (lo + hi) // 2
if fits(mid, max(round(mid / aspect_ratio), 1)):
lo = mid
else:
hi = mid
return (lo, max(round(lo / aspect_ratio), 1))
# Das A4-Beispiel aus „How Claude resizes and pads images“:
print(resized_size(1075, 1520)) # (924, 1307)
# Für das Resize nutze deine Bildbibliothek, z. B. Pillow:
# image.resize(resized_size(*image.size))
```
```typescript TypeScript
/** Visual tokens consumed by an image: one token per 28x28 pixel patch. */
function countImageTokens(width: number, height: number): number {
return Math.ceil(width / 28) * Math.ceil(height / 28);
}
/**
* Round half to even (banker's rounding), matching Python's round(). The
* live API resolves exact .5 ties toward the even neighbor, so Math.round
* (which rounds halves up) would compute a different size for some images.
*/
function roundTiesToEven(value: number): number {
const floor = Math.floor(value);
if (value - floor !== 0.5) {
return Math.round(value);
}
return floor % 2 === 0 ? floor : floor + 1;
}
/**
* The size Claude resizes an image to before padding.
*
* Defaults are for the standard resolution tier. For high-resolution-tier
* models, use maxEdge = 2576 and maxTokens = 4784. Returns [width, height].
* Images that already fit within the limits are returned unchanged.
*/
function resizedSize(
width: number,
height: number,
maxEdge = 1568,
maxTokens = 1568
): [number, number] {
const fits = (w: number, h: number): boolean =>
Math.ceil(w / 28) * 28 <= maxEdge &&
Math.ceil(h / 28) * 28 <= maxEdge &&
countImageTokens(w, h) <= maxTokens;
if (fits(width, height)) {
return [width, height];
}
if (height > width) {
const [resizedH, resizedW] = resizedSize(height, width, maxEdge, maxTokens);
return [resizedW, resizedH];
}
// Binärsuche entlang der langen Kante nach der größten seitenverhältnis-
// wahrenden Größe, die passt.
const aspectRatio = width / height;
let lo = 1; // lo always fits
let hi = width; // hi never fits
while (lo + 1 < hi) {
const mid = Math.floor((lo + hi) / 2);
if (fits(mid, Math.max(roundTiesToEven(mid / aspectRatio), 1))) {
lo = mid;
} else {
hi = mid;
}
}
return [lo, Math.max(roundTiesToEven(lo / aspectRatio), 1)];
}
// Das A4-Beispiel aus „Wie Claude Bilder skaliert und auffüllt“:
console.log(resizedSize(1075, 1520)); // [ 924, 1307 ]
// Verwende zum Skalieren deine Bildbibliothek, zum Beispiel sharp:
// await sharp(input).resize(width, height).toBuffer()
```
```csharp C#
// Visuelle Tokens, die ein Bild verbraucht: ein Token pro 28x28-Pixel-Patch.
static int CountImageTokens(int width, int height)
{
return (width + 27) / 28 * ((height + 27) / 28); // ceil(w/28) * ceil(h/28)
}
// Die Größe, auf die Claude ein Bild vor dem Padding skaliert. Defaults gelten
// für die Standard-Auflösungsstufe; für High-Resolution-Tier-Modelle übergib
// maxEdge: 2576, maxTokens: 4784. Bilder, die bereits in die Limits passen,
// werden unverändert zurückgegeben.
static (int Width, int Height) ResizedSize(
int width, int height, int maxEdge = 1568, int maxTokens = 1568)
{
bool Fits(int w, int h) =>
(w + 27) / 28 * 28 <= maxEdge
&& (h + 27) / 28 * 28 <= maxEdge
&& CountImageTokens(w, h) <= maxTokens;
if (Fits(width, height))
{
return (width, height);
}
if (height > width)
{
(int resizedH, int resizedW) = ResizedSize(height, width, maxEdge, maxTokens);
return (resizedW, resizedH);
}
// Binärsuche entlang der langen Kante nach der größten seitenverhältnis-
// treuen Größe, die passt. Die kurze Kante rundet .5 auf gerade, wie die
// Live-API bei exakten .5-Ties (MidpointRounding.ToEven, Math.Round-Default).
double aspectRatio = (double)width / height;
int lo = 1; // lo always fits
int hi = width; // hi never fits
while (lo + 1 < hi)
{
int mid = (lo + hi) / 2;
if (Fits(mid, ShortEdge(mid)))
{
lo = mid;
}
else
{
hi = mid;
}
}
return (lo, ShortEdge(lo));
int ShortEdge(int longEdge) =>
Math.Max((int)Math.Round(longEdge / aspectRatio, MidpointRounding.ToEven), 1);
}
// Das A4-Beispiel aus "How Claude resizes and pads images":
Console.WriteLine(ResizedSize(1075, 1520)); // (924, 1307)
```
```go Go
// countImageTokens ist die Anzahl visueller Token, die ein Bild verbraucht:
// ein Token pro 28x28-Pixel-Patch.
func countImageTokens(width, height int) int {
return ((width + 27) / 28) * ((height + 27) / 28) // ceil(w/28) * ceil(h/28)
}
// resizedSize ist die Größe, auf die Claude ein Bild vor dem Padding skaliert,
// als (width, height). Übergib maxEdge 1568 und maxTokens 1568 für die
// Standard-Auflösungsstufe oder 2576 und 4784 für die hochauflösende Stufe.
// Bilder, die bereits innerhalb der Limits liegen, werden unverändert zurückgegeben.
// Das A4-Beispiel aus „How Claude resizes and pads images“:
// resizedSize(1075, 1520, 1568, 1568) gibt (924, 1307) zurück.
func resizedSize(width, height, maxEdge, maxTokens int) (int, int) {
fits := func(w, h int) bool {
return ((w+27)/28)*28 <= maxEdge &&
((h+27)/28)*28 <= maxEdge &&
countImageTokens(w, h) <= maxTokens
}
if fits(width, height) {
return width, height
}
if height > width {
resizedH, resizedW := resizedSize(height, width, maxEdge, maxTokens)
return resizedW, resizedH
}
// Binärsuche entlang der langen Kante nach der größten seitenverhältnistreuen
// Größe, die passt. Die kurze Kante rundet .5 auf gerade (math.RoundToEven),
// passend zur Live-API bei exakten .5-Werten; math.Round würde aufrunden.
aspectRatio := float64(width) / float64(height)
lo, hi := 1, width // lo always fits; hi never fits
for lo+1 < hi {
mid := (lo + hi) / 2
short := max(int(math.RoundToEven(float64(mid)/aspectRatio)), 1)
if fits(mid, short) {
lo = mid
} else {
hi = mid
}
}
return lo, max(int(math.RoundToEven(float64(lo)/aspectRatio)), 1)
}
```
```java Java
/** A resized image size, as returned by resizedSize. */
record Size(int width, int height) {}
/** Visual tokens consumed by an image: one token per 28x28 pixel patch. */
static int countImageTokens(int width, int height) {
return Math.ceilDiv(width, 28) * Math.ceilDiv(height, 28);
}
/**
* The size Claude resizes an image to before padding.
*
* Pass maxEdge 1568 and maxTokens 1568 for the standard resolution tier,
* or 2576 and 4784 for the high-resolution tier. Images that already fit
* within the limits are returned unchanged.
*
*
The A4 example from "How Claude resizes and pads images":
* resizedSize(1075, 1520, 1568, 1568) returns new Size(924, 1307).
*/
static Size resizedSize(int width, int height, int maxEdge, int maxTokens) {
if (fits(width, height, maxEdge, maxTokens)) {
return new Size(width, height);
}
if (height > width) {
Size rotated = resizedSize(height, width, maxEdge, maxTokens);
return new Size(rotated.height(), rotated.width());
}
// Binärsuche entlang der langen Kante nach der größten seitenverhältnistreuen
// Größe, die passt. Die kurze Kante rundet .5 auf gerade (Math.rint),
// passend zur Live-API bei exakten .5-Werten; Math.round würde sie aufrunden.
double aspectRatio = (double) width / height;
int lo = 1; // lo always fits
int hi = width; // hi never fits
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
if (fits(mid, shortEdge(mid, aspectRatio), maxEdge, maxTokens)) {
lo = mid;
} else {
hi = mid;
}
}
return new Size(lo, shortEdge(lo, aspectRatio));
}
private static boolean fits(int width, int height, int maxEdge, int maxTokens) {
return Math.ceilDiv(width, 28) * 28 <= maxEdge
&& Math.ceilDiv(height, 28) * 28 <= maxEdge
&& countImageTokens(width, height) <= maxTokens;
}
private static int shortEdge(int longEdge, double aspectRatio) {
return Math.max((int) Math.rint(longEdge / aspectRatio), 1);
}
```
```php PHP
// Visuelle Tokens, die ein Bild verbraucht: ein Token pro 28x28-Pixel-Patch.
function countImageTokens(int $width, int $height): int
{
return intdiv($width + 27, 28) * intdiv($height + 27, 28);
}
/**
* The size Claude resizes an image to before padding, as [width, height].
*
* Defaults are for the standard resolution tier. For high-resolution-tier
* models, pass maxEdge: 2576, maxTokens: 4784. Images that already fit
* within the limits are returned unchanged.
*/
function resizedSize(int $width, int $height, int $maxEdge = 1568, int $maxTokens = 1568): array
{
$fits = fn (int $w, int $h): bool =>
intdiv($w + 27, 28) * 28 <= $maxEdge
&& intdiv($h + 27, 28) * 28 <= $maxEdge
&& countImageTokens($w, $h) <= $maxTokens;
if ($fits($width, $height)) {
return [$width, $height];
}
if ($height > $width) {
[$resizedH, $resizedW] = resizedSize($height, $width, $maxEdge, $maxTokens);
return [$resizedW, $resizedH];
}
// Binäre Suche entlang der langen Kante nach der größten seitenverhältnis-
// treuen Größe, die passt. Die kurze Kante rundet .5 auf gerade
// (PHP_ROUND_HALF_EVEN), passend zur Live-API bei exakten .5-Ties.
$aspectRatio = $width / $height;
$lo = 1; // lo always fits
$hi = $width; // hi never fits
while ($lo + 1 < $hi) {
$mid = intdiv($lo + $hi, 2);
$short = max((int) round($mid / $aspectRatio, 0, PHP_ROUND_HALF_EVEN), 1);
if ($fits($mid, $short)) {
$lo = $mid;
} else {
$hi = $mid;
}
}
return [$lo, max((int) round($lo / $aspectRatio, 0, PHP_ROUND_HALF_EVEN), 1)];
}
// Das A4-Beispiel aus „Wie Claude Bilder skaliert und auffüllt“:
[$resizedWidth, $resizedHeight] = resizedSize(1075, 1520);
echo "({$resizedWidth}, {$resizedHeight})\n"; // (924, 1307)
```
```ruby Ruby
# Visuelle Tokens, die ein Bild verbraucht: ein Token pro 28x28-Pixel-Patch.
def count_image_tokens(width, height)
width.ceildiv(28) * height.ceildiv(28)
end
# Die Größe, auf die Claude ein Bild vor dem Padding skaliert, als [width, height].
#
# Standardwerte gelten für die Standard-Auflösungsstufe. Für Modelle der
# High-Resolution-Stufe übergib max_edge: 2576, max_tokens: 4784. Bilder, die
# bereits in die Limits passen, werden unverändert zurückgegeben.
def resized_size(width, height, max_edge = 1568, max_tokens = 1568)
fits = lambda do |w, h|
w.ceildiv(28) * 28 <= max_edge &&
h.ceildiv(28) * 28 <= max_edge &&
count_image_tokens(w, h) <= max_tokens
end
return [width, height] if fits.call(width, height)
if height > width
resized_h, resized_w = resized_size(height, width, max_edge, max_tokens)
return [resized_w, resized_h]
end
# Binärsuche entlang der langen Kante nach der größten seitenverhältnis-
# treuen Größe. Die kurze Kante rundet .5 auf gerade (round(half: :even)),
# passend zur Live-API bei exakten .5-Gleichständen.
aspect_ratio = width.fdiv(height)
lo = 1 # lo always fits
hi = width # hi never fits
while lo + 1 < hi
mid = (lo + hi) / 2
short = [(mid / aspect_ratio).round(half: :even), 1].max
if fits.call(mid, short)
lo = mid
else
hi = mid
end
end
[lo, [(lo / aspect_ratio).round(half: :even), 1].max]
end
# Das A4-Beispiel aus "How Claude resizes and pads images":
p resized_size(1075, 1520) # => [924, 1307]
```
1. Skaliere das Bild auf die vom Resize-Helper zurückgegebenen Abmessungen. Wenn das Bild bereits in die Grenzen des Modells passt, gibt der Helper seine Abmessungen unverändert zurück und es ist keine Skalierung nötig.
2. [Sende das skalierte Bild](https://platform.claude.com/docs/de/build-with-claude/vision#send-images-to-claude) an die API. Fülle es nicht selbst auf. Claude übernimmt das Padding, und Padding verschiebt den Koordinatenursprung nicht.
3. Frage in deinem Prompt ausdrücklich nach Pixelkoordinaten. Zum Beispiel: *„Gib den Klickpunkt für die Schaltfläche Submit als `[x, y]` in Pixelkoordinaten zurück."*
4. Verwende die zurückgegebenen Koordinaten direkt auf dem Bild, das du gesendet hast. Wenn du normalisierte Koordinaten brauchst, teile durch die Abmessungen des gesendeten Bildes, nicht durch die Abmessungen des Originalbildes und nicht durch die aufgefüllten Abmessungen.