Richard Dern 14a7dc8561 Analyse la réutilisation des têtes de minifigs

2025-12-02 22:33:13 +01:00

27 KiB

Raw Blame History

Étude de sets LEGO

Présentation du projet

Ce projet vise à étudier statistiquement des sets LEGO. Le projet est construit autour du thème Jurassic World, mais le paramétrage des scripts devrait permettre d'étudier les sets de n'importe quel thème LEGO.

L'objectif est de mettre en lumière des éléments spécifiques, tels que des pièces rares, des couleurs originales, ou des minifigs particulières. Cette étude doit permettre de piquer la curiosité en explorant l'évolution de notre thème préféré à travers le temps.

Cette étude a pour ambition de satisfaire ma curiosité, mon désir d'approfondir un sujet qui m'est cher, et mon besoin compulsif d'exhaustivité. Découvrir qu'un nouveau set LEGO Jurassic World, posséder le set, le construire, puis l'exposer, jouer avec, recréer l'ambiance des œuvres originales, en imprégner mon bureau ; tout cela n'est qu'une partie de cet univers, qui recèle d'autres informations à découvrir et explorer.

Enfin, sur un plan plus technique, je souhaite améliorer mes compétences en python sur des sujets concrets que je maitrise, en l'exploitant notamment avec des librairies destinées à la production de statistiques.

Organisation actuelle

Les fichiers téléchargés ou produits sont rangés dans data/ :
- data/raw/ contient les données brutes Rebrickable (fichiers compressés et décompressés).
- data/intermediate/ regroupe les transformations intermédiaires (filtres, enrichissements, rapports).
- data/final/ stocke les exports finaux prêts pour les statistiques et graphiques.
Les scripts créent automatiquement les répertoires parents nécessaires pour leurs sorties.
Les scripts d'orchestration se trouvent dans scripts/.
Le code mutualisé est rangé dans lib/.

Ordre d'exécution

Étape 1 : récupérer les thèmes Rebrickable

source .venv/bin/activate
python -m scripts.download_themes

Le script télécharge le fichier compressé themes.csv.gz depuis Rebrickable vers data/raw/, le décompresse immédiatement en themes.csv, supprime l'archive .gz, et ne retélécharge pas le fichier si themes.csv a moins de 7 jours.

Étape 2 : définir les thèmes à étudier

Renseigner dans .env la liste des identifiants de thèmes (séparés par des virgules). Pour l'univers Jurassic Park / Jurassic World, les identifiants relevés dans data/raw/themes.csv sont :

274 (Jurassic Park III, parent Studios)
602 (Jurassic World, parent racine)
620 (Jurassic World: Fallen Kingdom, parent Juniors)

L'identifiant 722 (Jurassic World, parent Duplo) est volontairement ignoré.

Étape 3 : récupérer les sets Rebrickable

source .venv/bin/activate
python -m scripts.download_sets

Le script télécharge le fichier compressé sets.csv.gz depuis Rebrickable vers data/raw/, le décompresse immédiatement en sets.csv, supprime l'archive .gz, et ne retélécharge pas le fichier si sets.csv a moins de 7 jours.

Étape 4 : filtrer les sets sur les thèmes ciblés

source .venv/bin/activate
python -m scripts.filter_sets

Le script lit THEME_IDS depuis .env, prend data/raw/sets.csv en entrée, applique les corrections déclarées dans config/num_parts_overrides.csv, et produit data/intermediate/sets_filtered.csv contenant uniquement les lignes dont le theme_id appartient aux thèmes sélectionnés et dont num_parts est strictement supérieur à 0.

Corrections manuelles connues (config/num_parts_overrides.csv) :

set_num	num_parts	commentaire
122220-1	30	Sachet promotionnel annoncé 30 pièces

Étape 5 : enrichir les sets filtrés

source .venv/bin/activate
python -m scripts.enrich_sets

Le script lit data/intermediate/sets_filtered.csv, ajoute :

set_id (partie avant le tiret dans set_num)
rebrickable_url (URL publique du set sur Rebrickable)
in_collection (true/false selon la présence du set dans le dossier MY_SETS)

La variable MY_SETS (définie dans .env) doit pointer vers un dossier contenant un sous-dossier par identifiant LEGO possédé. Si la variable est vide, que le dossier est absent ou vide, la colonne in_collection sera à false pour tous les sets. Les sorties sont data/intermediate/sets_enriched.csv et data/final/sets_missing.md.

