Update comparison

Author: johnsamuelwrites

bundle.js

@@ -252,6 +252,15 @@
   "comparison.artistCount": "{count} artist(s)",
   "comparison.noSharedArtist": "No shared artist",
   "comparison.removeAria": "Remove {label}",
+  "comparison.kind.artists": "artists",
+  "comparison.kind.artworks": "artworks",
+  "comparison.kind.items": "items",
+  "comparison.generic.commonArtists": "{count} shared {kind}",
+  "comparison.generic.noCommonArtists": "No shared {kind}",
+  "comparison.generic.columnMeta": "{total} {kind} • {unique} unique",
+  "comparison.generic.noUniqueArtist": "No unique item",
+  "comparison.generic.artistCount": "{count} {kind}",
+  "comparison.generic.noSharedArtist": "No shared item",
   "explorer.theme.artworksFound": "{count} artworks found for this theme.",
   "explorer.theme.loadingArtworks": "Loading artworks for this theme...",
   "explorer.action.openConstellation": "Explore in constellation",

src/i18n/locales/en.json

@@ -252,6 +252,15 @@
   "comparison.artistCount": "{count} artista(s)",
   "comparison.noSharedArtist": "Ningun artista compartido",
   "comparison.removeAria": "Retirar {label}",
+  "comparison.kind.artists": "artistas",
+  "comparison.kind.artworks": "obras",
+  "comparison.kind.items": "elementos",
+  "comparison.generic.commonArtists": "{count} {kind} en comun",
+  "comparison.generic.noCommonArtists": "Ningun elemento en comun",
+  "comparison.generic.columnMeta": "{total} {kind} • {unique} unicos",
+  "comparison.generic.noUniqueArtist": "Ningun elemento unico",
+  "comparison.generic.artistCount": "{count} {kind}",
+  "comparison.generic.noSharedArtist": "Ningun elemento compartido",
   "explorer.theme.artworksFound": "{count} obras encontradas para este tema.",
   "explorer.theme.loadingArtworks": "Cargando obras para este tema...",
   "explorer.action.openConstellation": "Explorar en la constelacion",

src/i18n/locales/es.json

@@ -252,6 +252,15 @@
   "comparison.artistCount": "{count} artiste(s)",
   "comparison.noSharedArtist": "Aucun artiste partagé",
   "comparison.removeAria": "Retirer {label}",
+  "comparison.kind.artists": "artistes",
+  "comparison.kind.artworks": "œuvres",
+  "comparison.kind.items": "éléments",
+  "comparison.generic.commonArtists": "{count} {kind} en commun",
+  "comparison.generic.noCommonArtists": "Aucun élément en commun",
+  "comparison.generic.columnMeta": "{total} {kind} • {unique} uniques",
+  "comparison.generic.noUniqueArtist": "Aucun élément unique",
+  "comparison.generic.artistCount": "{count} {kind}",
+  "comparison.generic.noSharedArtist": "Aucun élément partagé",
   "explorer.theme.artworksFound": "{count} œuvres trouvées pour ce thème.",
   "explorer.theme.loadingArtworks": "Chargement des œuvres pour ce thème...",
   "explorer.action.openConstellation": "Explorer dans la constellation",

src/i18n/locales/fr.json

@@ -135,15 +135,20 @@ classe Graphe:
 
         tantque len(queue) > 0:
             chemin = queue.pop(0)
-            noeud_actuel = chemin[-1]
+            noeud_actuel = chemin[len(chemin) - 1]
 
             pour voisin_id dans self.obtenir_voisins(noeud_actuel):
+                nouveau_chemin = []
+                pour etape_id dans chemin:
+                    nouveau_chemin.ajouter(etape_id)
+                nouveau_chemin.ajouter(voisin_id)
+
                 si voisin_id == noeud_arrivee_id:
-                    retour chemin + [voisin_id]
+                    retour nouveau_chemin
 
                 si voisin_id non dans visites:
                     visites.ajouter(voisin_id)
-                    queue.ajouter(chemin + [voisin_id])
+                    queue.ajouter(nouveau_chemin)
 
         retour []
 

src/semantique/graphe.multi

@@ -1,6 +1,22 @@
 importer ui.etat
 
 
+déf _obtenir_ids_elements(donnees: dictionnaire) -> liste:
+    """Retourner les IDs comparables, avec compatibilité pour l'ancien format artistes."""
+    items = donnees.obtenir("items_ids", nul)
+    si items est nul:
+        items = donnees.obtenir("artistes_ids", [])
+    retour items
+
+
+déf _obtenir_labels_elements(donnees: dictionnaire) -> dictionnaire:
+    """Retourner les labels comparables, avec compatibilité pour l'ancien format artistes."""
+    labels = donnees.obtenir("items_labels", nul)
+    si labels est nul:
+        labels = donnees.obtenir("artistes_labels", {})
+    retour labels
+
+
 déf calculer_intersection_artistes(ids_entites: liste) -> liste:
     """Calculer les artistes communs à toutes les entités données"""
     si len(ids_entites) < 2:
@@ -10,12 +26,12 @@ déf calculer_intersection_artistes(ids_entites: liste) -> liste:
     premiere_entite = ids_entites[0]
     donnees0 = ui.etat.obtenir_donnees_comparaison().obtenir(premiere_entite, {})
     communs = {}
-    pour artiste_id dans donnees0.obtenir("artistes_ids", []):
+    pour artiste_id dans _obtenir_ids_elements(donnees0):
         communs[artiste_id] = vrai
 
     pour entite_id dans ids_entites[1:]:
         donnees = ui.etat.obtenir_donnees_comparaison().obtenir(entite_id, {})
-        ids_entite = donnees.obtenir("artistes_ids", [])
+        ids_entite = _obtenir_ids_elements(donnees)
         dict_entite = {}
         pour a dans ids_entite:
             dict_entite[a] = vrai
@@ -41,7 +57,7 @@ déf calculer_artistes_uniques(ids_entites: liste) -> dictionnaire:
     pour entite_id dans ids_entites:
         donnees = ui.etat.obtenir_donnees_comparaison().obtenir(entite_id, {})
         d = {}
-        pour a dans donnees.obtenir("artistes_ids", []):
+        pour a dans _obtenir_ids_elements(donnees):
             d[a] = vrai
         ensembles[entite_id] = d
 
@@ -65,7 +81,7 @@ déf obtenir_etiquette_artiste(artiste_id: chaine, ids_entites: liste) -> chaine
     """Chercher l'étiquette d'un artiste dans les données de comparaison chargées"""
     pour entite_id dans ids_entites:
         donnees = ui.etat.obtenir_donnees_comparaison().obtenir(entite_id, {})
-        labels = donnees.obtenir("artistes_labels", {})
+        labels = _obtenir_labels_elements(donnees)
         label = labels.obtenir(artiste_id, "")
         si label:
             retour label
@@ -84,7 +100,7 @@ déf obtenir_statistiques(ids_entites: liste) -> dictionnaire:
     total_par_entite = {}
     pour entite_id dans ids_entites:
         donnees = ui.etat.obtenir_donnees_comparaison().obtenir(entite_id, {})
-        total_par_entite[entite_id] = len(donnees.obtenir("artistes_ids", []))
+        total_par_entite[entite_id] = len(_obtenir_ids_elements(donnees))
 
     uniques_par_entite = {}
     pour eid, u dans artistes_uniques.items():

src/semantique/intersections.multi

@@ -211,7 +211,7 @@ classe AnalyseArtiste:
             retour 0
 
         oeuvres_triees = sorted(self.oeuvres)
-        retour oeuvres_triees[-1] - oeuvres_triees[0]
+        retour oeuvres_triees[len(oeuvres_triees) - 1] - oeuvres_triees[0]
 
     déf obtenir_productivite_moyenne() -> nombre:
         """Calculer les œuvres par année"""

src/semantique/temporel.multi

@@ -14,6 +14,29 @@ déf _ti(cle: chaine, params: dictionnaire) -> chaine:
     retour texte
 
 
+déf _obtenir_kind_comparaison(ids_entites: liste) -> chaine:
+    pour entite_id dans ids_entites:
+        donnees = ui.etat.obtenir_donnees_comparaison().obtenir(entite_id, {})
+        kind = donnees.obtenir("items_kind", "")
+        si kind:
+            retour kind
+    retour "artists"
+
+
+déf _cle_comparaison(kind: chaine, suffixe: chaine) -> chaine:
+    si kind == "artists":
+        retour "comparison." + suffixe
+    retour "comparison.generic." + suffixe
+
+
+déf _libelle_kind(kind: chaine) -> chaine:
+    si kind == "artworks":
+        retour _t("comparison.kind.artworks")
+    si kind == "artists":
+        retour _t("comparison.kind.artists")
+    retour _t("comparison.kind.items")
+
+
 déf rendre_panneau_comparaison() -> chaine:
     """Rendre le panneau de comparaison entre entités sélectionnées"""
     entites = ui.etat.obtenir_entites_comparaison()
@@ -45,6 +68,8 @@ déf rendre_panneau_comparaison() -> chaine:
     pour entite dans entites:
         ids_entites.ajouter(entite.obtenir("id", ""))
 
+    kind = _obtenir_kind_comparaison(ids_entites)
+    kind_label = _libelle_kind(kind)
     artistes_communs = semantique.intersections.calculer_intersection_artistes(ids_entites)
     artistes_uniques = semantique.intersections.calculer_artistes_uniques(ids_entites)
     stats = semantique.intersections.obtenir_statistiques(ids_entites)
@@ -53,7 +78,7 @@ déf rendre_panneau_comparaison() -> chaine:
     toutes_chargees = vrai
     pour entite_id dans ids_entites:
         donnees = ui.etat.obtenir_donnees_comparaison().obtenir(entite_id, {})
-        si donnees.obtenir("artistes_ids", nul) est nul:
+        si donnees.obtenir("items_ids", donnees.obtenir("artistes_ids", nul)) est nul:
             toutes_chargees = faux
 
     si non toutes_chargees:
@@ -67,9 +92,9 @@ déf rendre_panneau_comparaison() -> chaine:
     nb_communs = stats.obtenir("artistes_communs_count", 0)
     html = html + '<div class="comparaison-resume">'
     si nb_communs > 0:
-        html = html + '<p class="comparaison-resume-texte">' + _ti("comparison.commonArtists", {"count": '<strong>' + chaine(nb_communs) + '</strong>'}) + '</p>'
+        html = html + '<p class="comparaison-resume-texte">' + _ti(_cle_comparaison(kind, "commonArtists"), {"count": '<strong>' + chaine(nb_communs) + '</strong>', "kind": kind_label}) + '</p>'
     sinon:
-        html = html + '<p class="comparaison-resume-texte">' + _t("comparison.noCommonArtists") + '</p>'
+        html = html + '<p class="comparaison-resume-texte">' + _ti(_cle_comparaison(kind, "noCommonArtists"), {"kind": kind_label}) + '</p>'
     html = html + '</div>'
 
     # Grille: colonnes entités + colonne centrale commune
@@ -84,7 +109,7 @@ déf rendre_panneau_comparaison() -> chaine:
 
         html = html + '<div class="comparaison-colonne">'
         html = html + '<h4 class="comparaison-col-titre">' + entite_label + '</h4>'
-        html = html + '<span class="comparaison-col-meta">' + _ti("comparison.columnMeta", {"total": total, "unique": len(uniques)}) + '</span>'
+        html = html + '<span class="comparaison-col-meta">' + _ti(_cle_comparaison(kind, "columnMeta"), {"total": total, "unique": len(uniques), "kind": kind_label}) + '</span>'
 
         si uniques:
             html = html + '<ul class="comparaison-liste">'
@@ -95,14 +120,14 @@ déf rendre_panneau_comparaison() -> chaine:
                 html = html + '<li class="comparaison-item comparaison-plus">+ ' + _ti("comparison.moreOthers", {"count": len(uniques) - 8}) + '</li>'
             html = html + '</ul>'
         sinon:
-            html = html + '<p class="comparaison-vide">' + _t("comparison.noUniqueArtist") + '</p>'
+            html = html + '<p class="comparaison-vide">' + _ti(_cle_comparaison(kind, "noUniqueArtist"), {"kind": kind_label}) + '</p>'
 
         html = html + '</div>'
 
     # Colonne centrale — artistes communs
     html = html + '<div class="comparaison-colonne comparaison-colonne-commun">'
     html = html + '<h4 class="comparaison-col-titre comparaison-col-titre-commun">' + _t("comparison.commonColumn") + '</h4>'
