ForHosting KIT · Images

Calculateur pixels d'écran

Calculez les pixels et la mémoire graphique d'une résolution : 1920 sur 1080 à 32 bits par pixel font 2 073 600 pixels, environ 2,07 mégapixels, et 8 294 400 octets par image. Les tailles existent aussi en Kio, Mio, Gio et Mo décimaux. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Largeur: 1 920
Hauteur: 1 080
Profondeur de couleur: 32

Vous obtenez

Résolution: 1920×1080 @ 32 bpp
Pixels totaux: 2 073 600
Mégapixels: 2,0736
Octets par pixel: 4

La planification de la mémoire graphique commence par trois nombres : la largeur de l'écran en pixels, sa hauteur, et le nombre de bits stockés par chaque pixel. Multipliez la largeur par la hauteur pour obtenir le nombre brut de pixels ; divisez par un million pour la figure marketing en mégapixels ; multipliez par les bits par pixel et divisez par huit pour la taille du framebuffer en octets. Moteurs de jeu, équipes d'UI embarquée, concepteurs de bornes et flottes de rendu cloud ont besoin de la même réponse déterministe pour dimensionner la VRAM, choisir un panneau ou comparer le Full HD au 4K et au 8K. Ce calculateur de pixels de résolution d'écran accepte largeur, hauteur et profondeur de couleur, et renvoie le total de pixels, les mégapixels, les octets par pixel et les tailles de framebuffer en octets, kibioctets, mébioctets, gibioctets et mégaoctets décimaux, plus une étiquette compacte de résolution. Lorsque la profondeur de couleur est un entier entre un et quarante-huit, il indique aussi combien de couleurs distinctes cette profondeur peut adresser.

Comment total de pixels, mégapixels et mémoire framebuffer s'articulent

Un affichage numérique est une grille rectangulaire d'échantillons adressables. La largeur est le nombre de colonnes ; la hauteur, celui des lignes ; leur produit est le nombre total de pixels d'une trame complète. Le marketing du secteur cite souvent ce produit en mégapixels en divisant par un million, si bien qu'un panneau 1920 par 1080 fait environ 2.07 mégapixels et un panneau UHD 3840 par 2160 environ 8.29 mégapixels.

La profondeur de couleur, en bits par pixel (bpp), indique la quantité d'information portée par chaque échantillon : huit bpp est courant pour des données indexées ou monovoie, seize bpp pour le high-color ou les buffers de profondeur, vingt-quatre bpp pour le RGB888 empaqueté, et trente-deux bpp pour le RGBA8888 avec alpha. La mémoire du framebuffer en octets vaut le total de pixels multiplié par les bits par pixel divisé par huit, car huit bits forment un octet.

À partir de ce total en octets vous pouvez reporter des kibioctets (divisez par 1024), mébioctets (par 1024 au carré), gibioctets (par 1024 au cube) ou mégaoctets décimaux (par un million), selon que vous parlez aux tables de pages du noyau, aux fiches GPU ou aux textes produit. Ce calculateur dérive toujours tous les champs de taille des trois mêmes entrées, afin que vous ne mélangez pas une allégation marketing de mégapixels avec un bpp inadapté en estimant la VRAM pour des UI double-buffer ou multi-couches.

Le champ optionnel colors vaut deux élevé à la profondeur entière lorsque l'exposant est sûr, ce qui rejoint le tableau classique « combien de couleurs ce mode offre-t-il » sans prétendre plus de précision que l'entier de profondeur ne le permet.

Quand calculer pixels et mémoire d'image

Les planificateurs d'affichage et de signalétique convertissent les fiches panneau en mégapixels et budgets RAM pour des lecteurs qui doivent garder un ou plusieurs buffers de trame complète résidents. Les flottes de rendu cloud et de bureau distant estiment le coût de framebuffer par session en allouant des tranches GPU ou des trames logicielles CPU. Les enseignants en infographie peuvent montrer que « le 4K est quatre fois le Full HD » en pixels et que trente-deux bpp valent quatre octets par pixel sans erreurs d'arithmétique manuelle.

Une validation échouée ne consomme pas de solde. Gardez les requêtes petites, figez en tests les champs numériques nettoyés, et vous obtenez un dimensionnement reproductible pour BOM matériel, planificateurs de capacité et démos de cours sans monter votre propre pile graphique.

Cas d’usage

Budget GPU et VRAM

Estimez les octets de framebuffer d'une seule couche pour une résolution et un bpp cibles avant de choisir un GPU ou un SoC avec assez de mémoire graphique pour une UI double-buffer.

Planification d'affichage et signalétique

Convertissez largeur × hauteur du panneau et format de pixel en mégapixels et besoins RAM pour lecteurs, bornes et murs vidéo multi-écrans.

