ForHosting KIT · Images

Calculateur de taille RAW

Ce calculateur de taille de photo RAW estime l’espace requis par une capture de capteur non compressée lorsque vous connaissez la résolution de l’appareil en mégapixels et la profondeur de bits enregistrée par pixel.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Il convertit ces deux caractéristiques en un nombre approximatif d’octets, de mégaoctets décimaux et de mébioctets binaires. Le résultat facilite la planification du stockage, l’estimation des transferts et la comparaison des flux photographiques. Il s’agit d’une estimation mathématique transparente, et non d’une prédiction de chaque format RAW propriétaire, car les fichiers réels peuvent intégrer compression, métadonnées, remplissage, aperçus ou conditionnement propre au fabricant.

Saisissez la résolution du capteur et la profondeur enregistrée

Commencez par le nombre effectif de mégapixels utilisé pour la photo, qui ne correspond pas toujours au chiffre commercial arrondi inscrit sur le boîtier. Une valeur de 24 mégapixels représente 24,000,000 pixels de capteur. Indiquez ensuite le nombre de bits non compressés attribués à chaque échantillon de pixel. Les valeurs courantes sont 12, 14 et 16 bits, mais le calculateur accepte toute valeur finie positive afin de couvrir aussi les capteurs scientifiques et industriels inhabituels. La profondeur de bits ne désigne pas les bits par canal d’une image RGB finale. Un capteur Bayer classique enregistre un échantillon filtré par photosite avant dématriçage ; l’estimation emploie donc un échantillon par pixel. Les deux champs sont obligatoires et positifs. Les décimales sont acceptées, par exemple pour une résolution effective annoncée de 24.2 mégapixels.

Comprenez le calcul et les unités affichées

L’outil multiplie les mégapixels par 1,000,000 pour obtenir le nombre de pixels, multiplie ce résultat par la profondeur de bits, puis divise par huit pour convertir les bits en octets. Un échantillon de 16 bits occupe deux octets non compressés, tandis qu’un échantillon de 12 bits étroitement conditionné occupe en moyenne un octet et demi. La sortie fournit les pixels et les octets estimés afin que vous puissiez vérifier le calcul. Elle indique également les mégaoctets décimaux, avec un MB égal à 1,000,000 octets, et les mébioctets binaires, avec un MiB égal à 1,048,576 octets. Les fabricants emploient souvent les unités décimales, alors que certains systèmes affichent les unités binaires. L’arrondi sert uniquement à produire un JSON stable et lisible ; aucune compression, marge, miniature ou métadonnée n’est ajoutée.

Exploitez l’estimation pour planifier le stockage

Considérez le résultat comme une base pour une capture non compressée, puis adaptez-le au flux réel que vous préparez. Multipliez le nombre d’octets par photo par le nombre de prises de vue prévu pour estimer une séance, une rafale, une carte mémoire, une archive ou une sauvegarde. Prévoyez une marge pour le système de fichiers, les catalogues, les fichiers annexes, les aperçus et les retouches. Les RAW réels peuvent être plus petits avec compression, ou plus grands si les échantillons sont complétés dans des mots de 16 bits, si les aperçus ou métadonnées sont volumineux, ou si des pixels hors zone nominale sont conservés. Les modes multivues et certains capteurs spécialisés peuvent aussi enregistrer plusieurs échantillons par pixel final. Pour une prévision précise, comparez l’estimation à des fichiers issus du même appareil, mode RAW, recadrage et micrologiciel.

Cas d’usage

Choisir la capacité des cartes mémoire

Estimez l’espace non compressé par exposition avant de déterminer le nombre de cartes nécessaire pour un événement, une séance animalière ou une journée en studio.

Planifier archives et sauvegardes

Transformez les caractéristiques de l’appareil en référence cohérente pour dimensionner stockage principal, copies locales et copies hors site.

Comparer la charge de plusieurs appareils

Comparez la charge approximative de capteurs de résolutions et profondeurs différentes sans dépendre d’une compression propriétaire.

Questions fréquentes

Quel est le prix du calculateur ?

Le tarif de l’API est de $0.002 par requête. Le calculateur du navigateur exécute le même calcul déterministe sans téléverser de photo.

Pourquoi mon RAW réel est-il plus petit que l’estimation ?

De nombreux appareils appliquent une compression RAW avec ou sans perte. Le calculateur estime volontairement une base non compressée sans deviner de taux.

Pourquoi un fichier RAW réel peut-il être plus grand ?

Les métadonnées, aperçus JPEG, remplissages de ligne, pixels masqués et mots de stockage plus larges peuvent ajouter des octets.

Un RAW 14 bits utilise-t-il toujours exactement 14 bits par échantillon ?

Non. Certains formats conditionnent étroitement les échantillons, tandis que d’autres les complètent dans des unités plus larges. L’estimation suppose un conditionnement étroit.

Quelle différence existe-t-il entre MB et MiB ?

Un MB décimal vaut 1,000,000 octets. Un MiB binaire vaut 1,048,576 octets ; les valeurs numériques diffèrent donc pour un même fichier.

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/image/raw-file-estimate-size

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/image/raw-file-estimate-size \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"megapixels":24,"bit_depth":14}'

const res = await fetch("https://api.kit.forhosting.com/image/raw-file-estimate-size", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "megapixels": 24,
    "bit_depth": 14
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/raw-file-estimate-size",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "megapixels": 24,
    "bit_depth": 14
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/raw-file-estimate-size", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"megapixels":24,"bit_depth":14}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"megapixels":24,"bit_depth":14}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/raw-file-estimate-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

{
  "megapixels": 24,
  "bit_depth": 14
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.raw_file_estimate_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

par requête$0.002

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

Limites

`max_mb`	15
`max_megapixels`	12

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.

Consulter la documentation complète du KIT →

Lancer gratuitement