Étape 6 : calculer des statistiques basiques

source .venv/bin/activate
python -m scripts.compute_stats

Le script lit data/raw/themes.csv, data/raw/sets.csv, data/intermediate/sets_filtered.csv et data/intermediate/sets_enriched.csv, puis écrit data/final/stats.csv avec deux colonnes (libelle, valeur) contenant notamment :

nombre total de sets (catalogue complet)
nombre de sets filtrés et pourcentage vs total
nombre moyen de sets par thème (catalogue complet)
sets en collection / sets manquants
taux de possession
moyenne, médiane et total de pièces pour les thèmes filtrés
moyenne de sets commercialisés par an
bornes d'années et nombre de thèmes filtrés
année la plus prolifique
set le plus fourni / le moins fourni en pièces
set le plus ancien / le plus récent
moyenne de pièces des sets possédés / manquants
total de pièces des sets possédés
pourcentage de pièces possédées
moyenne de sets par thème (catalogue complet, via themes.csv)
nombre total de thèmes (catalogue complet)

Milestones (jalons chronologiques)

Les jalons sont configurés dans config/milestones.csv (colonnes year, description). Ils sont indépendants des thèmes sélectionnés : pour un autre univers (ex. Star Wars), il suffit de remplacer ou adapter ce fichier sans modifier le code.

Étape 7 : graphique du nombre de sets par année

source .venv/bin/activate
python -m scripts.plot_sets_per_year

Le script lit data/intermediate/sets_enriched.csv, les jalons config/milestones.csv, et produit figures/step07/sets_per_year.png montrant :

le nombre de sets par année (barres)
la moyenne cumulative des sets (courbe)
le total de pièces par année (barres)
la moyenne cumulative des pièces par set (courbe) annoté avec les jalons chronologiques

En parallèle, le script python -m scripts.plot_parts_per_set génère figures/step07/avg_parts_per_set.png avec la moyenne annuelle de pièces par set et une moyenne glissante (3 ans) pour mettre en évidence la tendance sans diluer l'historique.

Étape 8 : télécharger les données détaillées des pièces

source .venv/bin/activate
python -m scripts.download_parts_data

Le script télécharge les fichiers compressés inventories.csv.gz, inventory_parts.csv.gz, inventory_minifigs.csv.gz, minifigs.csv.gz, parts.csv.gz et colors.csv.gz vers data/raw/, les décompresse immédiatement en supprimant chaque archive .gz, et ne retélécharge pas les fichiers âgés de moins de 7 jours (cache fondé sur les CSV décompressés). Ces données complètent les sets en décrivant leurs inventaires, les pièces individuelles, les minifigs associées et les couleurs disponibles. Le fichier des catégories de pièces (part_categories.csv.gz) est également téléchargé afin d'affiner au besoin la sélection de catégories liées aux têtes de minifigs.

Étape 9 : assembler l'inventaire des pièces par set

source .venv/bin/activate
python -m scripts.build_parts_inventory

Le script lit data/intermediate/sets_enriched.csv, data/raw/inventories.csv, data/raw/inventory_parts.csv, data/raw/inventory_minifigs.csv, data/raw/minifigs.csv et data/raw/colors.csv, sélectionne la version d'inventaire la plus récente pour chaque set, puis produit data/intermediate/parts_filtered.csv contenant : part_num, color_rgb, is_translucent, set_num, set_id, quantity_in_set, is_spare. Les minifigs sont éclatées en pièces en exploitant leur propre inventaire (présent dans inventories.csv + inventory_parts.csv) et leurs quantités dans inventory_minifigs.csv. Ce fichier sert de base aux analyses ultérieures sans relire les CSV bruts. Le fichier agrégé inclut également l'année du set (year) et un indicateur is_minifig_part pour distinguer les pièces issues des minifigs.

Étape 10 : identifier les écarts d'inventaire

source .venv/bin/activate
python -m scripts.report_inventory_gaps

Le script lit data/intermediate/sets_enriched.csv et data/intermediate/parts_filtered.csv, calcule pour chaque set filtré le total de pièces (rechanges incluses), et produit data/intermediate/inventory_gaps.csv avec les colonnes :

set_num
set_id
expected_parts (num_parts dans sets_enriched.csv)
inventory_parts (somme de quantity_in_set dans parts_filtered.csv, rechanges incluses)
delta (valeur absolue de expected_parts - inventory_parts)
in_collection (valeur issue de sets_enriched.csv)

Seuls les sets dont les totaux diffèrent figurent dans ce fichier. Aucune tentative de correction n'est effectuée : l'inventaire existant reste la référence malgré les éventuels manques du catalogue Rebrickable.

Un tableau Markdown est également généré dans data/final/inventory_gaps.md listant ces sets avec leur nom, l'écart observé et un lien vers les instructions LEGO.

Étape 11 : statistiques simples sur les pièces

source .venv/bin/activate
python -m scripts.compute_parts_stats

Le script lit data/intermediate/parts_filtered.csv et data/final/stats.csv (pour le total catalogue filtré), puis produit data/final/parts_stats.csv avec : nombre de variations de pièces (hors rechanges), pièce la moins utilisée, pièce la plus commune, nombre de couleurs utilisées, total de pièces hors rechanges, écart entre le total de pièces attendu (stats catalogue) et l'inventaire agrégé, nombre de sets présentant un écart inventaire/catalogue et écart maximal observé.

Étape 12 : visualiser la palette globale

source .venv/bin/activate
python -m scripts.plot_colors_grid

Le script lit data/intermediate/parts_filtered.csv et data/raw/colors.csv, puis génère deux visuels : figures/step12/colors_grid.png pour l'ensemble des pièces (rechanges incluses) et figures/step12/colors_grid_minifigs.png pour la seule palette des minifigs. Les couleurs sont triées perceptuellement et mises en scène sur une grille hexagonale. Les codes couleurs 0033B2 et 05131D sont ignorés, et les pièces considérées comme techniques/structurelles (catégories Technic, roues, tubes, axes, etc.) sont filtrées afin de ne garder que les éléments « visibles » pour l’esthétique.

Étape 13 : palette de couleurs par set

source .venv/bin/activate
python -m scripts.build_colors_by_set

Le script agrège data/intermediate/parts_filtered.csv avec les libellés de couleurs data/raw/colors.csv et produit data/intermediate/colors_by_set.csv contenant, pour chaque set et chaque couleur, les quantités totales, hors rechanges, issues des minifigs et hors minifigs. Les couleurs ignorées (0033B2, 05131D) et les pièces techniques/structurelles sont exclues. Ce fichier sert de base aux visualisations et matrices de palette.

Étape 14 : évolution annuelle des palettes

source .venv/bin/activate
python -m scripts.compute_colors_timeline

Le script lit data/intermediate/colors_by_set.csv et produit deux agrégats : data/intermediate/colors_timeline.csv (statistiques annuelles : nombre de couleurs distinctes, nouvelles, perdues, part des translucides, top couleurs) et data/intermediate/colors_year_color_matrix.csv (quantités totales année × couleur) pour préparer heatmaps et analyses temporelles.

Étape 15 : visualiser l'évolution des palettes

source .venv/bin/activate
python -m scripts.plot_colors_timeline

Le script lit les agrégats de l'étape 14 et produit figures/step15/colors_translucent_share.png (part des pièces translucides par année et nombre de couleurs distinctes), figures/step15/colors_heatmap_linear.png (heatmap année × couleur en quantités brutes) et figures/step15/colors_heatmap_log.png (heatmap avec échelle log1p). Une troisième variante normalise les quantités par année : figures/step15/colors_heatmap_share.png. Dans cette vue, chaque colonne (année) est ramenée à une part relative (0–1) du total de pièces de l'année. Cela met en évidence la structure de palette indépendamment du volume : deux années restent comparables même si leur nombre total de pièces diffère fortement, mais l'information de volume absolu n'apparaît plus (à privilégier pour les comparaisons de proportions, pas pour mesurer la rareté volumique). Toutes les vues héritent du filtrage des couleurs ignorées et des pièces techniques/structurelles appliqué en amont.

Étape 16 : couleurs de peau des minifigs

source .venv/bin/activate
python -m scripts.compute_minifig_heads

Le script identifie les têtes de minifigs via la catégorie Rebrickable dédiée (part_cat_id 59 dans data/raw/parts.csv), filtre les pièces de rechange, puis agrège leurs couleurs depuis data/intermediate/parts_filtered.csv. Les sorties sont data/intermediate/minifig_heads_by_set.csv (quantités de têtes par set, couleur et année) et data/intermediate/minifig_heads_by_year.csv (agrégées par année). Ces fichiers serviront de base pour analyser l'évolution des teintes de peau (ou assimilées) des minifigs. Les couleurs ignorées (0033B2, 05131D) sont écartées lors de l’agrégation.