-    html = html + '<span class="comparaison-col-meta">' + _ti("comparison.artistCount", {"count": nb_communs}) + '</span>'
+    html = html + '<span class="comparaison-col-meta">' + _ti(_cle_comparaison(kind, "artistCount"), {"count": nb_communs, "kind": kind_label}) + '</span>'
 
     si artistes_communs:
         html = html + '<ul class="comparaison-liste">'
@@ -111,7 +136,7 @@ déf rendre_panneau_comparaison() -> chaine:
             html = html + '<li class="comparaison-item comparaison-commun">' + nom + '</li>'
         html = html + '</ul>'
     sinon:
-        html = html + '<p class="comparaison-vide">' + _t("comparison.noSharedArtist") + '</p>'
+        html = html + '<p class="comparaison-vide">' + _ti(_cle_comparaison(kind, "noSharedArtist"), {"kind": kind_label}) + '</p>'
 
     html = html + '</div>'
     html = html + '</div>'

src/ui/composants/panneau_comparaison.multi

@@ -45,7 +45,7 @@ observer var pan_constellation_y = 0
 # Etat du mode recit et de la comparaison
 observer var mode_recit = faux
 observer var entites_comparaison = []   # [{id, type, label}, ...]
-observer var donnees_comparaison = {}   # id -> {label, artistes_ids, artistes_labels}
+observer var donnees_comparaison = {}   # id -> {label, items_ids, items_labels, items_kind, artistes_ids, artistes_labels}
 
 # Etat de la trajectoire d'influence
 observer var trajectoire_depart_id = ""
@@ -609,6 +609,40 @@ déf obtenir_artistes_mouvement(mouvement_id: chaine) -> liste:
     retour ids
 
 
+déf _id_depuis_champ_entite(champ: dictionnaire) -> chaine:
+    """Extraire un Q-id depuis un champ normalisé {value: uri}."""
+    retour _extraire_id_entite(champ)
+
+
+déf _enregistrer_donnees_comparaison(entite_id: chaine, etiquette: chaine, ids: liste, labels: dictionnaire, kind: chaine):
+    """Stocker une collection comparable pour une entité."""
+    donnees_courantes = donnees_comparaison.obtenir(entite_id, {})
+    donnees_courantes["label"] = etiquette ou donnees_courantes.obtenir("label", entite_id)
+    donnees_courantes["items_ids"] = ids
+    donnees_courantes["items_labels"] = labels
+    donnees_courantes["items_kind"] = kind
+
+    # Compatibilité avec l'ancien panneau orienté mouvements/artistes.
+    si kind == "artists":
+        donnees_courantes["artistes_ids"] = ids
+        donnees_courantes["artistes_labels"] = labels
+
+    donnees_comparaison[entite_id] = donnees_courantes
+
+
+déf _extraire_oeuvres_comparaison(oeuvres: liste) -> dictionnaire:
+    ids = []
+    labels = {}
+    pour oeuvre dans oeuvres:
+        oeuvre_id = _id_depuis_champ_entite(oeuvre.obtenir("artwork", {}))
+        label_oeuvre = _etiquette_entite(oeuvre, ["artworkLabel"], "")
+        si oeuvre_id:
+            ids.ajouter(oeuvre_id)
+            si label_oeuvre:
+                labels[oeuvre_id] = label_oeuvre
+    retour {"ids": ids, "labels": labels}
+
+
 déf basculer_comparaison(entite_id: chaine, type_entite: chaine, etiquette: chaine) -> booleen:
     """Ajouter ou retirer une entité du panneau de comparaison. Retourne vrai si ajoutée."""
     pour entite dans entites_comparaison:
