Calculateur de taille d'image
Saisissez largeur, hauteur et profondeur de bits pour obtenir la taille non compressée : 1920 sur 1080 pixels en 24 bits par pixel font 6 220 800 octets, soit 6,2208 Mo. Utile avant d'exporter un BMP ou un TIFF, ou de réserver mémoire et stockage. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Largeur
- 1 920
- Hauteur
- 1 080
- Profondeur de bits
- 24
- Octets par pixel
- 3
- Nombre de pixels
- 2 073 600
- Mégapixels
- 2,0736
- Taille (octets)
- 6 220 800
La taille d'un fichier image non compressé est le nombre d'octets qu'occupe un raster lorsque chaque pixel est stocké à une profondeur de bits fixe, sans compression. Photographes, artistes de jeu, techniciens d'impression et ingénieurs backend cherchent un calculateur de taille de fichier image lorsqu'ils ont besoin de ce chiffre avant d'allouer de la RAM, de choisir un palier de stockage ou de décider si un tampon de quatre kilopixels à trente-deux bits tiendra sur une carte. JPEG, PNG, WebP et AVIF seront en général plus petits car ils écartent ou encodent la redondance ; BMP, TIFF non compressé, dumps bruts d'appareil et framebuffers GPU suivent cette forme fermée.
Comment se calcule la taille d'une image non compressée
Une image numérique est une grille rectangulaire de pixels. La largeur est le nombre d'échantillons sur une ligne. La hauteur est le nombre de lignes dans le cadre.
La profondeur de bits indique combien de bits décrivent chaque pixel, et non chaque canal de couleur : huit bits pour le gris usuel, vingt-quatre bits pour du RGB 8 bits, trente-deux bits pour du RGBA 8 bits, quarante-huit bits pour du RGB 16 bits. Une trame Full HD RGB à 1920 par 1080 par 24 bits fait 1920 fois 1080 fois trois octets, soit 6,220,800 octets, c'est-à-dire 6.2208 mégaoctets SI.
Une trame 4K UHD RGB à 3840 par 2160 par 24 bits a quatre fois ce nombre de pixels et donc quatre fois les octets. Les formats empaquetés 1 bit et 4 bits suivent la même identité comme charge théorique ; le véritable remplissage de lignes BMP n'est que quelques octets par balayage et est omis ici, comme un en-tête WAV l'est dans une estimation audio. Les codecs compressés sortent du périmètre car leur taille dépend du contenu et des réglages d'encodeur qu'aucune équation fermée ne peut garantir.
Si vous avez besoin d'un plafond de stockage pour un export BMP, un TIFF non compressé ou un envoi GPU, le produit raster est le chiffre qui compte, et ce calculateur le renvoie avec les octets et mégaoctets qui l'ont produit.
Où un calculateur de taille d'image rend service
Les ateliers d'impression dimensionnent les dumps TIFF CMYK avant de lancer le RIP d'une affiche afin qu'une feuille à trois cents dpi et vingt-quatre bits ne fasse pas déborder le disque du RIP. Les ingénieurs de jeu dimensionnent l'empreinte des textures non compressées pour l'envoi GPU, où un atlas 4096 par 4096 RGBA32 est une charge connue avant toute compression GPU.
Les opérateurs caméra et drone estiment des tampons proches du RAW lorsqu'ils ne connaissent que le nombre de pixels du capteur et la profondeur de bits ; ce calculateur les convertit aussitôt en mégaoctets. Les enseignants de l'image numérique montrent que doubler la résolution linéaire quadruple la taille du fichier alors que doubler la profondeur de bits ne fait que la doubler, et le champ formula énonce cette identité. Une validation en échec ne consomme pas le solde.
Gardez les requêtes petites, figez les mégaoctets arrondis dans les tests, et vous obtenez des chiffres de stockage reproductibles pour les chaînes d'images fixes, les démonstrations de cours et les workers en bordure, sans dresser votre propre infrastructure d'analyse média.
Cas d’usage
Dimensionner un export BMP ou TIFF avant d'exporter
Convertissez la largeur, la hauteur et la profondeur de bits prévues en octets et mégaoctets afin que le disque restant, la carte SD ou le seau d'object store aient de la place pour le raster non compressé que vous comptez écrire.
Questions fréquentes
La profondeur de bits est-elle par pixel ou par canal ?
Par pixel. Le RGB 24 bits fait trois octets par pixel ; le RGBA 32 bits en fait quatre.
Le résultat inclut-il la compression JPEG ou PNG ?
Non. Le chiffre est la charge raster non compressée. Les tailles JPEG, PNG, WebP et AVIF dépendent de l'encodeur et de l'image et sortent du périmètre. Le remplissage de lignes BMP et les en-têtes de conteneur de quelques dizaines d'octets sont omis.
Comment la taille non compressée est-elle calculée ?
La largeur multipliée par la hauteur donne le nombre de pixels ; on multiplie par la profondeur de bits puis on divise par huit pour obtenir des octets, et par un million pour des mégaoctets. Le remplissage des lignes et l'en-tête du fichier ne sont pas comptés.
Quelle profondeur de bits saisir pour les images courantes ?
Indiquez le nombre de bits par pixel, à savoir 8 pour des niveaux de gris classiques, 24 pour du RVB 8 bits, 32 pour du RVBA 8 bits et 48 pour du RVB 16 bits. Les formats compacts à 1 ou 4 bits suivent la même règle.
Pourquoi doubler la résolution quadruple-t-il la taille ?
Parce que la largeur et la hauteur doublent toutes les deux, donc le nombre de pixels est multiplié par quatre : une image de 3840 sur 2160 pèse quatre fois plus qu'une image de 1920 sur 1080. Doubler la profondeur de bits, de 24 à 48, ne fait que doubler la taille.
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
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/date/image-file-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"width":1920,"height":1080,"bit_depth":24}'const res = await fetch("https://api.kit.forhosting.com/date/image-file-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"width": 1920,
"height": 1080,
"bit_depth": 24
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/image-file-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"width": 1920,
"height": 1080,
"bit_depth": 24
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/image-file-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"width":1920,"height":1080,"bit_depth":24}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"width":1920,"height":1080,"bit_depth":24}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/image-file-size", 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,
"bit_depth": 24
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.image_file_size",
"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
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
Cet outil prend trois nombres finis positifs — largeur en pixels, hauteur en pixels et profondeur de bits par pixel — et renvoie size_bytes avec size_mb. L'identité est width fois height fois bit_depth divisé par huit ; diviser par un million donne des mégaoctets SI. Zéro, négatifs, NaN et Infinity échouent avec invalid_input et ne sont pas facturés.
Comment se calcule la taille d'une image non compressée
Un octet vaut huit bits, donc les octets par pixel valent bit_depth divisé par huit. La charge non compressée est donc width fois height fois les octets par pixel, ce qui équivaut à width fois height fois bit_depth divisé par huit. Doubler la profondeur de 24 à 48 double size_bytes lorsque la grille de pixels ne change pas.
Contrat d'entrée, unités et champs de réponse
Width et height sont de même des nombres finis positifs plutôt que des entiers forcés, de sorte que des rasters de recherche fractionnaires se calculent encore. Associez la réponse à votre propre encodeur si vous avez besoin d'une estimation compressée ; ce point de terminaison n'indique que la taille raster non compressée et n'inspecte pas un fichier déjà exporté. Envoyez un corps JSON avec trois nombres finis positifs obligatoires : width en pixels, height en pixels et bit_depth en bits par pixel. Des alias sont acceptés pour que les synonymes courants restent valides : w, image_width, px_width et cols pour width ; h, image_height, px_height et rows pour height ; bits, bpp, bits_per_pixel, depth et color_depth pour bit_depth. Chaque champ peut arriver comme nombre JSON ou comme chaîne numérique. Champs manquants, chaînes vides, NaN, Infinity, zéro et valeurs négatives échouent avec invalid_input en nommant le champ et ne sont pas facturés. Il n'y a pas d'enum sur bit_depth car le contrat est toute largeur finie positive, y compris 1, 8, 16, 24, 32 et 48, et non une liste fermée de préréglages de couleur. En cas de succès, le corps répète les trois entrées, bytes_per_pixel, pixel_count, megapixels, size_bytes, size_kb, size_mb, size_mib, plus les chaînes formula et note. Exemple : width 1920, height 1080, bit_depth 24 renvoie 6220800 dans size_bytes et 6.2208 dans size_mb.
Où un calculateur de taille d'image rend service
Les scripts de sauvegarde et d'ingestion peuvent refuser un export BMP prévu qui dépasserait un quota d'object store en calculant d'abord size_mb. Parce que l'implémentation est du parse pur de palier A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant.
Cas d'intégration
Enseigner comment le stockage raster évolue
Montrez aux élèves que doubler la résolution linéaire quadruple la taille non compressée alors que doubler la profondeur de bits ne fait que la doubler, avec la même formule que l'API renvoie dans le champ formula.
Précontrôler les quotas GPU, RIP et d'archive
Les chaînes de textures, les RIP d'impression et les sauvegardes peuvent refuser un fichier non compressé prévu qui dépasserait un quota en calculant d'abord size_mb, sans ouvrir d'encodeur ni lire un fichier.
Questions techniques
Comment calcule-t-on la taille d'un fichier image à partir de la largeur, de la hauteur et de la profondeur de bits ?
Envoyez des nombres finis positifs pour width (pixels), height (pixels) et bit_depth (bits par pixel). La charge est width × height × (bit_depth / 8) octets ; size_mb est ce compte divisé par un million.
Quelle est la différence entre size_mb et size_mib ?
size_mb utilise les mégaoctets SI (1 MB = 1,000,000 octets), le résultat principal. size_mib utilise les mébioctets (1 MiB = 1,048,576 octets), plus proches de ce que certains systèmes d'exploitation affichent comme taille de fichier.
Combien coûte le calculateur de taille de fichier image ?
L'outil du navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée non valide n'est pas facturée.