Cours d'infographie et documentation

Montrez aux étudiants et lecteurs de documentation le total de pixels, les mégapixels et les octets par trame pour les modes courants (HD, FHD, 4K) avec un oracle déterministe.

Questions fréquentes

Comment calculer le total de pixels et les mégapixels à partir de la résolution ?

Exemple : 1920×1080 → 2,073,600 pixels ≈ 2.0736 MP.

Cela inclut-il le double buffering ou plusieurs couches ?

Non. Le résultat dimensionne un seul stockage de trame complète.

Combien de mémoire occupe une image de 1920 sur 1080 ?

À 32 bits par pixel, elle occupe 8 294 400 octets, soit environ 7,91 Mio ou 8,29 mégaoctets décimaux. La règle : nombre total de pixels multiplié par les bits par pixel, divisé par les huit bits d'un octet.

Pourquoi les Mio et les Mo diffèrent-ils ?

Un mébioctet divise le nombre d'octets deux fois par 1024, alors qu'un mégaoctet décimal le divise par un million. Les tables de pages du noyau et les fiches techniques de GPU emploient plutôt le premier, les textes commerciaux le second : les deux sont donnés.

Combien de couleurs offre une profondeur de couleur ?

Deux puissance la profondeur de couleur, indiqué quand celle-ci est un entier de 1 à 48. Avec 32 bits, on obtient 4 294 967 296 valeurs possibles, et 24 bits correspond au RGB compact courant.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

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

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre 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)

Exemple de requête

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

Exemple de réponse

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

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Le chemin gratuit du navigateur et l'API payante partagent le même module pur, de sorte que les démos pédagogiques et les scripts de production ne divergent jamais sur une figure 1920×1080 à trente-deux bits.

Contrat d'entrée, forme de la réponse et règles de validation

Des dimensions irréalistes au-delà d'un milliard de pixels par côté ou des profondeurs au-delà de cent vingt-huit bpp sont rejetées pour qu'une faute de frappe ne force pas des produits flottants absurdes. Associez les nombres à votre propre multiplicateur multi-buffers si vous double-bufferisez ou conservez des textures hors écran ; ce point de terminaison ne dimensionne qu'un seul stockage de trame complète. Envoyez en POST un corps JSON avec trois nombres finis positifs obligatoires : width (pixels en largeur), height (pixels en hauteur) et color_depth (bits par pixel). Des alias sont acceptés pour que les scripts envoient w ou width_px, h ou height_px, et bpp, bits_per_pixel, bit_depth ou depth pour la profondeur de couleur. Champs manquants, chaînes vides, NaN, Infinity, zéro et valeurs négatives échouent avec invalid_input en nommant le champ ; ces échecs ne sont pas facturés. En succès le corps renvoie width, height et color_depth nettoyés ; une chaîne de résolution telle que 1920×1080 @ 32 bpp ; total_pixels ; megapixels ; bytes_per_pixel ; framebuffer_bits ; framebuffer_bytes ; framebuffer_kib ; framebuffer_mib ; framebuffer_gib ; framebuffer_mb ; et une courte formule qui reformule les identités. Lorsque color_depth est un entier de un à quarante-huit, colors est inclus comme deux à cette puissance ; pour des profondeurs fractionnaires ou hors plage ce champ est omis plutôt que renvoyé comme null. Exemple : width 1920, height 1080, color_depth 32 donne total_pixels 2073600, megapixels 2.0736, bytes_per_pixel 4 et framebuffer_bytes 8294400 (environ 7.91 MiB pour une couche).

Où une API pixels d'écran et framebuffer justifie son coût

Les équipes embarquées et de jeux dimensionnent la mémoire GPU et système avant de figer résolution et format de pixel, et une API minuscule et déterministe évite la dérive des tableurs en comparant le 720p seize bits au 1080p trente-deux bits et aux pipelines 4K dix bits. Comme l'implémentation est parse pur de niveau A, chaque appel réussi coûte le prix de base publié $0.002, sans jetons de modèle ni réseau sortant.

Questions techniques

Comment la mémoire du framebuffer est-elle calculée ?

framebuffer_bytes = total_pixels × color_depth / 8, car color_depth est en bits par pixel. L'API renvoie aussi KiB, MiB, GiB (binaires) et MB décimal pour les feuilles de planification.

Quelles valeurs de color_depth (bpp) dois-je utiliser ?

Les valeurs courantes sont 8, 16, 24 et 32 bpp. Utilisez les bits par pixel de votre format (par exemple RGBA8888 vaut 32). La profondeur doit être un nombre fini positif jusqu'à 128.

Combien coûte le calculateur de pixels de résolution d'écran ?

L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →