ForHosting KIT · Voyages et géographie

Cellules enfants geohash

Le geohash u4pruyd se divise en 32 enfants, de u4pruyd0 à u4pruydz, chacun plus long d'un caractère, l'ensemble couvrant toute la cellule parente. Collez un geohash pour obtenir tous les enfants dans le même ordre fixe, pour l'indexation ou la carte. 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

Geohash: u4pruyd

Vous obtenez

Précision: 7
Précision de l'enfant: 8
Quantité: 32

L’outil de cellules enfants geohash prend un geohash existant et subdivise sa zone rectangulaire en trente-deux cellules au niveau de précision suivant. Il renvoie chaque enfant en ajoutant les caractères de l’alphabet base32 geohash canonique dans un ordre stable. Le résultat convient ainsi à l’indexation, la cartographie, aux tests et aux parcours récursifs. L’entrée est normalisée en minuscules ; les caractères invalides et les longueurs non prises en charge produisent une erreur explicite. Le calcul est déterministe, sans réseau, hasard ni dépendance à l’heure.

Principe de la subdivision geohash

Un geohash représente une cellule géographique rectangulaire au moyen d’une suite entrelacée de bits de longitude et de latitude. Chaque caractère apporte cinq bits supplémentaires : son ajout divise donc la cellule parente en trente-deux rectangles plus petits. Ces rectangles sont exactement ses enfants immédiats ; nul besoin de décoder des coordonnées, d’arrondir ou d’effectuer une recherche spatiale pour les nommer.

Cette capacité ajoute au parent normalisé chaque caractère de l’alphabet geohash canonique, <code>0123456789bcdefghjkmnpqrstuvwxyz</code>. Pour le parent <code>u4pruyd</code>, les premiers enfants sont <code>u4pruyd0</code>, <code>u4pruyd1</code>, puis les suivants, jusqu’au dernier, <code>u4pruydz</code>. Chaque chaîne conserve le préfixe parent et compte exactement un caractère de plus.

Ensemble, les trente-deux résultats couvrent toute la cellule parente, sans vide ni chevauchement à cette précision. Leur ordre suit la valeur des caractères et non un parcours géographique. Utilisez cette opération pour obtenir le niveau suivant complet d’une hiérarchie geohash, plutôt que les cellules voisines situées autour du parent à précision égale.

Exploiter les cellules enfants dans un système spatial

La génération d’enfants convient aux applications spatiales qui stockent ou explorent les positions sous forme d’arbre de préfixes. Un service cartographique peut partir d’une grande cellule, demander ses enfants, puis ne subdiviser que les branches contenant assez de données. Une tâche de maintenance peut transformer un compartiment grossier en clés plus fines avant de redistribuer les enregistrements.

Les tests peuvent vérifier grâce à la sortie ordonnée qu’un encodeur, un index de préfixes ou un parcours récursif accepte tous les suffixes légaux sans jamais admettre de caractère base32 interdit. Cette opération nomme seulement les cellules : elle ne calcule pas leurs limites de latitude et longitude, ne détecte pas lesquelles contiennent des données et ne renvoie pas les huit voisines adjacentes. Préférez un décodeur pour les coordonnées ou emprises, et un outil de voisinage pour les cellules contiguës à précision égale.

Pour subdiviser récursivement, réutilisez un enfant jusqu’à la précision souhaitée en respectant la limite d’entrée. Chaque niveau multipliant les feuilles par trente-deux, maîtrisez la récursion côté client et évitez les arbres inutilement volumineux.

Cas d’usage

Construire un arbre de préfixes geohash

Développez les compartiments spatiaux choisis niveau par niveau tout en conservant les clés dans un ordre canonique reproductible.

Affiner les cellules d’agrégation cartographique

Remplacez une vaste région par toutes ses cellules de précision suivante avant de calculer des statistiques plus fines.

Tester des bibliothèques geohash

Produisez tous les suffixes autorisés pour vérifier les parcours de préfixes, la validation et les invariants de comptage.

Questions fréquentes

Combien un geohash possède-t-il de cellules enfants ?

Il possède exactement 32 enfants immédiats, car un caractère geohash ajouté apporte cinq bits et représente 32 valeurs possibles.

Les enfants sont-ils classés géographiquement ?

Non. Ils suivent l’ordre canonique des caractères base32, stable mais différent d’un balayage nord-sud ou ouest-est.

La subdivision modifie-t-elle la zone couverte ?

Les 32 enfants couvrent ensemble la même zone que le parent. Chacun couvre une subdivision au niveau de précision suivant.

Quels caractères sont autorisés ?

Les caractères valides sont 0–9 et bcdefghjkmnpqrstuvwxyz. Les lettres a, i, l et o sont exclues de l’alphabet geohash.

Comment descendre de plus d'un niveau ?

Renvoyez n'importe quel enfant et subdivisez-le à nouveau, jusqu'à la précision voulue, dans la limite de 12 caractères. Chaque niveau multiplie le nombre de cellules par 32 : ne développez que les branches utiles.

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/geo/geohash-children

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/geo/geohash-children \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"geohash":"u4pruyd"}'

const res = await fetch("https://api.kit.forhosting.com/geo/geohash-children", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "geohash": "u4pruyd"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/geo/geohash-children",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "geohash": "u4pruyd"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/geo/geohash-children", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"geohash":"u4pruyd"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"geohash":"u4pruyd"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geo/geohash-children", 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

{
  "geohash": "u4pruyd"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "geo.geohash_children",
  "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_precision 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.

Notes techniques

Validation de l’entrée et contenu de la réponse

Les espaces aux extrémités sont supprimés et les majuscules converties en minuscules avant validation. Une valeur valide contient entre un et douze caractères de l’alphabet base32 geohash. Les valeurs absentes, les types autres qu’une chaîne, les chaînes vides après nettoyage et les entrées trop longues sont également refusés. Aucun champ facultatif nul n’est émis. Envoyez un objet JSON contenant la chaîne obligatoire <code>geohash</code>. Les alias courts <code>hash</code> et <code>gh</code> restent acceptés pour la compatibilité, mais les nouvelles intégrations devraient employer le nom canonique. Celui-ci exclut volontairement a, i, l et o afin de limiter les confusions visuelles ; chacune de ces lettres entraîne une réponse <code>invalid_input</code>. Une réponse réussie contient <code>geohash</code>, le parent normalisé ; <code>precision</code>, sa longueur ; <code>child_precision</code>, supérieure d’une unité ; <code>children</code>, le tableau ordonné des trente-deux enfants ; et <code>count</code>, toujours égal à trente-deux. Une requête API réussie coûte $0.002, tandis que l’outil du navigateur exécute gratuitement le même calcul pur en local.

Questions techniques

Quel est le coût d’une requête API ?

Chaque requête API réussie coûte $0.002. La version navigateur exécute gratuitement et localement le même calcul déterministe.

Consulter la documentation complète du KIT →

Lancer gratuitement