ForHosting KIT · Bilder bearbeiten & analysieren

Bildschirm-Pixel-Rechner

Ermitteln Sie Pixel und Grafikspeicher einer Auflösung: 1920 mal 1080 bei 32 Bit pro Pixel ergibt 2.073.600 Pixel, etwa 2,07 Megapixel, und 8.294.400 Bytes pro Bild. Die Größen gibt es auch in KiB, MiB, GiB und dezimalen MB. Kostenlos in Ihrem Browser.

Kostenlos
Läuft in Ihrem Browser
Ohne Anmeldung
Ihre Daten bleiben auf Ihrem Gerät

Im Browser ausführen – kostenlos API ansehen

Nutzen Sie es über WebAPIE-MailTelegramApp bald

Rechenbeispiel

Wenn Sie eingeben

Breite: 1.920
Höhe: 1.080
Farbtiefe: 32

Erhalten Sie

Auflösung: 1920×1080 @ 32 bpp
Pixel insgesamt: 2.073.600
Megapixel: 2,0736
Bytes pro Pixel: 4

Die Planung von Grafikspeicher beginnt mit drei Zahlen: wie breit der Bildschirm in Pixeln ist, wie hoch er ist und wie viele Bits jedes Pixel speichert. Multiplizieren Sie Breite mit Höhe und Sie erhalten die rohe Pixelanzahl; teilen Sie durch eine Million für die Marketing-Angabe in Megapixeln; multiplizieren Sie mit Bits pro Pixel und teilen Sie durch acht für die Framebuffer-Größe in Bytes. Spiel-Engines, Embedded-UI-Teams, Kiosk-Designer und Cloud-Rendering-Flotten brauchen dieselbe deterministische Antwort beim Dimensionieren von VRAM, bei der Wahl eines Panels oder beim Vergleich von Full HD mit 4K und 8K. Dieser Bildschirm-Pixel-Rechner nimmt Breite, Höhe und Farbtiefe entgegen und liefert Gesamtpixel, Megapixel, Bytes pro Pixel sowie Framebuffer-Größen in Bytes, Kibibytes, Mebibytes, Gibibytes und dezimalen Megabytes plus eine kompakte Auflösungsbezeichnung. Ist die Farbtiefe eine ganze Zahl zwischen eins und achtundvierzig, meldet er auch, wie viele verschiedene Farben diese Tiefe adressieren kann.

Wie Gesamtpixel, Megapixel und Framebuffer-Speicher zusammenhängen

Ein digitales Display ist ein rechteckiges Raster adressierbarer Abtastwerte. Die Breite ist die Anzahl der Spalten; die Höhe die der Zeilen; ihr Produkt ist die Gesamtpixelzahl eines Vollbilds. Das Branchenmarketing gibt dieses Produkt oft in Megapixeln an, indem es durch eine Million teilt: ein 1920-mal-1080-Panel liegt bei etwa 2.07 Megapixeln, ein UHD-Panel 3840 mal 2160 bei etwa 8.29 Megapixeln.

Die Farbtiefe in Bits pro Pixel (bpp) sagt, wie viel Information jeder Abtastwert trägt: acht bpp ist üblich für indizierte oder einkanalige Daten, sechzehn bpp für High-Color oder Tiefenpuffer, vierundzwanzig bpp für gepacktes RGB888 und zweiunddreißig bpp für RGBA8888 mit Alpha. Der Framebuffer-Speicher in Bytes ist Gesamtpixel mal Bits pro Pixel geteilt durch acht, weil acht Bits ein Byte bilden.

Aus dieser Byte-Gesamtsumme können Sie Kibibytes (teilen durch 1024), Mebibytes (durch 1024 im Quadrat), Gibibytes (durch 1024 im Kubik) oder dezimale Megabytes (durch eine Million) berichten, je nachdem ob Sie mit Kernel-Seitentabellen, GPU-Datenblättern oder Produkttexten sprechen. Dieser Rechner leitet jedes Größenfeld stets aus denselben drei Eingaben ab, damit Sie eine Marketing-Megapixel-Angabe nicht mit unpassendem bpp vermischen, wenn Sie VRAM für doppelt gepufferte oder mehrschichtige UIs schätzen.

Das optionale Feld colors ist zwei hoch die ganzzahlige Farbtiefe, wenn der Exponent sicher ist — passend zur klassischen Tabelle «wie viele Farben bietet dieser Modus», ohne mehr Präzision zu behaupten, als die Tiefen-Ganzzahl erlaubt.

Wann sich Pixel- und Speicherrechnung lohnt

Display- und Digital-Signage-Planer wandeln Panel-Datenblätter in Megapixel und RAM-Budgets für Mediaplayer um, die einen oder mehrere Vollbild-Buffer resident halten müssen. Cloud-Rendering- und Remote-Desktop-Flotten schätzen die Framebuffer-Kosten pro Sitzung bei der Zuweisung von GPU-Slices oder CPU-Software-Frames. Lehrende der Computergrafik können zeigen, dass «4K viermal Full HD» in Pixeln ist und dass zweiunddreißig bpp vier Bytes pro Pixel sind — ohne manuelle Rechenfehler.

Fehlgeschlagene Validierung wird nicht berechnet. Halten Sie Anfragen klein, pinnen Sie bereinigte Zahlenfelder in Tests, und Sie erhalten reproduzierbare Dimensionierung für Hardware-BOMs, Kapazitätsplaner und Unterrichtsdemos, ohne einen eigenen Grafik-Stack aufzubauen.

Anwendungsfälle

GPU- und VRAM-Budgetierung

Schätzen Sie die Framebuffer-Bytes einer einzelnen Schicht für Zielauflösung und bpp, bevor Sie eine GPU oder ein SoC mit genug Grafikspeicher für doppelt gepufferte UI wählen.

Display- und Signage-Planung

Wandeln Sie Panel-Breite × Höhe und Pixelformat in Megapixel und RAM-Bedarf für Mediaplayer, Kioske und Mehrschirm-Videowände um.

Grafikunterricht und Dokumentation

Zeigen Sie Studierenden und Dokumentationslesern Gesamtpixel, Megapixel und Bytes pro Frame für gängige Modi (HD, FHD, 4K) mit einem deterministischen Orakel.

Häufige Fragen

Wie berechne ich Gesamtpixel und Megapixel aus der Auflösung?

Beispiel: 1920×1080 → 2,073,600 Pixel ≈ 2.0736 MP.

Wie viel Speicher braucht ein Bild mit 1920 mal 1080?

Bei 32 Bit pro Pixel sind es 8.294.400 Bytes, etwa 7,91 MiB oder 8,29 dezimale Megabytes. Die Regel lautet Gesamtpixel mal Bit pro Pixel, geteilt durch acht Bit pro Byte.

Ist Doppelpufferung im Ergebnis enthalten?

Nein. Jede Größe gilt für ein einzelnes Vollbild. Hält Ihre Oberfläche zwei Puffer oder mehrere Ebenen im Speicher, multiplizieren Sie den Wert selbst mit dieser Anzahl.

Warum unterscheiden sich MiB und MB?

Ein Mebibyte teilt die Bytezahl zweimal durch 1024, ein dezimales Megabyte teilt sie durch eine Million. Kernel-Seitentabellen und GPU-Datenblätter nutzen eher das erste, Produkttexte das zweite, deshalb stehen beide da.

Wie viele Farben ergibt eine Farbtiefe?

Zwei hoch Farbtiefe, angegeben, wenn die Tiefe eine ganze Zahl von 1 bis 48 ist. Mit 32 Bit gibt es 4.294.967.296 mögliche Werte, und 24 Bit ist das übliche gepackte RGB.

Für Entwickler — API-Zugang

Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.

Endpunkt

POSThttps://api.kit.forhosting.com/dev/screen-pixels

Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.

Aufruf aus Ihrem Stack

curl -X POST https://api.kit.forhosting.com/dev/screen-pixels \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"width":1920,"height":1080,"color_depth":32}'

const res = await fetch("https://api.kit.forhosting.com/dev/screen-pixels", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "width": 1920,
    "height": 1080,
    "color_depth": 32
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/screen-pixels",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "width": 1920,
    "height": 1080,
    "color_depth": 32
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/screen-pixels", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"width":1920,"height":1080,"color_depth":32}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"width":1920,"height":1080,"color_depth":32}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/screen-pixels", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Beispiel-Anfrage

{
  "width": 1920,
  "height": 1080,
  "color_depth": 32
}

Beispiel-Antwort

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

Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.

Preis

pro Anfrage$0.002

Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.

Fehler

HTTP	Code	Bedeutung
`401`	`unauthorized`	Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer).
`402`	`insufficient_balance`	Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht.
`404`	`unknown_type`	Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog.
`429`	`rate_limited`	Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt.

Technische Hinweise

Der kostenlose Browser-Pfad und die bezahlte API teilen dasselbe reine Modul, sodass Lehrdemos und Produktionsskripte nie bei einer 1920×1080-bei-zweiunddreißig-Bit-Zahl auseinanderlaufen.

Eingabevertrag, Antwortform und Validierungsregeln

Unrealistisch riesige Abmessungen über einer Milliarde Pixel pro Seite oder Farbtiefen über einhundertachtundzwanzig bpp werden abgelehnt, damit ein Tippfehler keine absurden Gleitkomma-Produkte erzwingt. Kombinieren Sie die Zahlen mit Ihrem eigenen Multi-Buffer-Faktor, wenn Sie doppelt puffern oder Offscreen-Texturen halten; dieser Endpunkt dimensioniert nur einen Vollbild-Speicher. Senden Sie per POST einen JSON-Body mit drei erforderlichen endlichen positiven Zahlen: width (Pixel in der Breite), height (Pixel in der Höhe) und color_depth (Bits pro Pixel). Aliase sind akzeptiert, damit Skripte w oder width_px, h oder height_px sowie bpp, bits_per_pixel, bit_depth oder depth für die Farbtiefe senden können. Fehlende Felder, leere Zeichenketten, NaN, Infinity, Null und negative Werte scheitern mit invalid_input unter Nennung des Feldes; diese Fehler werden nicht abgerechnet. Bei Erfolg spiegelt der Body die bereinigten width, height und color_depth; eine Auflösungszeichenkette wie 1920×1080 @ 32 bpp; total_pixels; megapixels; bytes_per_pixel; framebuffer_bits; framebuffer_bytes; framebuffer_kib; framebuffer_mib; framebuffer_gib; framebuffer_mb; und eine kurze Formel, die die Identitäten erneut festhält. Ist color_depth eine ganze Zahl von eins bis achtundvierzig, wird colors als zwei hoch diese Potenz aufgenommen; bei gebrochenen oder außerhalb des Bereichs liegenden Tiefen wird das Feld weggelassen statt als null zurückgegeben. Beispiel: width 1920, height 1080, color_depth 32 ergibt total_pixels 2073600, megapixels 2.0736, bytes_per_pixel 4 und framebuffer_bytes 8294400 (etwa 7.91 MiB für eine Schicht).

Wo eine Bildschirm-Pixel- und Framebuffer-API ihren Nutzen zeigt

Embedded- und Spieleteams dimensionieren GPU- und Systemspeicher, bevor sie Auflösung und Pixelformat festlegen, und eine winzige deterministische API verhindert Tabellen-Drift beim Vergleich von 720p mit sechzehn Bit gegen 1080p mit zweiunddreißig Bit und 4K-Zehn-Bit-Pipelines. Weil die Implementierung reines Parse der Stufe A ist, kostet jeder erfolgreiche Aufruf den veröffentlichten Basispreis $0.002, ohne Modell-Tokens und ohne ausgehendes Netz.

Technische Fragen

Wie wird der Framebuffer-Speicher berechnet?

framebuffer_bytes = total_pixels × color_depth / 8, weil color_depth Bits pro Pixel sind. Die API liefert außerdem KiB, MiB, GiB (binär) und dezimale MB für Planungsblätter.

Welche color_depth-(bpp)-Werte sollte ich verwenden?

Übliche Werte sind 8, 16, 24 und 32 bpp. Verwenden Sie die Bits pro Pixel Ihres Pixelformats (zum Beispiel ist RGBA8888 32). Die Tiefe muss eine endliche positive Zahl bis 128 sein.

Enthält das Double-Buffering oder mehrere Schichten?

Nein. Das Ergebnis dimensioniert einen einzigen Vollbild-Speicher. Multiplizieren Sie framebuffer_bytes außerhalb der API mit Ihrer Buffer- oder Schichtanzahl, wenn Sie doppelt puffern oder mehrere Schichten komponieren.

Was kostet der Bildschirm-Pixel-Rechner?

Das Browser-Werkzeug ist kostenlos. API-Anfragen nutzen das vorausbezahlte KIT-Guthaben zu $0.002 pro erfolgreichem Aufruf; ungültige Eingabe wird nicht abgerechnet.

Vollständige KIT-Dokumentation lesen →