Étape 17 : visualiser les couleurs de peau des minifigs

source .venv/bin/activate
python -m scripts.plot_minifig_heads

Le script lit data/intermediate/minifig_heads_by_year.csv et produit figures/step16/minifig_heads_shares.png (répartition annuelle des couleurs de têtes, en parts empilées) et figures/step16/minifig_heads_global.png (donut global des parts cumulées). Les couleurs sont limitées aux plus fréquentes (avec regroupement des autres).

Étape 18 : usage global de la couleur Yellow pour les têtes

source .venv/bin/activate
python -m scripts.compute_global_minifig_heads
python -m scripts.plot_global_minifig_skin_tones

Ces scripts lisent les CSV bruts du catalogue complet (data/raw/inventories.csv, inventory_parts.csv, parts.csv, colors.csv, sets.csv), extraient les têtes de minifigs via part_cat_id=59, agrègent les couleurs par année dans data/intermediate/global_minifig_heads_by_year.csv, puis tracent figures/step17/global_minifig_heads_yellow_share.png montrant la part annuelle de la couleur Yellow comparée au reste, jalons inclus.

Étape 19 : total de minifigs des sets filtrés

source .venv/bin/activate
python -m scripts.compute_minifig_stats

Le script relit les sets (data/raw/themes.csv, data/raw/sets.csv, data/intermediate/sets_filtered.csv, data/intermediate/sets_enriched.csv) ainsi que les inventaires (data/raw/inventories.csv, data/raw/inventory_minifigs.csv), recalcule toutes les statistiques de base puis régénère data/final/stats.csv en y ajoutant le libellé « Nombre total de minifigs (thèmes filtrés) ». Cette étape se lance après le téléchargement des données d'inventaire (étape 8) et doit être rejouée si les sets filtrés ou les inventaires sont mis à jour.

Étape 20 : lister les têtes de minifigs par set

source .venv/bin/activate
python -m scripts.compute_minifigs_by_set

Le script lit l'inventaire agrégé data/intermediate/parts_filtered.csv, les inventaires data/raw/inventories.csv, data/raw/inventory_parts.csv, data/raw/inventory_minifigs.csv, le catalogue des pièces (data/raw/parts.csv) et celui des minifigs (data/raw/minifigs.csv). Il sélectionne les têtes de minifigs (catégorie 59), ignore les rechanges et dédoublonne par set et référence. Si une tête est associée à une minifig précise dans l'inventaire du set, known_character est renseigné avec le nom de la minifig et fig_num est indiqué ; sinon, known_character reste vide après tentative de correspondance automatique. Les correspondances d'alias sont décrites dans config/known_character_aliases.csv et les genres des personnages nommés dans config/known_character_genders.csv. Le CSV data/intermediate/minifigs_by_set.csv contient : set_num, part_num, known_character, fig_num, gender.

Étape 21 : visualiser le nombre de minifigs par set

source .venv/bin/activate
python -m scripts.plot_minifigs_per_set

Le script relit data/intermediate/sets_enriched.csv, data/intermediate/parts_filtered.csv et data/raw/parts.csv, compte les têtes de minifigs hors rechanges et produit deux sorties :

data/intermediate/minifig_counts_by_set.csv : set_num, set_id, name, year, minifig_count
figures/step21/minifigs_per_set.png : diagramme en barres horizontales (ordre décroissant) du nombre de minifigs par set filtré

Étape 22 : personnages représentés par les minifigs

source .venv/bin/activate
python -m scripts.plot_minifig_characters

Le script lit data/intermediate/minifigs_by_set.csv, compte le nombre de minifigs distinctes par personnage (known_character + fig_num), écrit data/intermediate/minifig_characters_counts.csv, puis trace figures/step22/minifig_characters.png (barres horizontales triées). Les barres sont colorées en fonction du genre renseigné dans config/known_character_genders.csv.

Étape 23 : présence annuelle des personnages

source .venv/bin/activate
python -m scripts.plot_minifig_characters_timeline

Le script lit data/intermediate/minifigs_by_set.csv et data/intermediate/sets_enriched.csv, calcule le nombre de minifigs par personnage et par année (hors figurants) dans data/intermediate/minifig_characters_year_presence.csv, puis trace figures/step23/minifig_characters_timeline.png (heatmap avec volumes).

Étape 24 : longévité des personnages

source .venv/bin/activate
python -m scripts.plot_minifig_character_spans

Le script lit data/intermediate/minifigs_by_set.csv et data/intermediate/sets_enriched.csv, calcule la première et la dernière année d'apparition pour chaque personnage (hors figurants), sérialise data/intermediate/minifig_character_spans.csv, puis trace figures/step24/minifig_character_spans.png (barres horizontales des spans). Les barres sont colorées selon le genre issu de config/known_character_genders.csv.

Étape 25 : répartition des genres des personnages

source .venv/bin/activate
python -m scripts.plot_minifig_gender_share

Le script lit data/intermediate/minifigs_by_set.csv, agrège le nombre de minifigs distinctes par genre (basé sur config/known_character_genders.csv), écrit data/intermediate/minifig_gender_counts.csv, puis trace figures/step25/minifig_gender_share.png (donut indiquant la part des personnages féminins, masculins ou inconnus).

Étape 26 : corrélation pièces / minifigs

source .venv/bin/activate
python -m scripts.plot_minifig_parts_correlation

Le script lit data/intermediate/minifig_counts_by_set.csv, data/intermediate/sets_enriched.csv, data/raw/sets.csv, data/raw/inventories.csv et data/raw/inventory_minifigs.csv, produit data/intermediate/minifig_parts_correlation.csv (pièces vs minifigs pour le catalogue global et les thèmes filtrés), puis trace figures/step26/minifig_parts_correlation.png en superposant les nuages de points et leurs tendances linéaires. Un second export data/intermediate/minifigs_per_set_timeline.csv est généré pour l'évolution annuelle du nombre moyen de minifigs par set, visualisé dans figures/step26/minifigs_per_set_timeline.png (courbes catalogue vs thèmes filtrés).

Étape 27 : pièces rares (variantes exclusives)

source .venv/bin/activate
python -m scripts.compute_rare_parts
python -m scripts.plot_rare_parts

Le calcul lit data/intermediate/parts_filtered.csv, data/intermediate/sets_enriched.csv, data/raw/parts.csv et data/raw/colors.csv pour identifier les combinaisons pièce + couleur présentes dans un seul set (rechanges exclues). Il produit :

data/intermediate/rare_parts.csv : liste détaillée des pièces rares avec set, couleur, nature minifig/hors minifig et possession.
data/intermediate/rare_parts_by_set.csv : agrégat par set (comptes distincts, quantités, focus minifigs).

Le tracé figures/step27/rare_parts_per_set.png met en scène le top des sets contenant le plus de variantes exclusives, en distinguant les pièces de minifigs et l’état de possession.

Étape 28 : richesse chromatique par set

source .venv/bin/activate
python -m scripts.compute_color_richness
python -m scripts.plot_color_richness

Le calcul lit data/intermediate/colors_by_set.csv et data/intermediate/sets_enriched.csv pour mesurer la diversité des palettes (nombre de couleurs distinctes hors rechanges, part des 3 couleurs principales, part de couleurs de minifigs). Il produit :

data/intermediate/color_richness_by_set.csv : métriques détaillées par set (comptes et parts principales, possession).
data/intermediate/color_richness_by_year.csv : agrégat annuel (moyenne, médiane, bornes de diversité et concentration).

Les graphiques figures/step28/color_richness_boxplot.png, figures/step28/color_richness_top_sets.png et figures/step28/color_concentration_scatter.png montrent respectivement la répartition annuelle, le top des sets les plus colorés et la concentration des palettes (part des 3 couleurs dominantes vs nombre de couleurs).

Étape 29 : répartition par catégories de pièces (structure vs esthétique)

source .venv/bin/activate
python -m scripts.compute_part_categories
python -m scripts.plot_part_categories

Le calcul lit data/intermediate/parts_filtered.csv, data/raw/parts.csv, data/raw/part_categories.csv et data/intermediate/sets_enriched.csv pour mesurer la part de chaque catégorie de pièce (rechanges exclues), marquer celles considérées comme structurelles/technic (liste IGNORED_PART_CATEGORY_IDS de lib/rebrickable/color_ignores.py), et produire :

data/intermediate/part_categories_by_set.csv : parts par set et par catégorie, avec possession et indicateur structurel.
data/intermediate/part_categories_by_year.csv : parts annuelles par catégorie.
data/intermediate/part_categories_global.csv : parts globales par catégorie.

Les visuels figures/step29/top_part_categories_area.png, figures/step29/part_categories_heatmap.png et figures/step29/structural_share_timeline.png montrent respectivement l’évolution des principales catégories (aire empilée), une heatmap exhaustive catégorie × année, et la trajectoire de la part des pièces structurelles.