@@ -639,18 +673,14 @@ déf basculer_comparaison(entite_id: chaine, type_entite: chaine, etiquette: cha
             si noeud:
                 artistes_labels[artiste_id] = noeud.etiquette
 
-    donnees_comparaison[entite_id] = {
-        "label": etiquette,
-        "artistes_ids": artistes_ids,
-        "artistes_labels": artistes_labels
-    }
+    _enregistrer_donnees_comparaison(entite_id, etiquette, artistes_ids, artistes_labels, "artists")
     retour vrai
 
 
 asynchrone déf charger_donnees_comparaison(entite_id: chaine, type_entite: chaine):
     """Charger les données d'une entité pour la comparaison sans modifier le graphe principal"""
     existantes = donnees_comparaison.obtenir(entite_id, {})
-    si existantes.obtenir("artistes_ids", []):
+    si existantes.obtenir("items_ids", []):
         retour
 
     si type_entite == "mouvement":
@@ -668,10 +698,28 @@ asynchrone déf charger_donnees_comparaison(entite_id: chaine, type_entite: chai
                         ids.ajouter(artiste_id)
                         si label_art:
                             labels[artiste_id] = label_art
-            donnees_courantes = donnees_comparaison.obtenir(entite_id, {})
-            donnees_courantes["artistes_ids"] = ids
-            donnees_courantes["artistes_labels"] = labels
-            donnees_comparaison[entite_id] = donnees_courantes
+            _enregistrer_donnees_comparaison(entite_id, existantes.obtenir("label", entite_id), ids, labels, "artists")
+        sauf erreur:
+            passe
+    sinon si type_entite == "artiste":
+        essayer:
+            oeuvres = attendre donnees.requetes.obtenir_oeuvres_artiste(entite_id, 50, mode_langue_actif)
+            extraites = _extraire_oeuvres_comparaison(oeuvres)
+            _enregistrer_donnees_comparaison(entite_id, existantes.obtenir("label", entite_id), extraites.obtenir("ids", []), extraites.obtenir("labels", {}), "artworks")
+        sauf erreur:
+            passe
+    sinon si type_entite == "musee":
+        essayer:
+            oeuvres = attendre donnees.requetes.obtenir_oeuvres_musee(entite_id, 50, mode_langue_actif)
+            extraites = _extraire_oeuvres_comparaison(oeuvres)
+            _enregistrer_donnees_comparaison(entite_id, existantes.obtenir("label", entite_id), extraites.obtenir("ids", []), extraites.obtenir("labels", {}), "artworks")
+        sauf erreur:
+            passe
+    sinon si type_entite == "sujet":
+        essayer:
+            oeuvres = attendre donnees.requetes.obtenir_oeuvres_par_sujet(entite_id, 50, mode_langue_actif)
+            extraites = _extraire_oeuvres_comparaison(oeuvres)
+            _enregistrer_donnees_comparaison(entite_id, existantes.obtenir("label", entite_id), extraites.obtenir("ids", []), extraites.obtenir("labels", {}), "artworks")
         sauf erreur:
             passe
 
@@ -713,10 +761,35 @@ asynchrone déf trouver_trajectoire_influence(depart_id: chaine, arrivee_id: cha
     affichage_chargement = vrai
 
     essayer:
-        attendre construire_graphe_influences(depart_id)
-        attendre construire_graphe_influences(arrivee_id)
-
-        chemin = graphe.chemin_plus_court(depart_id, arrivee_id)
+        chemin = []
+        visites = {depart_id}
+        queue = [[depart_id]]
+        profondeur_max = 4
+
+        # Le graphe courant est incomplet: enrichir les voisins d'influence à mesure du BFS.
+        tantque len(queue) > 0 et non chemin:
+            chemin_courant = queue.pop(0)
+            noeud_courant = chemin_courant[len(chemin_courant) - 1]
+
+            si len(chemin_courant) - 1 < profondeur_max:
+                attendre construire_graphe_influences(noeud_courant)
+                voisins = graphe.obtenir_voisins(noeud_courant, "a_influence")
+
+                pour voisin_id dans voisins:
+                    si non chemin:
+                        nouveau_chemin = []
+                        pour etape_id dans chemin_courant:
+                            nouveau_chemin.ajouter(etape_id)
+                        nouveau_chemin.ajouter(voisin_id)
+
+                        si voisin_id == arrivee_id:
+                            chemin = nouveau_chemin
+                        sinon si voisin_id non dans visites:
+                            visites.ajouter(voisin_id)
+                            queue.ajouter(nouveau_chemin)
+
+        si non chemin:
+            chemin = graphe.chemin_plus_court(depart_id, arrivee_id)
 
         labels = {}
         pour noeud_id dans chemin: