이 크기는 코드에서 계산하세요.
이 크기는 코드에서 계산하세요.
```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)
# 긴 변을 따라 이진 탐색하여 종횡비를 유지하면서 들어맞는
# 최대 크기를 찾습니다.
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))
# "Claude가 이미지를 리사이즈하고 패딩하는 방법"의 A4 예제:
print(resized_size(1075, 1520)) # (924, 1307)
# 리사이즈를 적용하려면 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];
}
// 긴 변을 따라 이진 탐색하여 종횡비를 유지하면서 들어맞는
// 가장 큰 크기를 찾습니다.
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)];
}
// "Claude가 이미지를 리사이즈하고 패딩하는 방법"의 A4 예시:
console.log(resizedSize(1075, 1520)); // [ 924, 1307 ]
// 리사이즈를 적용하려면 sharp 같은 이미지 라이브러리를 사용하세요:
// await sharp(input).resize(width, height).toBuffer()
```
```csharp C#
// 이미지가 소비하는 비주얼 토큰: 28x28 픽셀 패치당 토큰 1개.
static int CountImageTokens(int width, int height)
{
return (width + 27) / 28 * ((height + 27) / 28); // ceil(w/28) * ceil(h/28)
}
// Claude가 패딩 전에 이미지를 리사이즈하는 크기입니다. 기본값은
// 표준 해상도 티어용이며, 고해상도 티어 모델의 경우
// maxEdge: 2576, maxTokens: 4784를 전달하세요. 이미 제한 내에 맞는 이미지는
// 변경 없이 반환됩니다.
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);
}
// 긴 변을 따라 이진 탐색으로 종횡비를 유지하면서 맞는 최대 크기를
// 찾습니다. 짧은 변은 half-to-even 방식으로 반올림되어 정확히 .5인 경우
// 실제 API와 일치합니다(MidpointRounding.ToEven, Math.Round의 기본값).
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);
}
// "How Claude resizes and pads images"의 A4 예제:
Console.WriteLine(ResizedSize(1075, 1520)); // (924, 1307)
```
```go Go
// countImageTokens는 이미지가 소비하는 시각 토큰 수입니다: 28x28 픽셀
// 패치당 토큰 하나입니다.
func countImageTokens(width, height int) int {
return ((width + 27) / 28) * ((height + 27) / 28) // ceil(w/28) * ceil(h/28)
}
// resizedSize는 Claude가 패딩 전에 이미지를 조정하는 크기를 (width, height)로
// 반환합니다. 표준 해상도 티어에는 maxEdge 1568과 maxTokens 1568을,
// 고해상도 티어에는 2576과 4784를 전달하세요. 이미 제한 내에 맞는
// 이미지는 변경 없이 반환됩니다.
// "How Claude resizes and pads images"의 A4 예시:
// resizedSize(1075, 1520, 1568, 1568)은 (924, 1307)을 반환합니다.
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
}
// 긴 변을 따라 이진 탐색으로 종횡비를 유지하면서 맞는 최대 크기를
// 찾습니다. 짧은 변은 반올림 시 짝수로 처리(math.RoundToEven)하여
// .5 동점에서 실제 API와 일치합니다. math.Round는 올림 처리합니다.
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());
}
// 긴 변을 따라 이진 탐색으로 종횡비를 유지하며 들어맞는 최대 크기를
// 찾습니다. 짧은 변은 0.5를 짝수로 반올림하며(Math.rint),
// 정확히 .5일 때 실제 API와 일치합니다. Math.round는 올림 처리합니다.
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
// 이미지가 소비하는 시각 토큰: 28x28 픽셀 패치당 토큰 1개.
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];
}
// 긴 변을 따라 이진 탐색으로 종횡비를 유지하면서 들어맞는
// 최대 크기를 찾습니다. 짧은 변은 half-to-even 반올림
// (PHP_ROUND_HALF_EVEN)을 사용하며, 정확히 .5일 때 실제 API와 일치합니다.
$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)];
}
// "How Claude resizes and pads images"의 A4 예제:
[$resizedWidth, $resizedHeight] = resizedSize(1075, 1520);
echo "({$resizedWidth}, {$resizedHeight})\n"; // (924, 1307)
```
```ruby Ruby
# 이미지가 소비하는 시각 토큰: 28x28 픽셀 패치당 토큰 하나.
def count_image_tokens(width, height)
width.ceildiv(28) * height.ceildiv(28)
end
# Claude가 패딩 전에 이미지를 조정하는 크기([width, height] 형식).
#
# 기본값은 표준 해상도 티어용입니다. 고해상도 티어 모델의 경우
# max_edge: 2576, max_tokens: 4784를 전달하세요. 이미 제한 내에
# 맞는 이미지는 변경 없이 반환됩니다.
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
# 긴 변을 따라 이진 탐색으로 종횡비를 유지하면서 들어맞는 최대
# 크기를 찾습니다. 짧은 변은 반올림 시 짝수로 처리(round(half: :even))하여
# 정확히 .5인 경우 실제 API와 일치합니다.
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
# "How Claude resizes and pads images"의 A4 예제:
p resized_size(1075, 1520) # => [924, 1307]
```
1. 크기 조정 헬퍼가 반환한 크기로 이미지를 크기 조정하세요. 이미지가 이미 모델의 제한 내에 있으면 헬퍼는 크기를 변경하지 않고 반환하며 크기 조정이 필요하지 않습니다.
2. [크기 조정된 이미지를 API로 전송](https://platform.claude.com/docs/ko/build-with-claude/vision#send-images-to-claude)하세요. 직접 패딩하지 마세요. Claude가 패딩을 처리하며, 패딩은 좌표 원점을 이동시키지 않습니다.
3. 프롬프트에서 픽셀 좌표를 명시적으로 요청하세요. 예: *"Submit 버튼의 클릭 지점을 픽셀 좌표로 `[x, y]` 형식으로 반환하세요."*
4. 반환된 좌표를 전송한 이미지에 대해 직접 사용하세요. 정규화된 좌표가 필요한 경우, 원본 이미지의 크기나 패딩된 크기가 아닌 전송한 이미지의 크기로 나누세요.