Étape 30 : visages multiples sur les têtes de minifigs

source .venv/bin/activate
python -m scripts.compute_minifig_head_faces
python -m scripts.plot_minifig_head_faces

Le calcul lit data/intermediate/minifigs_by_set.csv, data/raw/parts.csv et data/intermediate/sets_enriched.csv pour annoter les têtes de minifigs contenant plusieurs visages (détection par mots-clés dans le nom de pièce). Il produit :

data/intermediate/minifig_head_faces.csv : têtes annotées (set, personnage, genre, indicateur dual-face).
data/intermediate/minifig_head_faces_by_year.csv : volume et part des dual-face par année.
data/intermediate/minifig_head_faces_by_set.csv : volume et part par set (possession incluse).
data/intermediate/minifig_head_faces_by_character.csv : volume et part par personnage.

Les visuels figures/step30/minifig_head_faces_timeline.png, figures/step30/minifig_head_faces_top_sets.png et figures/step30/minifig_head_faces_characters.png montrent respectivement la trajectoire annuelle, le top des sets concernés et les personnages dotés de têtes dual-face.

Étape 31 : téléchargement des ressources visuelles (sets, minifigs, têtes)

Renseigner REBRICKABLE_TOKEN dans .env (clé API Rebrickable).
source .venv/bin/activate
python -m scripts.download_resources

Le script lit data/intermediate/sets_enriched.csv, data/intermediate/minifigs_by_set.csv et data/raw/minifigs.csv. Il récupère les URLs d'images de têtes via l’API Rebrickable /api/v3/lego/parts/{part_num}/, ajoute la colonne part_img_url à data/intermediate/minifigs_by_set.csv, puis télécharge :

figures/rebrickable/{set_id}/set.jpg : visuel du set (img_url).
figures/rebrickable/{set_id}/{known_character}/minifig.jpg : visuel de la minifig complète.
figures/rebrickable/{set_id}/{known_character}/head.jpg : visuel de la tête correspondante.

Les requêtes API sont dédoublonnées, espacées (fair-use) et mises en cache dans data/intermediate/part_img_cache.csv pour reprise en cas d’interruption. Les images déjà téléchargées sont réutilisées localement pour éviter les requêtes répétées.

Étape 32 : frises chronologiques des minifigs par personnage

source .venv/bin/activate
python -m scripts.plot_minifig_character_collages
python -m scripts.plot_minifig_head_collages

Le script lit data/intermediate/minifigs_by_set.csv, data/intermediate/sets_enriched.csv et les ressources téléchargées dans figures/rebrickable. Il regroupe chaque personnage connu (hors figurants) avec les sets associés et leur année de commercialisation, pour produire :

data/intermediate/minifig_character_sets.csv : apparitions des personnages avec set, identifiant de set, année, possession et fig_num.
figures/step32/minifig_characters/{personnage}.png : frise horizontale par personnage, composée des visuels de minifigs dans l’ordre chronologique, annotés avec l’année, le numéro de set (avec * si possédé) et l’identifiant de minifig. Les minifigs dont l’image n’est pas disponible sont remplacées par un rectangle neutre pour matérialiser le manque.
figures/step32/minifig_heads/{personnage}.png : même principe mais en utilisant les visuels de têtes (head.jpg) pour chaque apparition, annotés avec l’année, le set (avec * si possédé) et le part_num de la tête.

Étape 33 : réutilisation des têtes de minifigs dans le catalogue

source .venv/bin/activate
python -m scripts.compute_head_reuse
python -m scripts.plot_head_reuse

Le calcul lit data/intermediate/minifigs_by_set.csv, data/raw/parts.csv, data/raw/inventories.csv et data/raw/inventory_parts.csv pour recenser les têtes présentes dans les sets filtrés, puis compter combien de sets du catalogue les contiennent (rechanges exclues). Il produit :

data/intermediate/head_reuse.csv : pour chaque tête observée dans les sets filtrés, le nombre de sets filtrés qui la contiennent, le nombre de sets du reste du catalogue et le total.
figures/step33/head_reuse.png : bar chart horizontal montrant, par tête, la part filtrée vs le reste du catalogue (têtes exclusives en haut).
Les étiquettes affichent aussi l’identifiant de la minifig (fig-*) et un astérisque à côté du set (set_num*) lorsqu’il est présent dans la collection.

27 KiB Raw Blame History Unescape Escape