Upload 41 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+cles_analyse_iramuteq.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,43 @@
+# Rôle du fichier: Dockerfile porte une partie du pipeline d'analyse Rainette.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+
+FROM rocker/r2u:22.04
+
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Python pour spaCy
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+      ca-certificates \
+      python3 \
+      python3-pip \
+    && rm -rf /var/lib/apt/lists/*
+
+# Paquets R (r2u installe en binaires via apt/bspm, donc très rapide)
+RUN install.r shiny quanteda wordcloud RColorBrewer igraph dplyr htmltools remotes irlba
+
+# FactoMineR depuis GitHub (sans tirer les Suggests)
+RUN R -q -e "options(repos=c(CRAN='https://cloud.r-project.org')); remotes::install_github('husson/FactoMineR', dependencies=NA, upgrade='never')"
+
+# Utilisateur non-root compatible Hugging Face
+RUN set -eux; \
+    if ! id -u user >/dev/null 2>&1; then \
+      if getent passwd 1000 >/dev/null 2>&1; then \
+        useradd -m -u 1001 user; \
+      else \
+        useradd -m -u 1000 user; \
+      fi; \
+    fi
+
+ENV HOME=/home/user
+WORKDIR /home/user/app
+
+COPY . /home/user/app
+
+RUN chown -R user:user /home/user/app
+
+USER user
+EXPOSE 7860
+CMD ["Rscript", "/home/user/app/rainette/start.R"]

app.R

@@ -0,0 +1,639 @@
+# Rôle du fichier: app.R porte une partie du pipeline d'analyse Rainette.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+
+###############################################################################
+#                    Script CHD - version beta 0.4 - 18-02-2026               #
+#      A partir d'un corpus texte formaté aux exigences IRAMUTEQ              #
+#                            Stéphane Meurisse                                #
+#                           wwww.codeandcortex.fr                             #          
+#                                                                             #
+#      1.Réalise la CHD sur le corpus, sans rainette_explor                   #
+#      2.Extrait chi2, lr, freq, docprop dans un CSV                          #
+#      3.AFC                                                                  #
+#      4.Recherche de NER avec Spacy (md)                                     #
+#      5.Génère nuages de mots et graphes de cooccurrences par classe         #
+#      6.Exporte les segments de texte par classe au format text              #
+#      7.Creation d'un concordancier au format html                           #
+#      8.Recherche de coocurrences                                            #
+###############################################################################
+
+library(shiny)
+library(quanteda)
+library(wordcloud)
+library(RColorBrewer)
+library(igraph)
+library(dplyr)
+library(htmltools)
+
+options(shiny.maxRequestSize = 300 * 1024^2)
+options(shinygadgets.viewer = shiny::browserViewer())
+options(bspm.sudo = TRUE)
+
+if (file.exists("help.md")) {
+  ui_aide_huggingface <- function() {
+    tagList(
+      tags$h2("Aide"),
+      includeMarkdown("help.md")
+    )
+  }
+} else {
+  ui_aide_huggingface <- function() {
+    tagList(
+      tags$h2("Aide"),
+      tags$p("Le fichier help.md est introuvable. Ajoute help.md à la racine du projet.")
+    )
+  }
+}
+
+
+source("iramuteq-like/nettoyage_iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/concordancier-iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("spacy_ner/concordancier_ner.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/afc_iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/ui_options_iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/affichage_iramuteq-like.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/wordcloud_iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("ui.R", encoding = "UTF-8", local = TRUE)
+
+source("iramuteq-like/chd_iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/dendogramme_iramuteq.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/stats_chd.R", encoding = "UTF-8", local = TRUE)
+source("iramuteq-like/chd_engine_iramuteq.R", encoding = "UTF-8", local = TRUE)
+
+server <- function(input, output, session) {
+
+  rv <- reactiveValues(
+    logs = "",
+    statut = "En attente.",
+    progression = 0,
+
+    base_dir = NULL,
+    export_dir = NULL,
+    segments_file = NULL,
+    stats_file = NULL,
+    html_file = NULL,
+    ner_file = NULL,
+    zip_file = NULL,
+
+    res = NULL,
+    res_chd = NULL,
+    dfm_chd = NULL,
+    dfm = NULL,
+    filtered_corpus = NULL,
+    res_stats_df = NULL,
+    clusters = NULL,
+    max_n_groups = NULL,
+    max_n_groups_chd = NULL,
+
+    res_type = "simple",
+
+    exports_prefix = paste0("exports_", session$token),
+
+    spacy_tokens_df = NULL,
+    lexique_fr_df = NULL,
+    textes_indexation = NULL,
+
+    ner_df = NULL,
+    ner_nb_segments = NA_integer_,
+
+    afc_obj = NULL,
+    afc_erreur = NULL,
+
+    afc_vars_obj = NULL,
+    afc_vars_erreur = NULL,
+
+    afc_dir = NULL,
+    afc_table_mots = NULL,
+    afc_table_vars = NULL,
+    afc_plot_classes = NULL,
+    afc_plot_termes = NULL,
+    afc_plot_vars = NULL,
+
+    explor_assets = NULL,
+    stats_corpus_df = NULL,
+    stats_zipf_df = NULL
+  )
+
+  register_outputs_status(input, output, session, rv)
+
+  output$ui_afc_statut <- renderUI({
+    if (!is.null(rv$afc_erreur) && nzchar(rv$afc_erreur)) {
+      return(tags$p("AFC : erreur (voir ci-dessous)."))
+    }
+    if (is.null(rv$afc_obj) || is.null(rv$afc_obj$ca)) {
+      return(tags$p("AFC non calculée. Lance une analyse pour calculer l'AFC classes × termes."))
+    }
+    ncl <- nrow(rv$afc_obj$table)
+    nt <- ncol(rv$afc_obj$table)
+    tags$p(paste0("AFC calculée sur ", ncl, " classes et ", nt, " termes (table Classes × Termes)."))
+  })
+
+  output$ui_afc_erreurs <- renderUI({
+    messages <- Filter(
+      nzchar,
+      list(
+        rv$afc_erreur,
+        rv$afc_vars_erreur
+      )
+    )
+
+    if (length(messages) == 0) {
+      return(NULL)
+    }
+
+    tags$div(
+      style = "display: flex; flex-direction: column; gap: 8px; margin-bottom: 12px;",
+      lapply(messages, function(msg) {
+        tags$div(
+          style = "border: 1px solid #f5c2c7; background: #f8d7da; color: #842029; border-radius: 4px; padding: 10px; white-space: pre-wrap;",
+          msg
+        )
+      })
+    )
+  })
+
+  output$ui_spacy_langue_detection <- renderUI({
+    if (identical(input$source_dictionnaire, "lexique_fr")) {
+      return(NULL)
+    }
+
+  output$ui_ner_lexique_incompatibilite <- renderUI({
+    if (!isTRUE(input$activer_ner) || !identical(input$source_dictionnaire, "lexique_fr")) {
+      return(NULL)
+    }
+
+  output$ui_corpus_preview <- renderUI({
+    fichier <- input$fichier_corpus
+    if (is.null(fichier) || is.null(fichier$datapath) || !file.exists(fichier$datapath)) {
+      return(tags$p("Aucun corpus importé pour le moment."))
+    }
+
+    lignes <- tryCatch(
+      readLines(fichier$datapath, encoding = "UTF-8", warn = FALSE),
+      error = function(e) NULL
+    )
+
+    if (is.null(lignes) || length(lignes) == 0) {
+      return(tags$p("Le corpus importé est vide ou illisible."))
+    }
+
+    max_lignes <- 250
+    extrait <- lignes[seq_len(min(length(lignes), max_lignes))]
+    texte <- paste(extrait, collapse = "\n")
+
+    if (length(lignes) > max_lignes) {
+      texte <- paste0(
+        texte,
+        "\n\n… Aperçu limité aux ", max_lignes,
+        " premières lignes (", length(lignes), " lignes au total)."
+      )
+    }
+
+    tags$div(
+      tags$p(
+        style = "margin-bottom: 8px;",
+        paste0("Fichier : ", fichier$name)
+      ),
+      tags$pre(
+        style = "white-space: pre-wrap; max-height: 70vh; overflow-y: auto; border: 1px solid #ddd; padding: 10px; background: #fafafa;",
+        texte
+      )
+    )
+  })
+
+  output$ui_table_stats_corpus <- renderUI({
+    req(rv$stats_corpus_df)
+
+    definitions <- c(
+      "Nom du corpus" = "Nom du fichier corpus importé.",
+      "Nombre de textes" = "Nombre d'unités de texte détectées dans le corpus.",
+      "Nombre de mots dans le corpus" = "Total des occurrences de mots (tokens).",
+      "Nombre de formes" = "Nombre de formes lexicales distinctes (types), différent des hapax.",
+      "Nombre de segments de texte" = "Nombre de segments après découpage pour l'analyse.",
+      "Nombre d'Hapax" = "Nombre de formes apparaissant une seule fois dans le corpus.",
+      "Loi de Zpif" = "Indicateur de conformité approximative à la loi de Zipf."
+    )
+
+    lignes <- lapply(seq_len(nrow(rv$stats_corpus_df)), function(i) {
+      metrique <- as.character(rv$stats_corpus_df$Metrique[i])
+      valeur <- as.character(rv$stats_corpus_df$Valeur[i])
+      definition <- unname(definitions[[metrique]])
+      if (is.null(definition) || !nzchar(definition)) definition <- ""
+
+      tags$tr(
+        tags$td(
+          tags$div(metrique),
+          if (nzchar(definition)) tags$div(
+            style = "font-size: 0.85em; color: #c62828; margin-top: 2px;",
+            definition
+          )
+        ),
+        tags$td(valeur)
+      )
+    })
+
+    tags$table(
+      class = "table table-striped table-condensed",
+      tags$thead(
+        tags$tr(
+          tags$th("Metrique"),
+          tags$th("Valeur")
+        )
+      ),
+      tags$tbody(lignes)
+    )
+  })
+
+
+  output$plot_stats_zipf <- renderPlot({
+    req(rv$stats_zipf_df)
+    df <- rv$stats_zipf_df
+    if (is.null(df) || nrow(df) < 2) {
+      plot.new()
+      text(0.5, 0.5, "Données insuffisantes pour tracer la loi de Zpif.", cex = 1.1)
+      return(invisible(NULL))
+    }
+
+    x_lim <- range(df$log_rang, na.rm = TRUE)
+    y_lim <- range(c(df$log_frequence, df$log_pred), na.rm = TRUE)
+
+    plot(
+      x = df$log_rang,
+      y = df$log_frequence,
+      pch = 16,
+      cex = 0.8,
+      col = grDevices::adjustcolor("#2C7FB8", alpha.f = 0.7),
+      xlab = "log(rang)",
+      ylab = "log(fréquence)",
+      main = "Loi de Zpif",
+      xlim = x_lim,
+      ylim = y_lim,
+      asp = 1
+    )
+    grid(col = "#E6E6E6", lty = "dotted")
+
+    ord <- order(df$log_rang)
+    lines(df$log_rang[ord], df$log_pred[ord], col = "#D7301F", lwd = 2.5)
+
+    legend(
+      "topright",
+      legend = c("Données", "Régression log-log"),
+      col = c("#2C7FB8", "#D7301F"),
+      pch = c(16, NA),
+      lty = c(NA, 1),
+      lwd = c(NA, 2),
+      bty = "n"
+    )
+  })
+
+  output$ui_chd_statut <- renderUI({
+    if (is.null(rv$res)) {
+      return(tags$p("CHD non disponible. Lance une analyse."))
+    }
+
+    nb_classes <- NA_integer_
+    if (!is.null(rv$clusters)) nb_classes <- length(rv$clusters)
+
+    if (identical(rv$res_type, "iramuteq")) {
+      return(tags$p(paste0("CHD disponible (moteur IRaMuTeQ-like) - classes détectées : ", nb_classes, ".")))
+    }
+
+    if (identical(rv$res_type, "double")) {
+      return(tags$p("CHD disponible (classification double rainette2)."))
+    }
+
+    tags$p(paste0("CHD disponible (classification simple rainette) - classes détectées : ", nb_classes, "."))
+  })
+
+  register_events_lancer(input, output, session, rv)
+  register_rainette_explor_affichage(input, output, session, rv)
+
+  output$plot_afc_classes <- renderPlot({
+    if (!is.null(rv$afc_erreur) && nzchar(rv$afc_erreur)) {
+      plot.new()
+      text(0.5, 0.5, "AFC indisponible (erreur).", cex = 1.1)
+      return(invisible(NULL))
+    }
+    if (is.null(rv$afc_obj) || is.null(rv$afc_obj$ca)) {
+      plot.new()
+      text(0.5, 0.5, "AFC non disponible. Lance une analyse.", cex = 1.1)
+      return(invisible(NULL))
+    }
+    tracer_afc_classes_seules(rv$afc_obj, axes = c(1, 2), cex_labels = 1.05)
+  })
+
+    panneaux <- lapply(classes, function(cl) {
+      output_id <- paste0("table_stats_chd_iramuteq_cl_", cl)
+
+      output[[output_id]] <- renderTable({
+        extraire_stats_chd_classe(
+          rv$res_stats_df,
+          classe = cl,
+          n_max = 100,
+          show_negative = FALSE,
+          max_p = if (isTRUE(input$filtrer_affichage_pvalue)) input$max_p else 1,
+          seuil_p_significativite = input$max_p,
+          style = "iramuteq_clone"
+        )
+      }, rownames = FALSE, sanitize.text.function = function(x) x)
+
+      tabPanel(
+        title = paste0("Classe ", cl),
+        tableOutput(output_id)
+      )
+    })
+
+    do.call(tabsetPanel, c(id = "tabs_stats_chd_iramuteq", panneaux))
+  })
+
+
+    if (is.null(rv$exports_prefix) || !nzchar(rv$exports_prefix)) {
+      return(tags$div(
+        style = "padding: 12px;",
+        tags$p("Préfixe de ressources invalide."),
+        tags$p("Relance l'analyse pour régénérer les exports.")
+      ))
+    }
+
+    if (!(rv$exports_prefix %in% names(shiny::resourcePaths()))) {
+      shiny::addResourcePath(rv$exports_prefix, rv$export_dir)
+    }
+
+    candidats_html <- c(
+      rv$html_file,
+      file.path(rv$export_dir, "segments_par_classe.html"),
+      file.path(rv$export_dir, "concordancier.html")
+    )
+    candidats_dyn <- list.files(
+      rv$export_dir,
+      pattern = "(segments.*classe|concord).*\\.html$",
+      ignore.case = TRUE,
+      full.names = TRUE
+    )
+    candidats_html <- c(candidats_html, candidats_dyn)
+    candidats_html <- unique(candidats_html[!is.na(candidats_html) & nzchar(candidats_html)])
+    html_existant <- candidats_html[file.exists(candidats_html)]
+
+    if (length(html_existant) == 0) {
+      return(tags$div(
+        style = "padding: 12px;",
+        tags$p("Le fichier du concordancier HTML n'est pas disponible pour cette analyse."),
+        tags$p("Relance l'analyse puis vérifie les logs si le problème persiste.")
+      ))
+    }
+
+    src_html <- html_existant[[1]]
+    nom_html <- basename(src_html)
+    src_dans_exports <- file.path(rv$export_dir, nom_html)
+
+    if (!isTRUE(file.exists(src_dans_exports))) {
+      ok_copy <- tryCatch(file.copy(src_html, src_dans_exports, overwrite = TRUE), error = function(e) FALSE)
+      if (isTRUE(ok_copy)) src_html <- src_dans_exports
+    } else {
+      src_html <- src_dans_exports
+    }
+
+    tags$iframe(
+      src = paste0("/", rv$exports_prefix, "/", basename(src_html)),
+      style = "width: 100%; height: 70vh; border: 1px solid #999;"
+    )
+  })
+
+    tags$div(
+      style = "text-align: center;",
+      tags$img(
+        src = paste0("/", rv$exports_prefix, "/", src_rel),
+        style = "max-width: 100%; height: auto; border: 1px solid #999; display: inline-block;"
+      )
+    )
+  })
+
+  output$table_stats_classe <- renderTable({
+    req(input$classe_viz, rv$res_stats_df)
+    classe_norm <- normaliser_id_classe_ui(input$classe_viz)
+    classe_stats <- if (is.na(classe_norm)) input$classe_viz else classe_norm
+
+    extraire_stats_chd_classe(
+      rv$res_stats_df,
+      classe = classe_stats,
+      n_max = 50,
+      max_p = if (isTRUE(input$filtrer_affichage_pvalue)) input$max_p else 1,
+      seuil_p_significativite = input$max_p,
+      style = "iramuteq_clone"
+    )
+  }, rownames = FALSE, sanitize.text.function = function(x) x)
+
+  output$plot_afc <- renderPlot({
+    if (!is.null(rv$afc_erreur) && nzchar(rv$afc_erreur)) {
+      plot.new()
+      text(0.5, 0.5, "AFC indisponible (erreur).", cex = 1.1)
+      return(invisible(NULL))
+    }
+    if (is.null(rv$afc_obj) || is.null(rv$afc_obj$ca)) {
+      plot.new()
+      text(0.5, 0.5, "AFC non disponible. Lance une analyse.", cex = 1.1)
+      return(invisible(NULL))
+    }
+
+    activer_repel <- TRUE
+    if (!is.null(input$afc_reduire_chevauchement)) activer_repel <- isTRUE(input$afc_reduire_chevauchement)
+
+    taille_sel <- "frequency"
+    if (!is.null(input$afc_taille_mots) && nzchar(as.character(input$afc_taille_mots))) {
+      taille_sel <- as.character(input$afc_taille_mots)
+    }
+    if (!taille_sel %in% c("frequency", "chi2")) taille_sel <- "frequency"
+
+    top_termes <- 120
+    if (!is.null(input$afc_top_termes) && is.finite(input$afc_top_termes)) top_termes <- as.integer(input$afc_top_termes)
+
+    tracer_afc_classes_termes(rv$afc_obj, axes = c(1, 2), top_termes = top_termes, taille_sel = taille_sel, activer_repel = activer_repel)
+  })
+
+  output$ui_table_afc_mots_par_classe <- renderUI({
+    if (is.null(rv$afc_table_mots)) {
+      output$table_afc_mots_message <- renderTable({
+        data.frame(Message = "AFC mots : non disponible.", stringsAsFactors = FALSE)
+      }, rownames = FALSE)
+      return(tableOutput("table_afc_mots_message"))
+    }
+
+    df <- rv$afc_table_mots
+    colonnes <- intersect(c("Terme", "Classe_max", "frequency", "chi2", "p_value", "Segment_texte"), names(df))
+    df <- df[, colonnes, drop = FALSE]
+    if ("p_value" %in% names(df)) {
+      df$p_value <- ifelse(
+        is.na(df$p_value),
+        NA_character_,
+        formatC(df$p_value, format = "f", digits = 6)
+      )
+    }
+
+    classes <- unique(as.character(df$Classe_max))
+    classes <- classes[!is.na(classes) & nzchar(classes)]
+    classes <- sort(classes)
+
+    if (length(classes) == 0) {
+      output$table_afc_mots_message <- renderTable({
+        data.frame(Message = "AFC mots : aucune classe disponible.", stringsAsFactors = FALSE)
+      }, rownames = FALSE)
+      return(tableOutput("table_afc_mots_message"))
+    }
+
+    ui_tables <- lapply(seq_along(classes), function(i) {
+      cl <- classes[[i]]
+      id <- paste0("table_afc_mots_", i)
+
+      output[[id]] <- renderUI({
+        sous_df <- df[df$Classe_max == cl, , drop = FALSE]
+        colonnes <- intersect(c("Terme", "frequency", "chi2", "p_value", "Segment_texte"), names(sous_df))
+        sous_df <- sous_df[, colonnes, drop = FALSE]
+
+        if ("p_value" %in% names(sous_df)) {
+          sous_df$p_value <- ifelse(
+            is.na(sous_df$p_value),
+            NA_character_,
+            formatC(sous_df$p_value, format = "f", digits = 6)
+          )
+        }
+
+        if ("chi2" %in% names(sous_df)) {
+          sous_df <- sous_df[order(-sous_df$chi2), , drop = FALSE]
+          sous_df$chi2 <- ifelse(
+            is.na(sous_df$chi2),
+            NA_character_,
+            formatC(sous_df$chi2, format = "f", digits = 6)
+          )
+        }
+
+        sous_df <- head(sous_df, 100)
+        generer_table_html_afc_mots(sous_df)
+      })
+
+      tagList(
+        tags$h5(cl),
+        uiOutput(id)
+      )
+    })
+
+    do.call(tagList, ui_tables)
+  })
+
+  output$plot_afc_vars <- renderPlot({
+    if (!is.null(rv$afc_vars_erreur) && nzchar(rv$afc_vars_erreur)) {
+      plot.new()
+      text(0.5, 0.5, "AFC variables étoilées indisponible (erreur).", cex = 1.1)
+      return(invisible(NULL))
+    }
+    if (is.null(rv$afc_vars_obj) || is.null(rv$afc_vars_obj$ca)) {
+      plot.new()
+      text(0.5, 0.5, "AFC variables étoilées non disponible. Lance une analyse.", cex = 1.1)
+      return(invisible(NULL))
+    }
+
+    activer_repel <- TRUE
+    if (!is.null(input$afc_reduire_chevauchement)) activer_repel <- isTRUE(input$afc_reduire_chevauchement)
+
+    top_mod <- 120
+    if (!is.null(input$afc_top_modalites) && is.finite(input$afc_top_modalites)) top_mod <- as.integer(input$afc_top_modalites)
+
+    tracer_afc_variables_etoilees(rv$afc_vars_obj, axes = c(1, 2), top_modalites = top_mod, activer_repel = activer_repel)
+  })
+
+  output$table_afc_vars <- renderTable({
+    if (is.null(rv$afc_table_vars)) {
+      return(data.frame(Message = "AFC variables étoilées : non disponible.", stringsAsFactors = FALSE))
+    }
+    df <- rv$afc_table_vars
+    colonnes <- intersect(c("Modalite", "Classe_max", "frequency", "chi2", "p_value"), names(df))
+    df <- df[, colonnes, drop = FALSE]
+    if ("p_value" %in% names(df)) {
+      p_values <- df$p_value
+      df$p_value <- ifelse(
+        is.na(p_values),
+        NA_character_,
+        ifelse(
+          p_values > 0.05,
+          sprintf("<span style='color:#d97706;font-weight:600;'>%s</span>", formatC(p_values, format = "f", digits = 6)),
+          formatC(p_values, format = "f", digits = 6)
+        )
+      )
+    }
+    if ("chi2" %in% names(df)) df <- df[order(-df$chi2), , drop = FALSE]
+    if ("chi2" %in% names(df)) {
+      df$chi2 <- ifelse(
+        is.na(df$chi2),
+        NA_character_,
+        formatC(df$chi2, format = "f", digits = 6)
+      )
+    }
+    head(df, 200)
+  }, rownames = FALSE, sanitize.text.function = function(x) x)
+
+  output$table_afc_eig <- renderTable({
+    if (!is.null(rv$afc_erreur) && nzchar(rv$afc_erreur)) {
+      return(data.frame(Message = "AFC indisponible (erreur).", stringsAsFactors = FALSE))
+    }
+    if (is.null(rv$afc_obj) || is.null(rv$afc_obj$ca)) {
+      return(data.frame(Message = "AFC non disponible.", stringsAsFactors = FALSE))
+    }
+    eig <- rv$afc_obj$ca$eig
+    if (is.null(eig)) return(data.frame(Message = "Valeurs propres indisponibles.", stringsAsFactors = FALSE))
+    df <- as.data.frame(eig)
+    df$Dim <- rownames(df)
+    rownames(df) <- NULL
+    df <- df[, c("Dim", names(df)[1], names(df)[2], names(df)[3]), drop = FALSE]
+    names(df) <- c("Dim", "Valeur_propre", "Pourcentage_inertie", "Pourcentage_cumule")
+    df
+  }, rownames = FALSE)
+
+  output$dl_segments <- downloadHandler(
+    filename = function() "segments_par_classe.txt",
+    content = function(file) {
+      req(rv$segments_file)
+      file.copy(rv$segments_file, file, overwrite = TRUE)
+    }
+  )
+
+  output$dl_stats <- downloadHandler(
+    filename = function() "stats_par_classe.csv",
+    content = function(file) {
+      req(rv$stats_file)
+      file.copy(rv$stats_file, file, overwrite = TRUE)
+    }
+  )
+
+  output$dl_html <- downloadHandler(
+    filename = function() "segments_par_classe.html",
+    content = function(file) {
+      req(rv$html_file)
+      file.copy(rv$html_file, file, overwrite = TRUE)
+    }
+  )
+
+  output$dl_zip <- downloadHandler(
+    filename = function() "exports_rainette.zip",
+    content = function(file) {
+      req(rv$zip_file)
+      file.copy(rv$zip_file, file, overwrite = TRUE)
+    }
+  )
+
+  output$dl_afc_zip <- downloadHandler(
+    filename = function() "afc_exports.zip",
+    content = function(file) {
+      req(rv$afc_dir)
+      zip_tmp <- tempfile(fileext = ".zip")
+      ancien <- getwd()
+      on.exit(setwd(ancien), add = TRUE)
+      setwd(dirname(rv$afc_dir))
+      if (file.exists(zip_tmp)) unlink(zip_tmp)
+      utils::zip(zipfile = zip_tmp, files = basename(rv$afc_dir))
+      file.copy(zip_tmp, file, overwrite = TRUE)
+    }
+  )
+
+}
+
+app <- shinyApp(ui = ui, server = server)
+app

gitattributes

@@ -0,0 +1,43 @@
+# Rôle du fichier: gitattributes définit les règles Git appliquées au dépôt.
+# Ce fichier contrôle le suivi des contenus et la normalisation associée.
+# Il évite les écarts de versionnement et garantit une base de travail stable.
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+packages/udpipe/data/brussels_listings.RData filter=lfs diff=lfs merge=lfs -text
+packages/udpipe/data/brussels_reviews_anno.RData filter=lfs diff=lfs merge=lfs -text
+packages/udpipe/data/brussels_reviews_w2v_embeddings_lemma_nl.RData filter=lfs diff=lfs merge=lfs -text
+packages/udpipe/data/brussels_reviews.RData filter=lfs diff=lfs merge=lfs -text
+packages/udpipe/inst/dummydata/toymodel.udpipe filter=lfs diff=lfs merge=lfs -text
+packages/udpipe/french-gsd-ud-2.5-191206.udpipe filter=lfs diff=lfs merge=lfs -text

gitignore

@@ -0,0 +1,4 @@
+# Rôle du fichier: gitignore définit les règles Git appliquées au dépôt.
+# Ce fichier contrôle le suivi des contenus et la normalisation associée.
+# Il évite les écarts de versionnement et garantit une base de travail stable.
+.DS_Store

help/chd.md

@@ -0,0 +1,101 @@
+# CHD — Clarification de `mincl` et de la sélection des classes terminales
+
+## 1) À quoi sert `mincl` ?
+
+`mincl` est le **seuil minimal d'effectif d'une classe** (en pratique : nombre d'UCE/segments) utilisé au moment de la **sélection finale des classes terminales**.
+
+- Si une classe terminale a un effectif `< mincl`, elle peut être écartée telle quelle.
+- Dans la logique IRaMuTeQ, l'algorithme peut alors remonter dans l'arbre vers une classe mère pour garder une partition interprétable.
+
+Autrement dit, `mincl` ne règle pas directement la segmentation du texte : il intervient surtout dans le **post-traitement de l'arbre CHD**.
+
+---
+
+## 2) Comment IRaMuTeQ applique `mincl` ?
+
+Dans les scripts historiques d'IRaMuTeQ :
+
+- `find.terminales(...)` conserve d'abord les classes terminales dont l'effectif est `>= mincl`.
+- Pour les classes trop petites, il existe une logique de remontée vers la classe mère (via les liens mère/filles) avant de figer la solution.
+- `make.classes(...)` reconstruit ensuite les classes finales et l'arbre filtré.
+
+Cette étape explique pourquoi, à corpus identique, les classes finales peuvent différer d'une implémentation CHD qui n'a pas ce post-traitement.
+
+---
+
+## 3) Valeur "auto" de `mincl` dans IRaMuTeQ
+
+### 3.1 CHD texte (`Rchdtxt`)
+
+Convention utilisée :
+
+- `mincl = 0`  
+  → mode automatique
+
+Formule auto :
+
+\[
+mincl = round(nrow(classeuce1) / ind)
+\]
+
+avec :
+
+- `ind = nbcl * 2` si `classif_mode == 0` (double classification)
+- sinon `ind = nbcl`
+
+et `nbcl = nbt + 1`.
+
+### 3.2 CHD questionnaire (`Rchdquest`)
+
+Convention différente :
+
+- `mincl = 2`  
+  → mode automatique
+
+Formule auto :
+
+\[
+mincl = round(nrow(classeuce1) / (nbt + 1))
+\]
+
+Puis un plancher est imposé :
+
+- si `mincl < 3` alors `mincl = 3`.
+
+---
+
+## 4) Différence avec le script Rainette de ce projet
+
+Dans ce projet, la classification est obtenue via `rainette(...)` / `rainette2(...)`, puis les groupes sont utilisés directement comme classes.
+
+- Le paramètre `min_split_members` sert principalement à contraindre `k` (nombre de classes faisable).
+- Ce n'est **pas** l'équivalent exact de `mincl` d'IRaMuTeQ.
+
+Conséquence : sans post-traitement "classes terminales" à la manière IRaMuTeQ, le nombre et l'identité des classes finales peuvent varier.
+
+---
+
+## 5) Recommandation d'implémentation (optionnelle)
+
+Pour rapprocher le comportement d'IRaMuTeQ sans casser l'existant :
+
+1. Ajouter un réglage `mode_mincl` :
+   - `manuel`
+   - `auto_iramuteq`
+2. Ajouter `mincl_manuel` (actif seulement en mode manuel).
+3. En mode `auto_iramuteq`, calculer `mincl` avec la formule texte ci-dessus.
+4. Appliquer ensuite un post-traitement de classes terminales (inspiré de `find.terminales`/`make.classes`).
+
+Ainsi, l'utilisateur peut choisir entre :
+
+- un mode Rainette "direct" (plus simple),
+- un mode "IRa-like" (plus proche des sorties IRaMuTeQ).
+
+---
+
+## 6) Vocabulaire rapide
+
+- **UCE / segment** : unité de texte classée.
+- **Classe terminale** : classe feuille dans l'arbre CHD.
+- **Classe mère / filles** : relation hiérarchique dans l'arbre de partition.
+- **`mincl`** : effectif minimal exigé pour conserver une classe terminale telle quelle.

help/chd_iramuteq.md

@@ -0,0 +1,144 @@
+# CHD IRaMuTeQ-like — fonctionnement et paramètres utilisateur
+
+Ce document explique le fonctionnement du mode **CHD IRaMuTeQ-like** dans l’application, les paramètres disponibles, et l’interprétation des sorties (dendrogramme et tableaux de statistiques).
+
+---
+
+## 1) Objectif de la CHD IRaMuTeQ-like
+
+La CHD (Classification Hiérarchique Descendante) cherche à partitionner les segments de texte en classes lexicalement homogènes et distinctes.
+
+Dans ce mode IRaMuTeQ-like, l’algorithme suit la logique historique IRaMuTeQ :
+- découpage hiérarchique en classes,
+- sélection de classes terminales,
+- calcul des termes caractéristiques par classe (chi2 signé, p-value, fréquence, proportion documentaire),
+- visualisation via un dendrogramme de style phylogramme.
+
+---
+
+## 2) Pipeline simplifié
+
+1. **Préparation du DFM** (matrice documents/termes) à partir des segments.
+2. **Lancement du moteur CHD** avec un nombre de classes cible (paramètre `k`).
+3. **Reconstruction des classes terminales** avec un seuil `mincl` (auto ou manuel).
+4. **Calcul des statistiques par classe**:
+   - chi2 signé,
+   - p-value,
+   - fréquence (`frequency`),
+   - proportion documentaire (`docprop`),
+   - ratio de vraisemblance (`lr`).
+5. **Rendu visuel**:
+   - dendrogramme CHD IRaMuTeQ-like,
+   - tableaux de stats par classe,
+   - vues AFC (si activées).
+
+---
+
+## 3) Paramètres utilisateur (côté interface)
+
+> Les noms affichés peuvent légèrement varier selon l’écran, mais la logique fonctionnelle est la suivante.
+
+### 3.1 Nombre de classes (`k`)
+- **Libellé dans l’interface**: « Nombre de classes terminales de la phase 1 ».
+- **Valeur par défaut**: `10`.
+- **Rôle**: fixe le niveau de découpage attendu.
+- **Effet**: plus `k` est élevé, plus la partition est fine (classes plus nombreuses, parfois moins stables).
+- **Valeurs recommandées**:
+  - petits corpus: 3 à 6,
+  - corpus moyens/grands: 4 à 10.
+
+### 3.2 Mode de classification (`classif_mode`)
+- **Valeurs**: `simple` ou `double`.
+- **Rôle**:
+  - `simple`: classification standard,
+  - `double`: logique de classification croisée (plus stricte, selon configuration).
+
+### 3.3 Seuil minimal de classe (`mincl`) + mode auto/manuel (`mincl_mode`)
+- **`mincl_mode = auto`**: le système calcule automatiquement un minimum d’effectif par classe.
+- **`mincl_mode = manuel`**: l’utilisateur impose `mincl`.
+- **Effet**:
+  - `mincl` plus grand = classes plus robustes, mais potentiellement moins nombreuses,
+  - `mincl` plus petit = classes plus fines, mais plus sensibles au bruit.
+
+### 3.4 Seuil de p-value (`max_p`)
+- **Rôle**: filtre des termes dans certaines vues statistiques.
+- **Exemples**:
+  - `0.05` pour les termes statistiquement marqués,
+  - `1` pour ne pas filtrer (vue exhaustive).
+
+### 3.5 Binarisation (`binariser`)
+- **Rôle**: transforme les fréquences en présence/absence avant CHD.
+- **Usage**: en général activée pour rester proche des pratiques historiques CHD lexicales.
+
+### 3.6 Méthode SVD (`svd_method`)
+- **Valeurs**: `irlba`, `svdR`.
+- **Rôle**: méthode de décomposition utilisée dans l’étape factorielle interne.
+- **Interprétation des méthodes**:
+  - `irlba` : appelle `irlba::irlba(...)`, une SVD tronquée itérative adaptée aux matrices creuses/volumineuses ; souvent plus rapide et plus robuste en mémoire pour la CHD,
+  - `svdR` : appelle `svd(...)` de base R ; calcul exact complet, utile comme référence de reproductibilité mais potentiellement plus coûteux.
+- **Par défaut**: `irlba`.
+
+### 3.7 Mode patate (`mode_patate`)
+- **Rôle**: active/désactive l’étape de reclassement itératif des individus selon le moteur historique.
+- **Effet**:
+  - désactivé (`FALSE`) = reclassement plus complet,
+  - activé (`TRUE`) = comportement simplifié/rapide.
+
+---
+
+## 4) Sorties et interprétation
+
+### 4.1 Dendrogramme CHD (IRaMuTeQ-like)
+- Représentation en **phylogramme**:
+  - axe x: profondeur de partition,
+  - axe y: ordre des classes terminales.
+- Les classes terminales peuvent être colorées différemment.
+- Si la structure est incomplète (données trop pauvres ou sortie CHD invalide), un message explicite est affiché.
+
+### 4.2 Tableau statistique par classe
+Colonnes principales:
+- **Terme**: forme lexicale.
+- **chi2**: chi2 signé (positif = sur-représenté dans la classe; négatif = sous-représenté).
+- **p**: p-value associée.
+- **frequency**: fréquence du terme dans la classe.
+- **docprop**: proportion de segments de la classe contenant le terme.
+- **lr**: ratio de vraisemblance (indicateur complémentaire).
+
+---
+
+## 5) Bonnes pratiques pour l’utilisateur
+
+1. Commencer avec un `k` modéré (4–6).
+2. Vérifier l’équilibre des classes (éviter des classes trop petites).
+3. Ajuster `mincl` si beaucoup de classes instables apparaissent.
+4. Utiliser `max_p = 0.05` pour une lecture interprétative, puis `max_p = 1` pour audit complet.
+
+---
+
+## 6) Dépannage rapide
+
+### Problème: pas de dendrogramme / message d’erreur
+- Vérifier que le corpus contient suffisamment de segments et de vocabulaire.
+- Réduire `k`.
+- Revenir à `mincl_mode = auto`.
+
+### Problème: tableau de stats vide
+- Vérifier les filtres (`max_p` trop strict).
+- Vérifier que les classes reconstruites ne sont pas nulles.
+
+### Problème: résultats instables entre exécutions
+- Éviter de changer simultanément plusieurs paramètres (`k`, `mincl`, `svd_method`).
+
+---
+
+## 7) Paramètres “utilisateur” recommandés (profil de départ)
+
+- `k = 5`
+- `classif_mode = simple`
+- `mincl_mode = auto`
+- `max_p = 0.05`
+- `binariser = TRUE`
+- `svd_method = irlba`
+- `mode_patate = FALSE`
+
+Ce profil donne généralement un bon compromis entre lisibilité des classes, stabilité et interprétabilité.

help/help.md

@@ -0,0 +1,115 @@
+[//]: # (Rôle du fichier: help.md documente une partie de l'application Rainette.)
+[//]: # (Ce document sert de référence fonctionnelle/technique pour l'équipe.)
+[//]: # (Il décrit le comportement attendu afin de sécuriser maintenance et diagnostics.)
+### codeandcortex.fr - Stéphane Meurisse - version beta 0.4 - 18-02-2026
+- <a href="https://www.codeandcortex.fr" target="_blank" rel="noopener noreferrer">codeandcortex.fr</a>
+- <a href="https://www.codeandcortex.fr/comprendre-chd-methode-reinert/" target="_blank" rel="noopener noreferrer">Comprendre la CHD</a>
+
+
+### IRaMuTeQ
+IRaMuTeQ, développé par Pierre Ratinaud, est un logiciel libre devenu une référence pour l’analyse textuelle en sciences humaines et sociales. Il met en œuvre la méthode de Reinert (CHD), l’AFC, ainsi que l’analyse de similitudes de Vergès, et propose de nombreux traitements complémentaires pour explorer la structure lexicale d’un corpus. Un atout est son dictionnaire de lemmes, plus précis et performant que beaucoup d’alternatives, ce qui améliore la stabilité des classes. Depuis la version 0.4 vous avez le choix avec le dictionnaire NLP de spaCy et celui de **IRaMuTeQ - lexique_fr** (uniquement fr)
+Ce qui change à partir de la version O.4 c'est l'utilisation du **dictionnaire** utilisé par **IRaMuTeQ** (uniquement fr). **Ce dictionnaire est plus précis que spaCy**.
+
+- <a href="https://pratinaud.gitpages.huma-num.fr/iramuteq-website/" target="_blank" rel="noopener noreferrer">IRaMuTeQ</a>
+
+
+### Méthode Reinert - CHD
+
+La méthode de Reinert est une approche statistique d’analyse lexicale conçue pour dégager des « mondes lexicaux » dans un corpus. 
+L’idée est de repérer des ensembles de segments de texte qui partagent des vocabulaires proches. 
+
+La CHD, pour "classification hiérarchique descendante", est l’algorithme de partitionnement associé à cette méthode. 
+Il procède par divisions successives : on prend l’ensemble des segments, puis on le coupe en deux groupes maximisant leur différenciation lexicale. 
+Ensuite, chaque groupe peut être à nouveau subdivisé, et ainsi de suite, jusqu’à obtenir un nombre de classes jugé pertinent ou une limite imposée par les paramètres.
+
+
+### Rainette développé par Julien Barnier
+
+Rainette est un package R qui réalise une CHD selon la méthode Reinert.
+- <a href="https://github.com/juba/rainette/blob/main/vignettes/introduction_usage.Rmd" target="_blank" rel="noopener noreferrer">Doc Rainette</a>
+- <a href="https://cran.r-project.org/web/packages/rainette/vignettes/introduction_usage.html" target="_blank" rel="noopener noreferrer">Utilisation de rainette</a>
+- <a href="https://juba.r-universe.dev/builds" target="_blank" rel="noopener noreferrer">Builds r-universe</a>
+
+
+### Pourquoi vos fichiers peuvent disparaître sur Hugging Face
+
+Sur Hugging Face Spaces, le stockage local de ce conteneur est temporaire : si le serveur redémarre, ou si la page est rechargée après une déconnexion, les fichiers générés pendant une analyse précédente peuvent ne plus être disponibles.
+
+Conseil : télécharge l’archive ZIP des exports juste après la fin de l’analyse.
+
+
+# Logique générale de l’application
+
+Uploadez un fichier texte au format IRaMuTeQ. L’app segmente, construit une matrice termes-documents (DTM), lance la CHD avec rainette, calcule les statistiques, génère un HTML surligné (concordancier), puis produit la CHD, AFC, NER, nuages de mots et réseaux de cooccurrences. L’onglet d’exploration (Explore_rainette) permet de visualiser la CHD.
+
+### Choix de la langue du dictionnaire spaCy
+
+Vous avez le choix entre 4 langues spaCy préinstallées : français, anglais, espagnol et allemand (modèles "large", lg). D’autres langues peuvent être ajoutées ensuite selon les besoins. Il existe quatre tailles de modèles : "sm", "md", "lg" et "trf" (basé sur la technologie "transformer"). Le script détecte la cohérence entre le choix du dictionnaire et votre corpus importé, sur la base des stopwords.
+
+### Paramètres de l’analyse
+
+- **segment_size** : taille des segments lors du découpage du corpus. Plus petit donne plus de segments, plus grand donne des segments plus longs.
+- **k (nombre de classes)** : nombre de classes demandé pour la CHD.
+- Nombre minimal de termes par segment : `min_segment_size` : Lors de la tokenisation et du calcul de la dtm, certaines formes (mots-outils, mots trop peu fréquents) ont été supprimées, les segments peuvent donc varier en taille. 
+Avec `min_segment_size = 10`, les segments comportant moins de 10 formes sont regroupés avec le segment suivant ou précédent du même document jusqu'à atteindre la taille minimale souhaitée.
+- Effectif minimal pour scinder une classe : **min_split_members**. Nombre minimal de documents pour qu'une classe soit scindée en deux à l'étape suivante de la classification.
+- Fréquence minimale des termes : `dfm_trim min_docfreq` : fréquence minimale en nombre de segments pour conserver un terme dans le DFM. Plus "haut" enlève les termes rares. Par exemple si vous `dfm_trim = 3` cela supprime de la matrice les termes apparaissant dans moins de 3 segments.
+- **max_p (p-value)** : seuil de p-value pour filtrer les termes mis en avant dans les statistiques.
+- **top_n (wordcloud)** : nombre de termes affichés dans chaque nuage de mots.
+- **window (cooccurrences)** : taille de la fenêtre glissante pour calculer les cooccurrences.
+- **top_feat (cooccurrences)** : nombre de termes retenus pour construire le réseau de cooccurrences.
+
+### Options de nettoyage du texte
+
+Ces options agissent surtout sur la **préparation linguistique** (tokenisation, DFM, CHD, stats), pas sur l’affichage "brut" des segments.
+
+- **Nettoyage caractères (regex)** (`nettoyage_caracteres`) : supprime les caractères non autorisés par la regex interne (ex : @).
+- **Supprimer la ponctuation** (`supprimer_ponctuation`) : active `remove_punct` lors de la tokenisation quanteda. La ponctuation est retirée des tokens utilisés pour les analyses (CHD, stats).
+- **Supprimer les chiffres (0-9)** (`supprimer_chiffres`) : supprime les chiffres avant tokenisation.
+- **Traiter les élisions FR** (`supprimer_apostrophes`) : enlève les élisions en début de mot (`c'`, `j'`, `l'`, `m'`, `n'`, `s'`, `t'`, `d'`, `qu'`) pour ramener par ex. `c'est` vers `est`.
+- **Forcer en minuscules avant analyse** (`forcer_minuscules_avant`) : convertit le texte en minuscules avant la construction des tokens/termes.
+
+#### Stopwords en mode IRaMuTeQ-like
+
+- En mode **IRaMuTeQ-like**, la source de lemmatisation est forcée sur **Lexique (fr)**.
+- Donc, quand l'option **Retirer les stopwords** est activée, le filtrage se fait avec les stopwords **français de quanteda** (et non avec spaCy).
+- Le filtrage stopwords via **spaCy** n'est utilisé que lorsque la source de dictionnaire est **spaCy** (mode Rainette).
+
+#### Effet sur le concordancier HTML
+
+- Quand **Supprimer la ponctuation** est cochée, la ponctuation est bien retirée dans les **données d’analyse**.
+- Le **concordancier HTML** continue d’afficher les segments issus du corpus, donc vous pouvez encore voir de la ponctuation dans le texte affiché.
+
+### Classification double (rainette2)
+
+- **Classification double** : l’application combine deux classifications rainette (res1 et res2) via rainette2, puis découpe l’arbre final avec k.
+
+### Lemmatisation (option)
+
+- **Lemmatisation** : si activée, le texte est **lemmatisé avec Spacy ou le dictionnaire de lemme provenant du logiciel IRaMuTeQ - lexique_fr**. La lemmatisation semble (beaucoup) plus efficace avec le dictionnaire IRaMuTeQ provenant de **OpenLexicon (modifié)**.
+
+- <a href="https://openlexicon.fr/" target="_blank" rel="noopener noreferrer">OpenLexicon</a>
+
+### Filtrage Morphosyntaxique
+- **Tokens à conserver** : filtre les tokens conservés selon leur catégorie grammaticale (ex : NOUN, ADJ, VERB, PROPN, ADV...).
+
+### Paramètres SpaCy/NER
+- Activer NER (spaCy) => Détections des entités nommées (NER) par spaCy (ex : "Paris" = "LOC"). Le modele spaCy "md" est un peu léger... pour cette tâche.
+
+### Exploration "Explore_rainette"
+
+- **Classe** : sélection de la classe pour afficher les images et la table de statistiques associées.
+- **CHD** : affichage graphique de la CHD.
+- **Type** : bar (barres) ou cloud (nuage) pour l’affichage des termes par classe.
+- **Statistiques** : chi2, lr, frequency, selon le critère utilisé pour classer les termes.
+- Dans les exports CSV de type (`measure = "chi2"`), les colonnes suivantes sont importantes :
+  - **`n_target`** : nombre d’occurrences du terme dans la classe/cluster analysé.
+  - **`n_reference`** : nombre d’occurrences du même terme dans (tout) le corpus de référence (le reste des classes).
+  - **`chi2`** et **`p`** : test d’association entre cible et référence ; plus `chi2` est élevé et `p` petite, plus le terme est spécifiquement lié à la classe.
+- **Nombre de termes** : nombre de termes affichés par classe dans la visualisation.
+- **Afficher les valeurs négatives** : inclut les termes négativement associés à une classe.
+
+### Démarrage
+
+- L’application ne fait plus de mise à jour automatique de `rainette` au lancement.
+- Si vous voyez un ancien message `AUTO_UPDATE_RAINETTE=true -> tentative de mise à jour`, vérifiez que l’image/conteneur a bien été reconstruit avec la dernière version du dépôt.

help/helpafc.md

@@ -0,0 +1,61 @@
+[//]: # (Rôle du fichier: helpafc.md documente une partie de l'application Rainette.)
+[//]: # (Ce document sert de référence fonctionnelle/technique pour l'équipe.)
+[//]: # (Il décrit le comportement attendu afin de sécuriser maintenance et diagnostics.)
+## Aide AFC : calcul, affichage des termes, rôle de `top_termes`, calcul du `residu de Pearson`
+
+### 1) Comment l’AFC est calculée dans le script
+
+L’AFC classes × termes est calculée en 3 étapes :
+
+1. Construction de la table de contingence **Classes × Termes** depuis le DFM.
+2. Exécution de l’AFC avec `FactoMineR::CA(tab, graph = FALSE)`.
+3. Récupération des coordonnées des classes (`rowcoord`) et des termes (`colcoord`) pour le tracé.
+
+### 2) Qu’est-ce que `top_termes` ?
+
+`top_termes` est **une limite d’affichage graphique** des mots sur le plan AFC. Par défaut : `top_termes = 120`
+
+### 3) Sur quoi `top_termes` filtre ?
+
+Le filtrage est fait dans la fonction de tracé des termes :
+
+1. on part de `termes_stats`,
+2. on enlève les termes vides,
+3. on trie par `frequency` décroissante,
+4. on garde les `top_termes` premiers.
+
+Pourquoi top_termes est en fréquence et pas en p-value ?
+
+Parce que top_termes est une contrainte de lisibilité graphique.
+Le rôle de top_termes est de limiter le nombre de labels affichés dans `tracer_afc_classes_termes`, sinon le plot devient illisible (chevauchements). 
+Le code trie les termes par `frequency` qui détermine ensuite le `top_termes`.
+En amont, dans le pipeline serveur, on construit termes_signif avec `p <= input$max_p`, puis on passe ces termes à `executer_afc_classes`, `termes_cibles` = termes_significatifs). **Donc la p-value réduit le périmètre des termes de l'AFC**.
+
+### 4) Le CSV contient-il seulement `top_termes` ?
+
+Le CSV `stats_termes.csv` exporte la table `rv$afc_obj$termes_stats` (jeu complet de stats AFC disponible), sans appliquer la réduction `top_termes`.
+
+### 5) Note sur l'afc chi2/résidu de Pearson
+
+- Les **positions AFC** viennent de `FactoMineR::CA`.
+- Les **résidus/chi2** sont des statistiques d’association utilisés pour l’interprétation.
+
+### 6) Comment le résidu de Pearson est calculé
+
+Pour chaque mot et chaque classe :
+
+- On regarde combien de fois le mot apparaît réellement dans cette classe.
+- On calcule ensuite combien on aurait “normalement” attendu pour ce mot dans cette classe, si la répartition était neutre.
+- On compare les deux : réel vs attendu, et transforme cet écart en une valeur (le résidu).
+
+Le résidu ne sert pas à recalculer l’AFC.
+
+- Le code extrait, pour chaque mot, la classe où la surreprésentation est la plus forte et sa valeur (`resid_max`).
+- `Classe_max` = la classe où le mot apparaît le plus en quantité brute (le plus d’occurrences observées).
+- `resid_max` = la valeur qui mesure à quel point ce mot est plus (ou moins) présent que prévu dans la classe (sur/sous-représentation)
+ 
+### 7) Résidu positif / résidu négatif
+
+- Résidu positif => le mot est plus présent que prévu dans cette classe (**surreprésenté**).
+- Résidu négatif => le mot est moins présent que prévu dans cette classe (**sous-représenté**).
+- Résidu proche de 0 => présence “normale”, pas d’écart fort.

help/helpchi2.md

@@ -0,0 +1,28 @@
+[//]: # (Rôle du fichier: helpchi2.md documente une partie de l'application Rainette.)
+[//]: # (Ce document sert de référence fonctionnelle/technique pour l'équipe.)
+[//]: # (Il décrit le comportement attendu afin de sécuriser maintenance et diagnostics.)
+## Aide : interprétation du chi2 et de `Classe_max`
+
+Le code calcule un chi2 global par terme sur l’ensemble des classes :
+
+\[
+\chi_j^2 = \sum \frac{(O - E)^2}{E}
+\]
+
+puis une p-value.
+
+En plus, il calcule les résidus standardisés cellule par cellule :
+
+\[
+\frac{O - E}{E}
+\]
+
+- `Classe_max` = la classe où ce résidu est le plus grand pour le terme considéré (`which.max`).
+- C’est la classe de surreprésentation la plus forte pour aider la lecture des résultats.
+- Les classes elles-mêmes viennent du regroupement (`dfm_group`) et sont renommées « Classe X » pour affichage.
+- L’interface confirme : couleur des mots selon la classe de plus forte surreprésentation (résidus), taille selon fréquence ou chi2.
+
+## En une phrase
+
+- `chi2` = « est-ce que la distribution du terme varie globalement selon les classes ? »
+- `Classe_max` = « si oui, dans quelle classe l’excès est le plus marqué ? »

help/ner.md

@@ -0,0 +1,85 @@
+# Named Entity Recognition NER (spaCy + règles JSON)
+
+## Fonctionnement
+1. spaCy détecte des entités (PER, ORG, LOC, etc...) mais le résultat nécessite bien souvent des corrections
+2. Dans le script un mini-filtrage a été ajouté pour supprimer des faux positifs (ponctuation seule, cas bruités, etc...)
+3. Vous pouvez ajouter un fichier au format **.json**, ses règles seront appliquées : exclusions et ajouts
+   
+
+![Import NER](import_ner.png)
+
+
+## Format attendu du fichier JSON
+- Le fichier doit être au **format `.json`**.
+Exemple totalement farfellu montrant que vous pouvze exclure et inclure des mots, créer un nouveau label
+
+```json
+{
+  "exclude_texts": ["ça", "«", "»"],
+  "exclude_labels": ["MISC"],
+  "include": [
+    {"text": "OpenAI", "label": "ORG"},
+    {"text": "ChatGPT", "label": "PRODUCT"},
+    {"text": "regarder", "label": "VERBE"},
+    {"text": "commencer", "label": "VERBE"}
+  ]
+}
+```
+
+
+## Peut-on créer ses propres labels ?
+Oui. Il faut écrire les **LABELS en MAJUSCULES**
+
+- Les entités détectées *nativement* par spaCy gardent les labels du modèle (`PER`, `ORG`, `LOC`, etc.).
+- Les entités ajoutées via `include` peuvent utiliser **n'importe quel label** (ex: `VOTRE_LABEL_1`, `VOTRE_LABEL_2`,...).
+- Ces labels personnalisés apparaissent ensuite dans la sortie NER (`ent_label`).
+
+Exemple: `{"text": "commencer", "label": "ACTION"}` forcera la présence de `commencer` avec le label `ACTION` si le mot est trouvé dans le texte.
+
+## Labels spaCy déjà existants
+Les labels disponibles dépendent du **modèle spaCy chargé**.
+
+### Labels du modèle FR utilisé dans ce projet (`fr_core_news_md`)
+- `PER` : personne
+- `ORG` : organisation
+- `LOC` : lieu
+- `MISC` : catégorie diverse (autres entités)
+
+### Labels NER officiels spaCy (Si je ne me trompe pas avec des modeles "lg" on bénéficie de catégories étendus)
+- `PERSON`: People, including fictional.
+- `NORP`: Nationalities or religious or political groups.
+- `FAC`: Buildings, airports, highways, bridges, etc.
+- `ORG`: Companies, agencies, institutions, etc.
+- `GPE`: Countries, cities, states.
+- `LOC`: Non-GPE locations, mountain ranges, bodies of water.
+- `PRODUCT`: Objects, vehicles, foods, etc. (Not services.)
+- `EVENT`: Named hurricanes, battles, wars, sports events, etc.
+- `WORK_OF_ART`: Titles of books, songs, etc.
+- `LAW`: Named documents made into laws.
+- `LANGUAGE`: Any named language.
+- `DATE`: Absolute or relative dates or periods.
+- `TIME`: Times smaller than a day.
+- `PERCENT`: Percentage, including ”%“.
+- `MONEY`: Monetary values, including unit.
+- `QUANTITY`: Measurements, as of weight or distance.
+- `ORDINAL`: “first”, “second”, etc.
+- `CARDINAL`: Numerals that do not fall under another type.
+
+## Signification des champs JSON
+- `exclude_texts` : liste de textes d'entité à **rejeter** (insensible à la casse).
+- `exclude_labels` : liste de labels d'entité à **rejeter** (ex. `MISC`).
+- `include` : liste d'entités à **forcer**.
+  - `text` : texte recherché dans le document.
+  - `label` : label assigné à l'entité ajoutée.
+
+## Expressions utilisées (important)
+Pour `include`, le script utilise une regex Python de la forme :
+
+- `\b<text>\b` avec `re.IGNORECASE`.
+
+Cela veut dire :
+- recherche **insensible à la casse** ;
+- correspondance sur des **bornes de mot** (`\b`) ;
+- évite de matcher au milieu d'un mot.
+
+Exemple : `"text": "Paris"` matche `Paris` mais pas `parisien`.

help/nettoyage.md

@@ -0,0 +1,48 @@
+# Audit des options de nettoyage (spaCy vs `lexique_fr`)
+
+Contexte analysé : pipeline Rainette (`R/server_events_lancer.R`, `nettoyage.R`, `R/pipeline_spacy_analysis.R`, `R/pipeline_lexique_analysis.R`, `R/nlp_spacy.R`, `rainette/spacy_preprocess.py`, `R/chd_afc_pipeline.R`, `R/nlp_language.R`).
+
+## Résumé rapide
+
+- Toutes les options UI sont bien **lues** par le pipeline.
+- Mais en mode **spaCy**, certaines options sont **redondantes** ou **sans effet réel** sur la sortie finale.
+- Ton log debug (`Diagnostic pipeline: ...`) est normal : il n'affiche qu'un sous-ensemble des options.
+
+## Vérification option par option
+
+| Option UI | `lexique_fr` | `spaCy` | Verdict |
+|---|---|---|---|
+| `nettoyage_caracteres` | Appliquée avant pipeline via `appliquer_nettoyage_et_minuscules()` | Appliquée avant pipeline via `appliquer_nettoyage_et_minuscules()` | ✅ OK des deux côtés |
+| `forcer_minuscules_avant` | Appliquée dans `appliquer_nettoyage_et_minuscules()` | Appliquée dans `appliquer_nettoyage_et_minuscules()` + passée à Python (`--lower_input`) | ⚠️ Redondante en spaCy |
+| `supprimer_chiffres` | Appliquée dans `appliquer_nettoyage_et_minuscules()` + `tokens(..., remove_numbers=TRUE/FALSE)` | Appliquée dans `appliquer_nettoyage_et_minuscules()` + spaCy Python (`--remove_numbers`) + `tokens(..., remove_numbers=...)` | ⚠️ Très redondante en spaCy |
+| `supprimer_apostrophes` | Appliquée dans `appliquer_nettoyage_et_minuscules()` | Appliquée dans `appliquer_nettoyage_et_minuscules()` + spaCy Python (`--strip_fr_elisions`) | ⚠️ Redondante en spaCy |
+| `supprimer_ponctuation` | Appliquée à la tokenisation quanteda (`tokens(remove_punct=...)`) | **Déjà supprimée** dans `rainette/spacy_preprocess.py` (`tok.is_punct` ignoré), puis retokenisation quanteda | ⚠️ En spaCy, case quasi sans effet |
+| `retirer_stopwords` | Oui (`obtenir_stopwords_analyse(..., source_dictionnaire='lexique_fr')` → quanteda FR) | Oui (`source_dictionnaire='spacy'` → stopwords spaCy) | ✅ OK des deux côtés |
+| `filtrage_morpho` | Oui via `filtrer_textes_lexique_par_cgram()` (`c_morpho`) | Oui via `--pos_keep` et filtrage POS dans Python | ✅ OK des deux côtés |
+
+## Point important pour ton test (`lexique_fr` + pas de case minuscules)
+
+Même si tu ne coches pas « Passage en minuscule », la chaîne de traitement fait ensuite un `tokens_tolower(...)` lors de la construction du DFM (avec ou sans stopwords). Donc la représentation finale utilisée pour l'analyse passe en minuscules dans tous les cas.
+
+➡️ En clair : pour l'analyse statistique, l'absence de coche « minuscules » n'empêche pas une normalisation en minuscules plus tard.
+
+## Pourquoi ton log debug ne montre pas tout
+
+La ligne :
+
+`Diagnostic pipeline: dictionnaire=... | langue UI=... | filtrage_morpho=... | retirer_stopwords=...`
+
+est volontairement courte et n'inclut pas `forcer_minuscules_avant`, `supprimer_ponctuation`, `supprimer_chiffres`, `supprimer_apostrophes`, `nettoyage_caracteres`.
+
+## Conclusion
+
+- ✅ **Oui**, les options principales sont prises en compte pour `lexique_fr` et spaCy.
+- ⚠️ **Non**, elles ne sont pas toutes discriminantes en spaCy (certaines sont doublées, et `supprimer_ponctuation` n'a presque pas d'effet car spaCy retire déjà la ponctuation en amont).
+- ⚠️ La case « Passage en minuscule » n'est pas un indicateur fiable du casing final du DFM, car le pipeline applique `tokens_tolower(...)` ensuite.
+
+## Recommandations (si tu veux un comportement plus lisible)
+
+1. Ajouter dans le log debug l'état de toutes les cases de nettoyage.
+2. En mode spaCy, clarifier dans l'UI que la ponctuation est déjà retirée côté Python.
+3. Décider d'un **seul** niveau pour la mise en minuscules (avant spaCy OU juste avant DFM), pour éviter les ambiguïtés de debug.
+4. Éviter les doubles suppressions chiffres/apostrophes (R + Python) sauf besoin explicite.

help/pos_spacy.md

@@ -0,0 +1,82 @@
+[//]: # (Rôle du fichier: pos_spacy.md documente une partie de l'application Rainette.)
+[//]: # (Ce document sert de référence fonctionnelle/technique pour l'équipe.)
+[//]: # (Il décrit le comportement attendu afin de sécuriser maintenance et diagnostics.)
+### Analyse morphosyntaxique avec spaCy et Lexique (fr)
+
+- Documentation principale spaCy : <https://spacy.io/usage>
+- Linguistic Features (POS, morphology) : <a href="https://spacy.io/usage/linguistic-feature/" target="_blank" rel="noopener noreferrer">Lexique POS spaCy</a>
+- Documentation OpenLexicon : <a href="https://openlexicon.fr/" target="_blank" rel="noopener noreferrer">OpenLexicon</a>
+
+### Traduction FR des POS (spaCy)
+
+- **ADJ** : adjectif
+- **ADP** : adposition (préposition)
+- **ADV** : adverbe
+- **AUX** : auxiliaire
+- **CCONJ** : conjonction de coordination
+- **DET** : déterminant
+- **INTJ** : interjection
+- **NOUN** : nom
+- **NUM** : numéral
+- **PART** : particule
+- **PRON** : pronom
+- **PROPN** : nom propre
+- **PUNCT** : ponctuation
+- **SCONJ** : conjonction de subordination
+- **SYM** : symbole
+- **VERB** : verbe
+- **X** : autre / catégorie inconnue
+
+### Filtrage morphosyntaxique spécifique lexique_fr
+
+Le dictionnaire **lexique_fr** utilisé ici est celui d’**IRaMuTeQ**, et il semble lui-même issu d’**OpenLexicon**.
+
+> Contrairement au logiciel IRaMuTeQ (où les niveaux sont généralement interprétés comme `1 = active` et `2 = supplémentaire`), le filtrage proposé ici est **binaire** et configurable de plusieurs façons.
+
+![Exemple : clés d'analyse logiciel IRaMuTeQ](cles_analyse_iramuteq.png)
+
+Deux configurations principales dans l'interface sont possibles :
+1. Si vous **ne cochez pas** le filtrage morphosyntaxique, **tout le corpus** est pris en compte.
+2. Si vous **filtrez** sur des catégories morphosyntaxiques (voir la liste ci-dessous), l’analyse porte sur le **corpus filtré** par les catégories sélectionnées.
+
+Noms des catégories de Lexique_fr
+
+- **NOM** : nom commun
+- **NOM_SUP** : nom
+- **VER** : verbe
+- **VER_SUP** : verbe
+- **AUX** : auxiliaire
+- **ADJ** : adjectif
+- **ADJ_SUP** : adjectif
+- **ADJ_DEM** : adjectif démonstratif
+- **ADJ_IND** : adjectif indéfini
+- **ADJ_INT** : adjectif interrogatif
+- **ADJ_NUM** : adjectif numéral
+- **ADJ_POS** : adjectif possessif
+- **ADV** : adverbe
+- **ADV_SUP** : adverbe
+- **PRE** : préposition
+- **CON** : conjonction
+- **ART_DEF** : article défini
+- **ART_IND** : article indéfini
+- **PRO_DEM** : pronom démonstratif
+- **PRO_IND** : pronom indéfini
+- **PRO_PER** : pronom personnel
+- **PRO_POS** : pronom possessif
+- **PRO_REL** : pronom relatif
+- **ONO** : onomatopée
+
+
+Flux technique (mode "Lexique_fr"):
+1. tokenisation locale (quanteda),
+2. filtrage des tokens par présence dans lexique_fr avec les catégories `c_morpho` sélectionnées,
+3. lemmatisation (si activée) directement via lexique_fr (forme -> lemme).
+
+> Le filtrage morphosyntaxique lexique_fr est donc indépendant de spaCy.
+
+### Activation de filtrage morphosyntaxique
+
+- de choisir la langue spaCy (`fr`, `en`, `es`, `it`, `de`) quand la source est **spaCy**,
+- de sélectionner les POS à conserver parmi la liste POS quand la source est **spaCy**,
+- de sélectionner directement les catégories `c_morpho` à conserver quand la source est **Lexique (fr)**,
+- de combiner ce filtrage avec la lemmatisation selon les besoins analytiques.

help/rapport_audit_iramuteq_like.md

@@ -0,0 +1,156 @@
+# Audit technique détaillé — pipeline IRaMuTeQ-like (tokenisation + découpage)
+
+## 1) Ce que fait exactement le pipeline actuel
+
+### 1.1 Entrée corpus et segmentation initiale
+- Le serveur lance d'abord l'import du corpus via `import_corpus_iramuteq(chemin_fichier)`, puis applique la segmentation via `split_segments(corpus, segment_size = input$segment_size)`.
+- Le nombre de segments affiché juste après cette étape est `ndoc(corpus)` après `split_segments`.
+- **Important**: les fonctions `import_corpus_iramuteq` et `split_segments` ne sont pas redéfinies dans ce dépôt (elles viennent d'une dépendance, typiquement `rainette`), donc leur comportement exact dépend de la version installée.
+
+### 1.2 Pré-nettoyage texte (avant tokenisation)
+- Le texte segmenté passe ensuite par `appliquer_nettoyage_et_minuscules(...)`.
+- Transformations possibles:
+  - normalisation espace insécable `\u00A0` -> espace,
+  - suppression des chiffres,
+  - suppression des préfixes d'élision FR (`c'`, `d'`, `l'`, `n'`, `t'`, `s'`, `j'`, `qu'`),
+  - suppression de caractères hors regex autorisée,
+  - normalisation des espaces,
+  - passage en minuscules.
+
+### 1.3 Tokenisation réellement utilisée
+
+#### Chemin Lexique FR
+- La tokenisation est faite avec `quanteda::tokens(...)` sur les textes prétraités.
+- Les options `remove_punct` et `remove_numbers` dépendent de l'UI.
+- Ensuite, stopwords optionnels puis `dfm` + `dfm_trim(min_docfreq=...)`.
+
+#### Chemin spaCy
+- Le script Python `rainette/spacy_preprocess.py` lit `doc_id,text`, puis pour chaque token spaCy:
+  - ignore espaces et ponctuation,
+  - optionnellement ignore nombres (`tok.like_num`),
+  - optionnellement retire préfixes d'élision FR,
+  - filtre POS (si demandé),
+  - prend surface ou lemme, en minuscules,
+  - recompose le document par `" ".join(tokens_sortie)`.
+- Ensuite côté R, **il y a une seconde tokenisation** quanteda sur ce texte reconstruit.
+
+### 1.4 CHD IRaMuTeQ-like
+- Quand `modele_chd == "iramuteq"`, le pipeline force `source_dictionnaire = "lexique_fr"`.
+- Les stats classes sont calculées via `construire_stats_classes_iramuteq(...)` (contingence présence/absence doc-terme), avec exclusion des classes 0.
+- Le moteur IRaMuTeQ-like (`lancer_moteur_chd_iramuteq`) s'appuie sur les scripts historiques `CHD.R`, `anacor.R`, `chdtxt.R`.
+
+---
+
+## 2) Où une divergence de nombre de segments peut apparaître
+
+## 2.1 Niveau segmentation primaire (le plus probable)
+1. **Version de dépendance différente** pour `split_segments`.
+2. **Normalisation des retours ligne** avant import non identique (`CRLF` vs `LF`) si la dépendance n'harmonise pas strictement.
+3. **Docnames invalides/dupliqués**: le pipeline renomme avec `make.unique`, ce qui peut modifier les correspondances ultérieures.
+
+## 2.2 Niveau filtrage post-segmentation
+Même si la segmentation est identique au départ, le nombre final peut diverger car:
+1. `dfm_trim(min_docfreq)` peut supprimer des termes et rendre certains documents vides.
+2. `supprimer_docs_vides_dfm(...)` retire explicitement les segments à somme nulle.
+3. En CHD, les segments non assignés (`classe 0/NA`) sont exclus des stats et de l'AFC.
+
+## 2.3 Niveau tokenisation
+1. **Différence quanteda vs spaCy**: la définition d'un token n'est pas identique.
+2. **Double tokenisation en chemin spaCy** (spaCy puis quanteda) -> pertes supplémentaires possibles.
+3. **Option élisions FR** activée à un endroit et pas l'autre (R nettoyage vs Python spaCy).
+4. **Suppression des chiffres** appliquée à deux niveaux possibles.
+
+---
+
+## 3) Fonctions IRaMuTeQ-like auditées et risques par fonction
+
+### 3.1 `preparer_entrees_chd_iramuteq(...)`
+- Fait: nettoyage + tokenisation quanteda + stopwords + DFM.
+- Risques:
+  - incohérence si ce prétraitement n'est pas exactement celui utilisé en pipeline principal,
+  - variation stopwords selon langue/source.
+
+### 3.2 `calculer_chd_iramuteq(...)`
+- Fait: conversion DFM -> matrice, binarisation optionnelle, appel `CHD(...)` historique.
+- Risques:
+  - DFM trop pauvre (<2 lignes/colonnes),
+  - effet de la binarisation sur la stabilité des classes.
+
+### 3.3 `reconstruire_classes_terminales_iramuteq(...)`
+- Fait: reconstruit classes terminales avec `find.terminales` + propagation descendants.
+- Risques:
+  - classes 0 (non assignées) nombreuses si `mincl` trop strict,
+  - conflit entre `nb_classes_cible` et terminales reconstruites.
+
+### 3.4 `construire_stats_classes_iramuteq(...)`
+- Fait: chi² signé doc-terme, exclut explicitement classes 0.
+- Risques:
+  - impression de "perte" de segments côté utilisateur (en réalité exclus post-classement).
+
+---
+
+## 4) Réponse précise à "comment est tokenisé ?"
+
+### En mode Lexique FR
+- `quanteda::tokens(textes_lexique, remove_punct=..., remove_numbers=...)`.
+- Les formes sont ensuite potentiellement abaissées en minuscules, stopwords retirés, puis DFM.
+
+### En mode spaCy
+1. spaCy segmente selon son tokenizer modèle langue.
+2. Filtrage optionnel POS + nombres + élisions.
+3. Lemme (ou surface) en minuscules.
+4. Reconstruction du texte par espaces.
+5. Nouvelle tokenisation quanteda pour DFM.
+
+**Conséquence**: le mode spaCy n'est pas équivalent byte-à-byte au mode lexique, même avec "mêmes paramètres UI".
+
+---
+
+## 5) Réponse précise à "comment est découpé le texte ?"
+
+1. Découpage en segments d'abord par `split_segments(corpus, segment_size=...)` (fonction externe).
+2. Ensuite, il existe un **découpage analytique secondaire**: les segments peuvent être retirés du jeu analysé si vidés par les filtres (`dfm_trim`, suppression docs vides, classes 0).
+
+Donc il faut distinguer:
+- **segments bruts après split**,
+- **segments conservés pour CHD**,
+- **segments classés (hors 0/NA)**.
+
+---
+
+## 6) Erreurs possibles (checklist de diagnostic)
+
+1. Version package `rainette` différente -> comportement `split_segments` différent.
+2. `segment_size` identique mais options de nettoyage non alignées.
+3. `supprimer_apostrophes` active d'un côté, inactive de l'autre.
+4. `supprimer_chiffres` active à la fois en nettoyage R et en spaCy.
+5. `remove_punct`/`remove_numbers` quanteda différents.
+6. `min_docfreq` trop élevé -> segments vidés.
+7. POS trop restrictif en spaCy -> segments vidés.
+8. Stopwords retirés puis fallback partiel.
+9. Docnames renommés (`make.unique`) perturbant certains alignements aval.
+10. Exclusion classes 0 interprétée comme erreur de découpage.
+
+---
+
+## 7) Recommandations immédiates (très concrètes)
+
+1. Logger séparément 3 compteurs à chaque run:
+   - `N_split = ndoc(corpus)` après `split_segments`,
+   - `N_non_vide = ndoc(dfm_obj)` après `supprimer_docs_vides_dfm`,
+   - `N_classes = ndoc(filtered_corpus_ok)` après exclusion classes 0/NA.
+2. Afficher ces 3 nombres dans l'UI, pas un seul "nombre de segments".
+3. Figer version `rainette` dans l'environnement pour reproductibilité.
+4. Pour audit comparatif, désactiver temporairement: POS filter, stopwords, `min_docfreq > 1`, suppression apostrophes/chiffres.
+
+---
+
+## 8) Conclusion opérationnelle
+
+Le script ne fait pas qu'un découpage unique. Il y a:
+1. une segmentation primaire (`split_segments`),
+2. un prétraitement/tokenisation,
+3. des filtrages qui peuvent éliminer des segments,
+4. une exclusion finale des segments non classés.
+
+Si vous observez un "nombre de segments" différent malgré corpus + segment_size identiques, l'écart provient très probablement de (a) version de `split_segments` ou (b) filtrages post-segmentation, et non du seul paramètre de segmentation UI.

help/rapport_dendrogramme_iramuteq.md

@@ -0,0 +1,22 @@
+# Rapport — construction du dendrogramme IRaMuTeQ-like
+
+## Constat
+Le dendrogramme pouvait afficher plus de classes que les classes finales réellement exploitées (ex: 16 affichées vs 6 classes finales).
+
+## Vérification de `iramuteq_clone_v3`
+Dans `iramuteq_clone_v3/tabchddist.py`, la découpe de l'arbre est pilotée explicitement par le nombre de classes cible (`clnb`) via :
+
+- `classes<-as.data.frame(cutree(as.hclust(chd), k=clnb))[,1]`
+
+Cette logique borne donc l'affichage/les statistiques à un nombre de classes final choisi.
+
+## Correctif appliqué
+Dans `tracer_dendrogramme_chd_iramuteq` :
+
+1. Source de vérité prioritaire = classes présentes dans `res_stats_df$Classe` (résultat final affiché côté UI).
+2. Sinon repli sur `classes` documentaires.
+3. Projection sur `terminales` par index de classe (classe `i` -> `terminales[i]`) avec filtrage des indices invalides.
+4. Pas de repli "toutes les feuilles" tant qu'une liste de classes finales utiles existe.
+
+## Effet attendu
+Le dendrogramme affiche uniquement les classes finales réellement présentes dans les résultats CHD (et donc alignées avec l'analyse affichée).

help/rapport_mapping_chd_iramuteq_like.md

@@ -0,0 +1,112 @@
+# Rapport de mapping IRaMuTeQ-like (CHD)
+
+## 1) État de la branche demandée
+
+- La branche Git locale `iramuteq-like` n'existe pas dans ce dépôt au moment de l'audit (`git branch -a` ne retourne que `work`).
+- L'analyse a donc été réalisée sur le **module fonctionnel `iramuteq-like/`** présent dans la branche courante.
+
+## 2) Mapping bout-en-bout: du concordancier au dendrogramme, à l'AFC (nuage de points) et à l'UI
+
+### 2.1 Concordancier
+
+- **Calcul des termes par classe**: `iramuteq-like/concordancier-iramuteq.R`
+  - `.generer_concordancier_iramuteq_termes()`:
+    - filtre par classe,
+    - filtre p-value (`p` / `p_value`) selon `max_p`,
+    - conserve chi2 positifs,
+    - trie par chi2 décroissant.
+- **Génération HTML**: `generer_concordancier_iramuteq_html()`:
+  - prend `segments_by_class`, `res_stats_df`, `textes_indexation`,
+  - applique fallback top chi2 si aucun terme filtré,
+  - détecte segments contenant les termes,
+  - surligne et écrit le HTML final.
+
+### 2.2 Calcul CHD IRaMuTeQ-like
+
+- **Moteur CHD**: `iramuteq-like/chd_iramuteq.R`
+  - `calculer_chd_iramuteq()`:
+    - charge scripts historiques (`anacor.R`, `CHD.R`, `chdtxt.R`),
+    - binarise la matrice documentaire,
+    - lance `CHD(...)`.
+  - `reconstruire_classes_terminales_iramuteq()`:
+    - reconstruit classes documentaires finales depuis `n1`, `list_mere`, `list_fille`,
+    - applique logique `mincl` auto/manuel,
+    - mappe docs vers classes terminales.
+  - `construire_stats_classes_iramuteq()`:
+    - calcule stats par classe/terme,
+    - chi2 signé et p-value (présence/absence doc),
+    - structure compatible avec le concordancier et les sorties UI.
+
+### 2.3 Dendrogramme CHD
+
+- **Entrée UI du dendrogramme**: `iramuteq-like/dendogramme_iramuteq.R`
+  - `tracer_dendogramme_iramuteq_ui()` récupère l'objet CHD (`rv$res$chd`, `rv$res_chd`, fallback) et appelle le traceur principal.
+- **Traceur principal**: `iramuteq-like/chd_iramuteq.R`
+  - `tracer_dendrogramme_chd_iramuteq()`:
+    - reconstruit la topologie depuis `list_fille`,
+    - identifie racine/feuilles terminales,
+    - calcule layout arborescent,
+    - annote classes + pourcentages + termes top chi2,
+    - gère orientation `vertical` / `horizontal`.
+
+### 2.4 Nuage de points (AFC classes × termes / variables)
+
+- **Calcul AFC**: `iramuteq-like/afc_iramuteq.R`
+  - `calculer_afc_classes_termes()` construit la table classes × termes,
+  - `executer_afc_classes_termes()` exécute l'AFC,
+  - `tracer_afc_classes_seules()` affiche classes,
+  - `tracer_afc_classes_termes()` affiche classes + termes.
+- **AFC variables étoilées**: même fichier
+  - `calculer_afc_classes_variables()`, `executer_afc_classes_variables()`, `tracer_afc_classes_variables()`.
+
+### 2.5 Nuage de mots par classe
+
+- **Génération assets PNG**: `iramuteq-like/wordcloud_iramuteq.R`
+- **Exposition UI (iframe/img)**: `iramuteq-like/server_events_lancer_iramuteq.R` via `output$ui_wordcloud_iramuteq`.
+
+### 2.6 Orchestration serveur (pipeline)
+
+- **Pipeline principal au clic Lancer**: `iramuteq-like/server_events_lancer_iramuteq.R`
+  - préparation corpus,
+  - exécution CHD,
+  - calcul stats,
+  - calcul AFC,
+  - génération wordclouds,
+  - génération concordancier HTML,
+  - alimentation de `rv$*` pour l'UI.
+
+### 2.7 Couches UI
+
+- **Panneau résultats IRaMuTeQ-like**: `iramuteq-like/affichage_iramuteq-like.R`
+  - sous-onglets Dendrogramme / Stats CHD / Concordancier / Nuage de mots.
+- **Rendu serveur principal Shiny**: `app.R`
+  - `output$plot_chd_iramuteq_dendro`,
+  - `output$ui_tables_stats_chd_iramuteq`,
+  - `output$plot_afc_classes`, `output$plot_afc`, `output$plot_afc_vars`,
+  - intègre `register_events_lancer(...)`.
+
+## 3) Changement réalisé: méthode d'affichage du dendrogramme
+
+### 3.1 Objectif
+
+Réduire la surcharge visuelle quand les annotations de termes par classe se chevauchent.
+
+### 3.2 Implémentation
+
+- **Nouvelle option UI** dans l'onglet Dendrogramme:
+  - `Méthode d'affichage`
+  - `standard` (comportement historique: termes près des classes)
+  - `compact` (nouveau défaut: termes regroupés en légende).
+- **Propagation des paramètres**:
+  - `app.R` transmet `input$iramuteq_dendro_display_method` au traceur.
+  - `tracer_dendogramme_iramuteq_ui()` accepte `display_method` et le passe à `tracer_dendrogramme_chd_iramuteq()`.
+- **Rendu compact dans le traceur**:
+  - en `vertical`: légende textuelle regroupée en bas (`mtext`).
+  - en `horizontal`: légende compacte en bas à droite (`legend`).
+  - titres ajustés pour expliciter le mode `compact`.
+
+### 3.3 Impact
+
+- Pas de changement du calcul CHD ni des classes.
+- Changement purement visuel du dendrogramme côté affichage.
+- Le mode `standard` reste disponible.

help/rapport_tokenisation_iramuteq_clone_v3.md

@@ -0,0 +1,148 @@
+# Rapport ciblé — chaîne de tokenisation `iramuteq_clone_v3` et pipeline `iramuteq-like`
+
+## Contexte
+
+Ce rapport répond à deux points :
+1. Auditer **la chaîne de tokenisation** du dossier `iramuteq_clone_v3`.
+2. Vérifier, côté application actuelle, le mode **`iramuteq-like`** (qui force `lexique_fr`) sans analyse spaCy.
+
+---
+
+## 1) Résultat principal sur `iramuteq_clone_v3`
+
+### 1.1 Limite structurelle du dépôt cloné
+
+Dans ce dépôt, le cœur de préparation du corpus texte (module `corpus`) est référencé mais **n'est pas présent** dans l'arborescence locale fournie.
+
+- `iramuteq.py` importe `from corpus import Builder, SubBuilder, MergeClusters`. Cela indique que la chaîne de tokenisation principale est attendue dans `corpus.py`/module `corpus`.【F:iramuteq_clone_v3/iramuteq.py†L43-L44】
+- `textcheckcorpus.py` importe aussi `Corpus` depuis `corpus`, confirmant la dépendance centrale à ce module absent localement.【F:iramuteq_clone_v3/textcheckcorpus.py†L16-L17】
+
+👉 Conséquence : on peut auditer les options visibles en amont/aval, mais **pas reconstruire à 100% la tokenisation interne historique** sans ce module.
+
+### 1.2 Ce qui est explicitement vérifiable dans `iramuteq_clone_v3`
+
+#### a) Contrôle du format corpus (pas de tokenisation lexicale ici)
+`textcheckcorpus.py` vérifie surtout la syntaxe des lignes/étoiles (`****`, variables `*`, thématiques `-*`, espaces interdits, etc.), mais pas un découpage lexical type tokenizer moderne.【F:iramuteq_clone_v3/textcheckcorpus.py†L19-L39】
+
+#### b) Options de CHD (aval de la tokenisation)
+`textreinert.py` expose des paramètres de classification (pas la tokenisation elle-même), notamment :
+- `classif_mode` (simple/double/uci),
+- `tailleuc1`, `tailleuc2` (taille des unités de contexte),
+- `mincl`, `minforme`,
+- `nbcl_p1`,
+- `max_actives`,
+- `svdmethod`,
+- `mode.patate`.【F:iramuteq_clone_v3/textreinert.py†L70-L81】
+
+Il génère ensuite des matrices clairsemées à partir des UC/UCE/UCI via des méthodes de `corpus` (`make_and_write_sparse_matrix_from_uc`, `..._from_uces`, `..._from_uci`).【F:iramuteq_clone_v3/textreinert.py†L33-L41】
+
+#### c) Règle mincl auto côté scripts R historiques
+Dans `Rscripts/chdtxt.R`, si `mincl == 0`, la formule automatique est :
+- `ind = nbcl * 2` en mode double, sinon `ind = nbcl` ;
+- `mincl = round(nrow(classeuce1)/ind)`.【F:iramuteq_clone_v3/Rscripts/chdtxt.R†L278-L281】
+
+---
+
+## 2) Pipeline **réel** utilisé par ton application `iramuteq-like` (sans spaCy)
+
+Tu as raison : en mode `iramuteq-like`, la source est forcée sur `lexique_fr`.
+
+### 2.1 Forçage `lexique_fr`
+Dans `server_events_lancer.R`, si `modele_chd == "iramuteq"`, la source dictionnaire est forcée à `lexique_fr` avec log explicite.【F:R/server_events_lancer.R†L314-L317】
+
+### 2.2 Chaîne de prétraitement effectivement appliquée
+Avant tokenisation, la pipeline applique :
+- nettoyage caractères,
+- minuscules (option),
+- suppression chiffres (option),
+- suppression apostrophes/élisions (option).【F:R/server_events_lancer.R†L295-L301】
+
+Ensuite, en branche `lexique_fr`, la pipeline passe par `executer_pipeline_lexique(...)`.【F:R/server_events_lancer.R†L342-L347】
+
+### 2.3 Tokenisation et options actives en branche `lexique_fr`
+Dans `executer_pipeline_lexique` :
+- tokenisation `quanteda::tokens(...)` sur `textes_lexique`,
+- options actives : `remove_punct = input$supprimer_ponctuation`, `remove_numbers = input$supprimer_chiffres`.
+- puis construction DFM avec logique stopwords/min_docfreq via `construire_dfm_avec_fallback_stopwords(...)`.【F:R/pipeline_lexique_analysis.R†L67-L82】
+
+### 2.4 Option de normalisation en minuscules au niveau DFM
+La fonction `construire_dfm_avec_fallback_stopwords(...)` applique `tokens_tolower(...)` (avec ou sans retrait stopwords), donc la représentation finale est normalisée en minuscules côté DFM.【F:R/chd_afc_pipeline.R†L63-L70】
+
+### 2.5 Option de préparation spécifique `iramuteq-like`
+Le module `iramuteq-like/chd_iramuteq.R` normalise explicitement les options de nettoyage suivantes :
+- `nettoyage_caracteres`,
+- `forcer_minuscules_avant`,
+- `supprimer_chiffres`,
+- `supprimer_apostrophes`,
+- `supprimer_ponctuation`,
+- `retirer_stopwords`.
+Puis tokenise avec `quanteda::tokens(remove_punct, remove_numbers)` et option stopwords quanteda selon langue.【F:iramuteq-like/chd_iramuteq.R†L26-L33】【F:iramuteq-like/chd_iramuteq.R†L80-L89】
+
+---
+
+## 3) Rapport des options actives (mode `iramuteq-like`)
+
+### 3.1 Options effectivement actives dans ta chaîne (et où)
+
+- `nettoyage_caracteres` : actif avant tokenisation via `appliquer_nettoyage_et_minuscules(...)`.【F:R/server_events_lancer.R†L295-L299】
+- `forcer_minuscules_avant` : actif avant tokenisation via `appliquer_nettoyage_et_minuscules(...)`.【F:R/server_events_lancer.R†L298-L299】
+- `supprimer_chiffres` : actif avant tokenisation + actif dans `tokens(remove_numbers=...)`.【F:R/server_events_lancer.R†L299-L300】【F:R/pipeline_lexique_analysis.R†L69-L71】
+- `supprimer_apostrophes` : actif avant tokenisation via nettoyage texte.【F:R/server_events_lancer.R†L300-L301】
+- `supprimer_ponctuation` : actif dans `tokens(remove_punct=...)` en branche `lexique_fr`.【F:R/pipeline_lexique_analysis.R†L69-L70】
+- `retirer_stopwords` : actif dans `construire_dfm_avec_fallback_stopwords(...)` (avec fallback si DFM trop pauvre).【F:R/chd_afc_pipeline.R†L55-L66】【F:R/chd_afc_pipeline.R†L87-L93】
+- `min_docfreq` : actif au `dfm_trim(min_docfreq=...)`.【F:R/chd_afc_pipeline.R†L77-L77】
+- `filtrage_morpho` + `lexique_utiliser_lemmes` : actifs en branche lexique via filtrage cgram/lemmatisation forme→lemme si demandé.【F:R/pipeline_lexique_analysis.R†L31-L36】【F:R/pipeline_lexique_analysis.R†L48-L61】
+
+### 3.2 Options non pertinentes pour ce mode
+- Les options spaCy ne sont pas utilisées quand `modele_chd="iramuteq"` puisque la source est forcée `lexique_fr`.【F:R/server_events_lancer.R†L314-L317】
+
+---
+
+## 4) Pourquoi l'écart de formes peut persister malgré “même paramétrage”
+
+Même en excluant spaCy, un écart peut persister entre IRaMuTeQ desktop et ton app si la tokenisation historique interne d'IRaMuTeQ (module `corpus` absent ici) diffère de ta chaîne `quanteda + lexique_fr + trim`.
+
+En pratique, les points sensibles sont :
+- règles de segmentation des unités de contexte (UC/UCE/UCI) et calcul d'actives/supplémentaires dans `corpus` historique (non auditable dans ce clone incomplet),
+- ordre exact nettoyage → lemmatisation → tokenisation,
+- traitement des élisions/apostrophes,
+- seuil `min_docfreq`, suppression stopwords, fallback, et suppression segments vides avant CHD.
+
+---
+
+## 5) Recommandation opérationnelle
+
+Pour une comparaison “iso-IRaMuTeQ” stricte, je recommande un mode audit en 2 passes :
+
+1. **Pass A (référence max proche IRaMuTeQ)**
+   - `retirer_stopwords = FALSE`
+   - `min_docfreq = 1`
+   - pas de filtrage morpho
+   - pas de suppression apostrophes/chiffres supplémentaire
+
+2. **Pass B (tes réglages actuels)**
+   - comparer : nb tokens bruts, nb formes DFM, nb hapax, nb segments non vides.
+
+Et ajouter un export intermédiaire (tokens par segment) pour expliquer où apparaissent les +194 formes.
+
+
+---
+
+## 6) Corrections concrètes recommandées pour rapprocher les scores
+
+1. **Figer une prépa corpus unique avant `quanteda::tokens`**
+   - Utiliser `iramuteq-like/textprepa_iramuteq.py` pour générer un texte préparé stable et auditable (mêmes règles à chaque run), puis tokeniser ce texte côté R.
+
+2. **Éviter les doubles effets de nettoyage**
+   - Si `iramuteq-like/textprepa_iramuteq.py` est activé, neutraliser le nettoyage redondant en amont pour ne pas supprimer deux fois chiffres/élisions.
+
+3. **Comparer les formes à 3 niveaux**
+   - Niveau A: formes post-prépa (sortie `output_tokens` de `iramuteq-like/textprepa_iramuteq.py`),
+   - Niveau B: formes post-`quanteda::tokens`,
+   - Niveau C: formes post-`dfm_trim`.
+
+4. **Conserver un mode “audit IRaMuTeQ”**
+   - `min_docfreq=1`, `retirer_stopwords=FALSE`, pas de filtrage morpho, pour isoler l'écart de tokenisation.
+
+5. **Comparer sur un sous-corpus fixe**
+   - Exporter 50–100 segments identiques entre IRaMuTeQ desktop et app, comparer les listes de formes exactes segment par segment.

iramuteq-like/CHD.R

@@ -0,0 +1,407 @@
+#Author: Pierre Ratinaud
+#Copyright (c) 2008-2020 Pierre Ratinaud
+#License: GNU/GPL
+
+pp<-function(txt,val) {
+	d<-paste(txt,' : ')
+	print(paste(d,val))
+}
+MyChiSq<-function(x,sc,n){
+	sr<-rowSums(x)
+	E <- outer(sr, sc, "*")/n
+	STAT<-sum(((x - E)^2)/E)
+	STAT
+}
+
+MySpeedChi <- function(x,sc) {
+    sr <-rowSums(x)
+    E <- outer(sr, sc, "*")
+	STAT<-sum((x - E)^2/E)
+	STAT
+}
+
+find.max <- function(dtable, chitable, compte, rmax, maxinter, sc, TT) {
+    ln <- which(dtable==1, arr.ind=TRUE)
+    lo <- list()
+    lo[1:nrow(dtable)] <- 0
+    for (k in 1:nrow(ln)) {lo[[ln[k,1]]]<-append(lo[[ln[k,1]]],ln[k,2])}
+    for (k in 1:nrow(dtable)) {lo[[k]] <- lo[[k]][-1]}
+	## lo<-lo[-c(1,length(lo))]
+	## for (l in lo) {
+	##     compte <- compte + 1 
+	##     chitable[1,l]<-chitable[1,l]+1
+	##     chitable[2,l]<-chitable[2,l]-1
+	##     chi<-MyChiSq(chitable,sc,TT)
+		## if (chi>maxinter) {
+		##     maxinter<-chi
+		##     rmax<-compte
+		## }   
+    #}
+	lo<-lo[-c(1)]
+	for (l in lo) {
+		chi<-MyChiSq(chitable,sc,TT)
+		if (chi>maxinter) {
+			maxinter<-chi
+			rmax<-compte
+		}
+		compte <- compte + 1
+		chitable[1,l]<-chitable[1,l]+1
+		chitable[2,l]<-chitable[2,l]-1
+	}	
+    res <- list(maxinter=maxinter, rmax=rmax)
+    res
+}  
+
+
+
+
+
+CHD<-function(data.in, x=9, mode.patate = FALSE, svd.method, libsvdc.path=NULL){
+#	sink('/home/pierre/workspace/iramuteq/dev/findchi2.txt')
+	dataori <- data.in
+    row.names(dataori) <- rownames(data.in)
+	dtable <- data.in
+	colnames(dtable) <- 1:ncol(dtable)
+    dout <- NULL
+	rowelim<-NULL
+	pp('ncol entree : ',ncol(dtable))
+	pp('nrow entree',nrow(dtable))
+	listcol <- list()
+	listmere <- list()
+	list_fille <- list()
+	print('vire colonnes vides en entree')#FIXME : il ne doit pas y avoir de colonnes vides en entree !!
+	sdt<-colSums(dtable)
+	if (min(sdt)==0)
+		dtable<-dtable[,-which(sdt==0)]
+    print('vire lignes vides en entree')
+    sdt<-rowSums(dtable)
+	if (min(sdt)==0) {
+        rowelim<-as.integer(rownames(dtable)[which(sdt==0)])
+        print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&')
+        print(rowelim)
+        print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&')
+		dtable<-dtable[-which(sdt==0),]
+	}
+	mere<-1
+	for (i in 1:x) {
+		clnb<-(i*2)
+		listmere[[clnb]]<-mere
+		listmere[[clnb+1]]<-mere
+		list_fille[[mere]] <- c(clnb,clnb+1)
+		listcol[[clnb]]<-vector()
+		listcol[[clnb+1]]<-vector()
+		#extraction du premier facteur de l'afc
+		print('afc')
+		pp('taille dtable dans boucle (col/row)',c(ncol(dtable),nrow(dtable)))
+		afc<-boostana(dtable, nd=1, svd.method = svd.method, libsvdc.path=libsvdc.path)
+		pp('SV',afc$singular.values)
+		pp('V.P.', afc$eigen.values)
+		coordrow <- as.matrix(afc$row.scores[,1])
+		coordrowori<-coordrow
+		row.names(coordrow)<-rownames(dtable)
+        coordrow <- cbind(coordrow,1:nrow(dtable))
+		print('deb recherche meilleur partition')
+        ordert <- as.matrix(coordrow[order(coordrow[,1]),])
+        ordert <- cbind(ordert, 1:nrow(ordert))
+        ordert <- ordert[order(ordert[,2]),]
+
+		listinter<-vector()
+		listlim<-vector()
+        dtable <- dtable[order(ordert[,3]),]
+        sc <- colSums(dtable)
+        TT <- sum(sc)
+        sc1 <- dtable[1,]
+        sc2 <- colSums(dtable) - sc1 
+        chitable <- rbind(sc1, sc2)
+        compte <- 1
+        maxinter <- 0
+        rmax <- NULL
+
+        inert <- find.max(dtable, chitable, compte, rmax, maxinter, sc, TT)
+        print('@@@@@@@@@@@@@@@@@@@@@@@@@@@@')
+		pp('max inter phase 1', inert$maxinter/TT)#max(listinter))
+		print('@@@@@@@@@@@@@@@@@@@@@@@@@@@@')
+        ordert <- ordert[order(ordert[,3]),]
+		listclasse<-ifelse(coordrowori<=ordert[(inert$rmax),1],clnb,clnb+1)
+	    dtable <- dtable[order(ordert[,2]),]
+		cl<-listclasse
+		pp('TT',TT)
+		#dtable<-cbind(dtable,'cl'= as.vector(cl))
+
+		N1<-length(listclasse[listclasse==clnb])
+		N2<-length(listclasse[listclasse==clnb+1])
+		pp('N1',N1)
+		pp('N2',N2)
+###################################################################
+#                  reclassement des individus                     #
+###################################################################
+        if (!mode.patate) {
+    		malcl<-1000000000000
+    		it<-0
+    		listsub<-list()
+    		#in boucle
+            ln <- which(dtable==1, arr.ind=TRUE)
+            lnz <- list()
+            lnz[1:nrow(dtable)] <- 0
+    
+            for (k in 1:nrow(ln)) {lnz[[ln[k,1]]]<-append(lnz[[ln[k,1]]],ln[k,2])}
+            for (k in 1:nrow(dtable)) {lnz[[k]] <- lnz[[k]][-1]}
+    		TT<-sum(dtable)
+    
+    		while (malcl!=0 & N1>=5 & N2>=5) {
+    			it<-it+1
+    			listsub[[it]]<-vector()
+                txt <- paste('nombre iteration', it)
+    			#pp('nombre iteration',it)
+    			vdelta<-vector()
+    			#dtable[,'cl']<-cl
+    			t1<-dtable[which(cl[,1]==clnb),]#[,-ncol(dtable)]
+    			t2<-dtable[which(cl[,1]==clnb+1),]#[,-ncol(dtable)]
+    			ncolt<-ncol(t1)
+    			#pp('ncolt',ncolt)
+    
+                if (N1 != 1) {
+                    sc1<-colSums(t1)
+                } else {
+                    sc1 <- t1
+                }
+                if (N2 != 1) {
+    			    sc2<-colSums(t2)
+                } else {
+                    sc2 <- t2
+                }
+    			
+                sc<-sc1+sc2
+    			chtableori<-rbind(sc1,sc2)
+    			chtable<-chtableori
+    			interori<-MyChiSq(chtableori,sc,TT)/TT#chisq.test(chtableori)$statistic#/TT
+    			txt <- paste(txt, ' - interori : ',interori)
+                #pp('interori',interori)
+    
+    			N1<-nrow(t1)
+    			N2<-nrow(t2)
+    
+    			#pp('N1',N1)
+    			#pp('N2',N2)
+    			txt <- paste(txt, 'N1:', N1,'-N2:',N2)
+                print(txt)
+                compte <- 0
+    			for (l in lnz){
+                        chi.in<-chtable
+                        compte <- compte + 1
+    					if(cl[compte]==clnb){
+    						chtable[1,l]<-chtable[1,l]-1
+    						chtable[2,l]<-chtable[2,l]+1
+    					}else{
+    						chtable[1,l]<-chtable[1,l]+1
+    						chtable[2,l]<-chtable[2,l]-1
+    					}
+    					interswitch<-MyChiSq(chtable,sc,TT)/TT#chisq.test(chtable)$statistic/TT
+    					ws<-interori-interswitch
+    
+    					if (ws<0){
+    						interori<-interswitch
+    						if(cl[compte]==clnb){
+    							#sc1<-chtable[1,]
+    							#sc2<-chtable[2,]
+    							cl[compte]<-clnb+1
+    							listsub[[it]]<-append(listsub[[it]],compte)
+    						} else {
+    							#sc1<-chtable[1,]
+    							#sc2<-chtable[2,]
+    							cl[compte]<-clnb
+    							listsub[[it]]<-append(listsub[[it]],compte)
+    						}
+    						vdelta<-append(vdelta,compte)
+                        } else {
+                            chtable<-chi.in
+    					}
+                   }
+    #			for (val in vdelta) {
+    #				if (cl[val]==clnb) {
+    #					cl[val]<-clnb+1
+    #					listsub[[it]]<-append(listsub[[it]],val)
+    #					}else {
+    #					cl[val]<-clnb
+    #					listsub[[it]]<-append(listsub[[it]],val)
+    #				}
+    #			}
+    			print('###################################')
+    			print('longueur < 0')
+    			malcl<-length(vdelta)
+
+    			if ((it>1)&&(!is.logical(listsub[[it]]))&&(!is.logical(listsub[[it-1]]))){
+    				if (all(listsub[[it]]==listsub[[(it-1)]])){
+    					malcl<-0
+    				}
+    			}
+    			print(malcl)
+    			print('###################################')
+    		}
+        }
+		#dtable<-cbind(dtable,'cl'=as.vector(cl))
+        #dtable[,'cl'] <-as.vector(cl)
+#######################################################################
+#                 Fin reclassement des individus                      #
+#######################################################################
+#		if (!(length(cl[cl==clnb])==1 || length(cl[cl==clnb+1])==1)) {
+			#t1<-dtable[dtable[,'cl']==clnb,][,-ncol(dtable)]
+			#t2<-dtable[dtable[,'cl']==clnb+1,][,-ncol(dtable)]
+		    t1<-dtable[which(cl[,1]==clnb),]#[,-ncol(dtable)]
+			t2<-dtable[which(cl[,1]==clnb+1),]#[,-ncol(dtable)]
+            if (inherits(t1, "numeric")) {
+                sc1 <- as.vector(t1)
+                nrowt1 <- 1
+            } else {
+                sc1 <- colSums(t1)
+                nrowt1 <- nrow(t1)
+            }
+            if  (inherits(t2, "numeric")) {
+                sc2 <- as.vector(t2)
+                nrowt2 <- 1
+            } else {
+                sc2 <- colSums(t2)
+                nrowt2 <- nrow(t2)
+            }
+            chtable<-rbind(sc1,sc2)
+			inter<-chisq.test(chtable)$statistic/TT
+			pp('last inter',inter)
+			print('=====================')
+			#calcul de la specificite des colonnes
+			mint<-min(nrowt1,nrowt2)
+			maxt<-max(nrowt1,nrowt2)
+			seuil<-round((1.9*(maxt/mint))+1.9,digit=6)
+			#sink('/home/pierre/workspace/iramuteq/dev/findchi2.txt')
+#			print('ATTENTION SEUIL 3,84')
+#			seuil<-3.84
+			pp('seuil',seuil)
+			sominf<-0
+			nv<-0
+			nz<-0
+			ncclnb<-0
+			ncclnbp<-0
+            NN1<-0
+            NN2<-0
+            maxchip<-0
+            nbzeroun<-0
+            res1<-0
+            res2<-0
+            nbseuil<-0
+            nbexe<-0
+            nbcontrib<-0
+			cn<-colnames(dtable)
+            #another try#########################################
+            one <- cbind(sc1,sc2)
+            cols <- c(length(which(cl==clnb)), length(which(cl==clnb+1))) 
+            print(cols)
+            colss <- matrix(rep(cols,ncol(dtable)), ncol=2, byrow=TRUE)
+            zero <- colss - one
+            rows <- cbind(rowSums(zero), rowSums(one))
+            n <- sum(cols)
+            for (m in 1:nrow(rows)) {
+                obs <- t(matrix(c(zero[m,],one[m,]),2,2))
+                E <- outer(rows[m,],cols,'*')/n
+                if ((min(obs[2,])==0) & (min(obs[1,])!=0)) {
+                    chi <- seuil + 1
+                } else if ((min(obs[1,])==0) & (min(obs[2,])!=0)) {
+                    chi <- seuil - 1
+                } else if (any(obs < 10)) {
+                    chi <- sum((abs(obs - E) - 0.5)^2 / E)
+                } else {
+                    chi <- sum(((obs - E)^2)/E)
+                }
+                if (is.na(chi)) {
+                    chi <- 0
+                }
+                if (chi > seuil) {
+                    if (obs[2,1] < E[2,1]) {
+                        listcol[[clnb]]<-append(listcol[[clnb]],cn[m])
+                        ncclnb<-ncclnb+1
+                    } else if (obs[2,2] < E[2,2]) {
+						listcol[[clnb+1]]<-append(listcol[[clnb+1]],cn[m])
+						ncclnbp<-ncclnbp+1
+                    }
+                }
+            }
+            ######################################################
+			print('resultats elim item')
+			pp(clnb+1,length(listcol[[clnb+1]]))
+			pp(clnb,length(listcol[[clnb]]))
+			pp('ncclnb',ncclnb)
+			pp('ncclnbp',ncclnbp)
+			listrownamedtable<-rownames(dtable)
+			listrownamedtable<-as.integer(listrownamedtable)
+			newcol<-vector(length=nrow(dataori))
+			#remplissage de la nouvelle colonne avec les nouvelles classes
+			print('remplissage')
+#			num<-0
+            newcol[listrownamedtable] <- cl[,1]
+			#recuperation de la classe precedante pour les cases vides
+			print('recuperation classes precedentes')
+            if (i!=1) {
+                newcol[which(newcol==0)] <- dout[,ncol(dout)][which(newcol==0)]
+            }
+            if(!is.null(rowelim)) {
+                newcol[rowelim] <- 0
+            }
+			tailleclasse<-as.matrix(summary(as.factor(as.character(newcol))))
+			print('tailleclasse')
+			print(tailleclasse)
+			tailleclasse<-as.matrix(tailleclasse[!(rownames(tailleclasse)==0),])
+			plusgrand<-which.max(tailleclasse)
+			#???????????????????????????????????
+			#Si 2 classes ont des effectifs egaux, on prend la premiere de la liste...
+			if (length(plusgrand)>1) {
+				plusgrand<-plusgrand[1]
+			}
+			#????????????????????????????????????
+			
+			#constuction du prochain tableau a analyser
+			print('construction tableau suivant')
+            dout<-cbind(dout,newcol)
+			classe<-as.integer(rownames(tailleclasse)[plusgrand])
+			dtable<-dataori[which(newcol==classe),]
+			row.names(dtable)<-rownames(dataori)[which(newcol==classe)]
+            colnames(dtable) <- 1:ncol(dtable)
+			mere<-classe
+			listcolelim<-listcol[[as.integer(classe)]]
+			mother<-listmere[[as.integer(classe)]]
+			while (mother!=1) {
+				listcolelim<-append(listcolelim,listcol[[mother]])
+				mother<-listmere[[mother]]
+			}
+			
+			listcolelim<-sort(unique(listcolelim))
+			pp('avant',ncol(dtable))
+			if (!is.logical(listcolelim)){
+				print('elimination colonne')
+				#dtable<-dtable[,-listcolelim]
+                dtable<-dtable[,!(colnames(dtable) %in% listcolelim)]
+			}
+			pp('apres',ncol(dtable))
+			#elimination des colonnes ne contenant que des 0
+			print('vire colonne inf 3 dans boucle')
+			sdt<-colSums(dtable)
+			if (min(sdt)<=3)
+				dtable<-dtable[,-which(sdt<=3)]
+	
+			#elimination des lignes ne contenant que des 0
+			print('vire ligne vide dans boucle')
+			if (ncol(dtable)==1) {
+				sdt<-dtable[,1]
+			} else {
+				sdt<-rowSums(dtable)
+			}
+			if (min(sdt)==0) {
+				rowelim<-as.integer(rownames(dtable)[which(sdt==0)])
+				print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&')
+				print(rowelim)
+				print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&')
+				dtable<-dtable[-which(sdt==0),]
+			}
+#		}
+	}
+#	sink()
+	res <- list(n1 = dout, list_mere = listmere, list_fille = list_fille)
+	res
+}

iramuteq-like/afc_helpers_iramuteq.R

@@ -0,0 +1,39 @@
+# Rôle du fichier: afc_helpers.R porte une partie du pipeline d'analyse Rainette.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+# Il facilite la maintenance en explicitant le périmètre et les points d'intégration.
+# Module AFC - helpers de contextualisation des termes
+# Ce fichier regroupe des utilitaires AFC, notamment la construction de segments
+# exemples associés aux termes caractéristiques de classes.
+
+construire_segments_exemples_afc <- function(termes_stats, dfm_obj, corpus_obj, max_chars = 220) {
+  if (is.null(termes_stats) || nrow(termes_stats) == 0 || is.null(dfm_obj) || is.null(corpus_obj)) return(termes_stats)
+  if (!all(c("Terme", "Classe_max") %in% names(termes_stats))) return(termes_stats)
+
+  classes_docs <- normaliser_classes(docvars(corpus_obj)$Classes)
+  textes <- as.character(corpus_obj)
+
+  if (length(classes_docs) != ndoc(dfm_obj) || length(textes) != ndoc(dfm_obj)) return(termes_stats)
+
+  mat <- as.matrix(dfm_obj)
+  termes_stats$Segment_texte <- NA_character_
+
+  for (i in seq_len(nrow(termes_stats))) {
+    terme <- as.character(termes_stats$Terme[i])
+    classe_num <- suppressWarnings(as.numeric(gsub("^Classe\\s+", "", as.character(termes_stats$Classe_max[i]))))
+
+    if (is.na(classe_num) || !nzchar(terme) || !(terme %in% colnames(mat))) next
+
+    idx <- which(classes_docs == as.character(classe_num) & mat[, terme] > 0)
+    if (length(idx) == 0) next
+
+    # Segment le plus représentatif pour le terme dans la classe (fréquence max du terme)
+    i_best <- idx[which.max(mat[idx, terme])]
+    seg <- gsub("\\s+", " ", trimws(textes[i_best]), perl = TRUE)
+    if (!nzchar(seg)) next
+    if (nchar(seg) > max_chars) seg <- paste0(substr(seg, 1, max_chars - 1), "…")
+
+    termes_stats$Segment_texte[i] <- seg
+  }
+
+  termes_stats
+}

iramuteq-like/afc_iramuteq.R

@@ -0,0 +1,672 @@
+# Rôle du fichier: afc.R porte une partie du pipeline d'analyse Rainette.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+# Il facilite la maintenance en explicitant le périmètre et les points d'intégration.
+# afc.R
+# AFC (Analyse Factorielle des Correspondances) pour classes × termes et classes × variables étoilées
+# Dépendance principale : FactoMineR (CA)
+# Le fichier fournit les fonctions attendues par app.R, sans changer la logique globale :
+# - calcul des tables de contingence
+# - exécution de l'AFC
+# - statistiques (fréquence, chi2, p-value)
+# - tracés avec axes centrés (0 au centre) et limites symétriques
+# - option anti-chevauchement des labels (placement en spirale + tests de collision)
+
+verifier_factominer <- function() {
+  if (!requireNamespace("FactoMineR", quietly = TRUE)) {
+    stop("AFC : le package 'FactoMineR' n'est pas installé ou indisponible dans l'environnement.")
+  }
+}
+
+# Limites symétriques autour de 0 pour centrer le graphe (0,0) au centre
+calculer_lim_sym <- function(x, y, marge = 0.08) {
+  x <- x[is.finite(x)]
+  y <- y[is.finite(y)]
+  if (length(x) == 0 || length(y) == 0) return(c(-1, 1))
+  m <- max(abs(c(x, y)))
+  if (!is.finite(m) || m == 0) m <- 1
+  m <- m * (1 + marge)
+  c(-m, m)
+}
+
+# Test de chevauchement rectangles
+.rectangles_chevauchent <- function(r1, r2) {
+  !(r1$xmax < r2$xmin || r2$xmax < r1$xmin || r1$ymax < r2$ymin || r2$ymax < r1$ymin)
+}
+
+# Placement anti-chevauchement des labels
+# Technique : on place les mots un par un. Si collision avec un label déjà placé, on déplace le label le long d'une spirale
+# (rayon croissant + angle) jusqu'à trouver une position non collisionnante, ou jusqu'à max_iter.
+placer_labels_sans_chevauchement_spirale <- function(x, y, labels, cex_vec, max_iter = 220) {
+  x <- as.numeric(x)
+  y <- as.numeric(y)
+  n <- length(labels)
+  if (n == 0) return(list(x = x, y = y))
+
+  if (length(cex_vec) == 1) cex_vec <- rep(cex_vec, n)
+  cex_vec <- as.numeric(cex_vec)
+  cex_vec[!is.finite(cex_vec)] <- 1
+
+  usr <- par("usr")
+  rx <- usr[2] - usr[1]
+  ry <- usr[4] - usr[3]
+  if (!is.finite(rx) || rx == 0) rx <- 1
+  if (!is.finite(ry) || ry == 0) ry <- 1
+
+  # Pas de déplacement relatif à l'étendue du graphe
+  pas <- 0.012 * max(rx, ry)
+
+  x2 <- x
+  y2 <- y
+
+  rects <- vector("list", n)
+
+  for (i in seq_len(n)) {
+    lab <- labels[i]
+    cexi <- cex_vec[i]
+
+    wi <- strwidth(lab, units = "user", cex = cexi)
+    hi <- strheight(lab, units = "user", cex = cexi)
+
+    if (!is.finite(wi) || wi == 0) wi <- 0.02 * rx
+    if (!is.finite(hi) || hi == 0) hi <- 0.02 * ry
+
+    xi <- x2[i]
+    yi <- y2[i]
+
+    ri <- list(
+      xmin = xi - wi / 2, xmax = xi + wi / 2,
+      ymin = yi - hi / 2, ymax = yi + hi / 2
+    )
+
+    collision <- FALSE
+    if (i > 1) {
+      for (j in seq_len(i - 1)) {
+        if (!is.null(rects[[j]]) && .rectangles_chevauchent(ri, rects[[j]])) {
+          collision <- TRUE
+          break
+        }
+      }
+    }
+
+    if (!collision) {
+      rects[[i]] <- ri
+      next
+    }
+
+    # Recherche en spirale
+    angle <- 0
+    rayon <- pas
+
+    trouve <- FALSE
+    for (k in seq_len(max_iter)) {
+      angle <- angle + 0.65
+      rayon <- rayon + pas * 0.15
+
+      xi_try <- x[i] + rayon * cos(angle)
+      yi_try <- y[i] + rayon * sin(angle)
+
+      ri_try <- list(
+        xmin = xi_try - wi / 2, xmax = xi_try + wi / 2,
+        ymin = yi_try - hi / 2, ymax = yi_try + hi / 2
+      )
+
+      collision2 <- FALSE
+      if (i > 1) {
+        for (j in seq_len(i - 1)) {
+          if (!is.null(rects[[j]]) && .rectangles_chevauchent(ri_try, rects[[j]])) {
+            collision2 <- TRUE
+            break
+          }
+        }
+      }
+
+      if (!collision2) {
+        x2[i] <- xi_try
+        y2[i] <- yi_try
+        rects[[i]] <- ri_try
+        trouve <- TRUE
+        break
+      }
+    }
+
+    if (!trouve) {
+      rects[[i]] <- ri
+    }
+  }
+
+  list(x = x2, y = y2)
+}
+
+# Calcul des résidus standardisés par colonne (terme/modalité) et par classe
+.calculer_residus_standardises <- function(tab) {
+  tab <- as.matrix(tab)
+  if (any(tab < 0, na.rm = TRUE)) stop("AFC : table de contingence invalide (valeurs négatives).")
+  n <- sum(tab)
+  if (!is.finite(n) || n <= 0) stop("AFC : table de contingence vide (somme nulle).")
+
+  rs <- rowSums(tab)
+  cs <- colSums(tab)
+  attendu <- outer(rs, cs) / n
+
+  # Résidus standardisés : (O - E) / sqrt(E)
+  res <- (tab - attendu) / sqrt(attendu)
+  res[!is.finite(res)] <- 0
+  list(attendu = attendu, residus = res)
+}
+
+# Statistiques globales d'association d'une colonne (terme/modalité) avec les classes
+# chi2 et p_value : test sur la distribution observée vs attendue sur les classes
+.calculer_stats_colonnes <- function(tab, seuil_p = 0.05) {
+  tab <- as.matrix(tab)
+  n <- sum(tab)
+  rs <- rowSums(tab)
+  cs <- colSums(tab)
+  k <- nrow(tab)
+
+  exp_mat <- outer(rs, cs) / n
+  exp_mat[!is.finite(exp_mat)] <- 0
+
+  out <- data.frame(
+    feature = colnames(tab),
+    frequency = as.numeric(cs),
+    chi2 = NA_real_,
+    p_value = NA_real_,
+    Classe_max = NA_character_,
+    resid_max = NA_real_,
+    stringsAsFactors = FALSE
+  )
+
+  rr <- .calculer_residus_standardises(tab)$residus
+
+  for (j in seq_len(ncol(tab))) {
+    obs <- tab[, j]
+    expv <- exp_mat[, j]
+
+    # chi2 global sur classes
+    good <- expv > 0
+    if (sum(good) >= 2) {
+      chi2j <- sum((obs[good] - expv[good])^2 / expv[good])
+      df <- max(1, sum(good) - 1)
+      pv <- suppressWarnings(stats::pchisq(chi2j, df = df, lower.tail = FALSE))
+    } else {
+      chi2j <- NA_real_
+      pv <- NA_real_
+    }
+
+    out$chi2[j] <- as.numeric(chi2j)
+    out$p_value[j] <- as.numeric(pv)
+
+    # classe de surreprésentation : max résidu standardisé
+    rj <- rr[, j]
+    imax <- which.max(rj)
+    out$Classe_max[j] <- rownames(tab)[imax]
+    out$resid_max[j] <- rj[imax]
+
+  }
+
+  out
+}
+
+# Construit la table Classes × Termes à partir d'un dfm quanteda
+calculer_table_classes_termes <- function(dfm_obj, groupes, termes_cibles = NULL, max_termes = 400) {
+  if (!inherits(dfm_obj, "dfm")) stop("AFC : dfm_obj doit être un objet quanteda::dfm.")
+  if (is.null(groupes) || length(groupes) != quanteda::ndoc(dfm_obj)) stop("AFC : 'groupes' doit avoir la même longueur que ndoc(dfm_obj).")
+
+  g <- suppressWarnings(as.integer(groupes))
+  g[!is.finite(g) | is.na(g) | g <= 0] <- NA_integer_
+
+  keep <- !is.na(g)
+  dfm2 <- dfm_obj[keep, ]
+  g2 <- as.character(g[keep])
+
+  if (quanteda::ndoc(dfm2) < 2) stop("AFC : pas assez de segments classés (hors NA).")
+
+  # Sélection des termes
+  if (!is.null(termes_cibles)) {
+    termes_cibles <- unique(as.character(termes_cibles))
+    termes_cibles <- termes_cibles[!is.na(termes_cibles) & nzchar(termes_cibles)]
+    termes_cibles <- intersect(termes_cibles, quanteda::featnames(dfm2))
+    if (length(termes_cibles) >= 2) {
+      dfm2 <- dfm2[, termes_cibles]
+    }
+  }
+
+  if (quanteda::nfeat(dfm2) > max_termes) {
+    top <- quanteda::topfeatures(dfm2, n = max_termes)
+    dfm2 <- dfm2[, names(top)]
+  }
+
+  if (quanteda::nfeat(dfm2) < 2) stop("AFC : moins de 2 termes disponibles pour l'AFC.")
+
+  dfm_g <- quanteda::dfm_group(dfm2, groups = g2)
+  mat <- as.matrix(dfm_g)
+  if (nrow(mat) < 2 || ncol(mat) < 2) stop("AFC : table Classes × Termes trop petite.")
+
+  # Noms des classes pour affichage
+  rn <- rownames(mat)
+  rn2 <- paste0("Classe ", rn)
+  rownames(mat) <- rn2
+
+  mat
+}
+
+# Exécution AFC classes × termes
+executer_afc_classes <- function(dfm_obj, groupes, termes_cibles = NULL, max_termes = 400, seuil_p = 0.05, rv = NULL) {
+  verifier_factominer()
+
+  tab <- calculer_table_classes_termes(
+    dfm_obj = dfm_obj,
+    groupes = groupes,
+    termes_cibles = termes_cibles,
+    max_termes = max_termes
+  )
+
+  ca <- FactoMineR::CA(tab, graph = FALSE)
+
+  rowcoord <- ca$row$coord
+  colcoord <- ca$col$coord
+
+  # Stats des termes (globales sur la table AFC)
+  st <- .calculer_stats_colonnes(tab, seuil_p = seuil_p)
+  names(st)[names(st) == "feature"] <- "Terme"
+
+  # Harmonisation : noms de classes déjà "Classe X"
+  st$Classe_max <- as.character(st$Classe_max)
+  # Dans .calculer_stats_colonnes, les classes sont rownames(tab), donc déjà "Classe X"
+
+  list(
+    table = tab,
+    ca = ca,
+    rowcoord = rowcoord,
+    colcoord = colcoord,
+    termes_stats = st,
+    seuil_p = seuil_p
+  )
+}
+
+# Tracé AFC des classes uniquement
+tracer_afc_classes_seules <- function(obj, axes = c(1, 2), cex_labels = 1.0) {
+  if (is.null(obj$ca) || is.null(obj$rowcoord)) stop("AFC classes : objet incomplet.")
+  ax1 <- axes[1]
+  ax2 <- axes[2]
+
+  rc <- obj$rowcoord
+  x_c <- rc[, ax1]
+  y_c <- rc[, ax2]
+
+  lim <- calculer_lim_sym(x_c, y_c)
+  plot(
+    0, 0,
+    type = "n",
+    xlab = paste0("Axe ", ax1),
+    ylab = paste0("Axe ", ax2),
+    xlim = lim, ylim = lim
+  )
+  abline(h = 0, v = 0, col = "gray80")
+
+  points(x_c, y_c, pch = 19, cex = 1.3)
+  text(x_c, y_c, labels = rownames(rc), pos = 3, cex = cex_labels)
+}
+
+# Tracé AFC classes + termes
+# - couleurs des mots : selon la classe où ils sont le plus surreprésentés (Classe_max)
+# - taille des mots : au choix (frequency ou chi2)
+# - anti-chevauchement : option activer_repel
+tracer_afc_classes_termes <- function(
+  obj,
+  axes = c(1, 2),
+  top_termes = 120,
+  taille_sel = c("frequency", "chi2"),
+  activer_repel = TRUE,
+  cex_min = 0.8,
+  cex_max = 2.0,
+  repel_max_iter = 220
+) {
+  if (is.null(obj$ca) || is.null(obj$rowcoord) || is.null(obj$colcoord) || is.null(obj$termes_stats)) {
+    stop("AFC : objet incomplet (coordonnées / stats manquantes).")
+  }
+
+  taille_sel <- match.arg(taille_sel)
+  ax1 <- axes[1]
+  ax2 <- axes[2]
+
+  rc <- obj$rowcoord
+  cc <- obj$colcoord
+  st <- obj$termes_stats
+
+  st <- st[!is.na(st$Terme) & nzchar(st$Terme), , drop = FALSE]
+  st <- st[order(-st$frequency), , drop = FALSE]
+
+  if (!is.null(top_termes) && is.finite(top_termes) && nrow(st) > top_termes) {
+    st <- st[seq_len(top_termes), , drop = FALSE]
+  }
+
+  st <- st[st$Terme %in% rownames(cc), , drop = FALSE]
+  if (nrow(st) < 2) {
+    plot.new()
+    text(0.5, 0.5, "AFC : pas assez de termes à tracer.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  mots <- st$Terme
+  xy_m <- cc[mots, , drop = FALSE]
+  x_m <- xy_m[, ax1]
+  y_m <- xy_m[, ax2]
+
+  x_c <- rc[, ax1]
+  y_c <- rc[, ax2]
+
+  lim <- calculer_lim_sym(c(x_m, x_c), c(y_m, y_c))
+  plot(
+    0, 0,
+    type = "n",
+    xlab = paste0("Axe ", ax1),
+    ylab = paste0("Axe ", ax2),
+    xlim = lim, ylim = lim
+  )
+  abline(h = 0, v = 0, col = "gray80")
+
+  # Note sur la technique : si activer_repel=TRUE, on applique un placement itératif en spirale
+  # avec tests de collision rectangles afin de réduire le chevauchement des étiquettes.
+  # Cela ne garantit pas 0 collision dans tous les cas, mais réduit fortement les superpositions.
+  points(x_c, y_c, pch = 19, cex = 1.25)
+  text(x_c, y_c, labels = rownames(rc), pos = 3, cex = 1.0)
+
+  # Couleurs par classe
+  classes <- sort(unique(rownames(rc)))
+  ncl <- length(classes)
+  pal <- if (requireNamespace("RColorBrewer", quietly = TRUE) && ncl <= 8) {
+    RColorBrewer::brewer.pal(max(3, ncl), "Set2")[seq_len(ncl)]
+  } else {
+    grDevices::rainbow(ncl)
+  }
+  col_map <- setNames(pal, classes)
+  col_m <- col_map[st$Classe_max]
+  col_m[is.na(col_m)] <- "gray40"
+
+  # Tailles
+  poids <- if (taille_sel == "chi2") st$chi2 else st$frequency
+  poids <- suppressWarnings(as.numeric(poids))
+  poids[!is.finite(poids)] <- 0
+  poids <- pmax(0, poids)
+
+  if (max(poids) == min(poids)) {
+    cex_vec <- rep((cex_min + cex_max) / 2, length(poids))
+  } else {
+    v <- sqrt(poids)
+    v <- (v - min(v)) / (max(v) - min(v))
+    cex_vec <- cex_min + v * (cex_max - cex_min)
+  }
+
+  if (isTRUE(activer_repel)) {
+    coords <- placer_labels_sans_chevauchement_spirale(
+      x = x_m, y = y_m, labels = mots, cex_vec = cex_vec, max_iter = repel_max_iter
+    )
+    x_lab <- coords$x
+    y_lab <- coords$y
+  } else {
+    x_lab <- x_m
+    y_lab <- y_m
+  }
+
+  points(x_lab, y_lab, pch = 16, cex = 0.5, col = col_m)
+  text(x_lab, y_lab, labels = mots, cex = cex_vec, col = col_m)
+}
+
+# Fallback : extraction de modalités depuis une ligne IRaMuTeQ (si docvars vides)
+.extraire_modalites_depuis_ligne_iramuteq <- function(textes) {
+  if (length(textes) == 0) return(vector("list", 0))
+  res <- vector("list", length(textes))
+  for (i in seq_along(textes)) {
+    tx <- textes[i]
+    if (is.na(tx) || !nzchar(tx)) {
+      res[[i]] <- character(0)
+      next
+    }
+    # On cherche des tokens commençant par * dans les 400 premiers caractères
+    head <- substr(tx, 1, 400)
+    mods <- unlist(regmatches(head, gregexpr("\\*[A-Za-z0-9_\\-]+", head, perl = TRUE)), use.names = FALSE)
+    mods <- unique(mods)
+    mods <- mods[!is.na(mods) & nzchar(mods)]
+    res[[i]] <- mods
+  }
+  res
+}
+
+# Construction table Classes × Modalités à partir des docvars (ou fallback texte)
+calculer_table_classes_modalites <- function(corpus_aligne, groupes, max_modalites = 400) {
+  if (is.null(corpus_aligne)) stop("AFC variables étoilées : corpus_aligne requis.")
+  dv <- quanteda::docvars(corpus_aligne)
+
+  g <- suppressWarnings(as.integer(groupes))
+  g[!is.finite(g) | is.na(g) | g <= 0] <- NA_integer_
+  keep <- !is.na(g)
+  if (sum(keep) < 2) stop("AFC variables étoilées : pas assez de segments classés (hors NA).")
+
+  dv2 <- dv[keep, , drop = FALSE]
+  g2 <- as.character(g[keep])
+
+  # Colonnes candidates : on exclut les colonnes techniques
+  exclure <- c("segment_source", "Classes")
+  cols <- setdiff(colnames(dv2), exclure)
+  cols <- cols[!is.na(cols) & nzchar(cols)]
+
+  # Priorité aux variables étoilées importées depuis l'entête IRaMuTeQ.
+  # Certains imports exposent les variables avec un nom préfixé "*".
+  cols_etoilees <- cols[grepl("^\\*", cols)]
+  if (length(cols_etoilees) > 0) {
+    cols <- cols_etoilees
+  }
+
+  modalites_par_seg <- NULL
+
+  if (length(cols) > 0) {
+    modalites_par_seg <- vector("list", nrow(dv2))
+    for (i in seq_len(nrow(dv2))) {
+      mods <- character(0)
+      for (cn in cols) {
+        if (is.na(cn) || !nzchar(cn)) next
+        v <- dv2[i, cn]
+        v <- as.character(v)
+        v <- v[!is.na(v) & nzchar(v)]
+        if (length(v) == 0) next
+        v <- gsub("\\s+", " ", trimws(v), perl = TRUE)
+        if (!nzchar(v)) next
+        # Modalité de type "var=valeur"
+        # Si la colonne est déjà une variable étoilée, on garde une modalité
+        # compacte de type "*var_valeur" pour rester proche de la syntaxe IRaMuTeQ.
+        if (isTRUE(grepl("^\\*", cn))) {
+          val_norm <- gsub("\\s+", "_", v, perl = TRUE)
+          val_norm <- gsub("[^[:alnum:]_\\-]", "_", val_norm, perl = TRUE)
+          val_norm <- gsub("_+", "_", val_norm, perl = TRUE)
+          val_norm <- gsub("^_+|_+$", "", val_norm, perl = TRUE)
+          if (nzchar(val_norm)) {
+            mods <- c(mods, paste0(cn, "_", val_norm))
+          }
+        } else {
+          mods <- c(mods, paste0(cn, "=", v))
+        }
+      }
+      modalites_par_seg[[i]] <- unique(mods)
+    }
+  }
+
+  # Fallback si aucune modalité trouvée via docvars
+  if (is.null(modalites_par_seg) || all(vapply(modalites_par_seg, length, integer(1)) == 0)) {
+    textes <- as.character(corpus_aligne)[keep]
+    modalites_par_seg <- .extraire_modalites_depuis_ligne_iramuteq(textes)
+  }
+
+  all_mods <- unique(unlist(modalites_par_seg, use.names = FALSE))
+  all_mods <- all_mods[!is.na(all_mods) & nzchar(all_mods)]
+  if (length(all_mods) < 2) stop("AFC variables étoilées : aucune modalité détectée.")
+
+  # Comptages classes × modalités (présence/absence par segment)
+  classes <- unique(g2)
+  classes <- classes[!is.na(classes)]
+  classes <- sort(classes)
+
+  tab <- matrix(0, nrow = length(classes), ncol = length(all_mods))
+  rownames(tab) <- paste0("Classe ", classes)
+  colnames(tab) <- all_mods
+
+  # Remplissage
+  for (i in seq_along(g2)) {
+    cl <- g2[i]
+    if (is.na(cl)) next
+    mods <- modalites_par_seg[[i]]
+    if (length(mods) == 0) next
+    mods <- intersect(mods, all_mods)
+    if (length(mods) == 0) next
+    tab[paste0("Classe ", cl), mods] <- tab[paste0("Classe ", cl), mods] + 1L
+  }
+
+  # Filtrage éventuel top modalités par fréquence
+  freq <- colSums(tab)
+  keepm <- freq > 0
+  tab <- tab[, keepm, drop = FALSE]
+  if (ncol(tab) < 2) stop("AFC variables étoilées : table trop pauvre après filtrage.")
+
+  if (ncol(tab) > max_modalites) {
+    ord <- order(colSums(tab), decreasing = TRUE)
+    tab <- tab[, ord[seq_len(max_modalites)], drop = FALSE]
+  }
+
+  tab
+}
+
+# Exécution AFC classes × variables étoilées
+executer_afc_variables_etoilees <- function(corpus_aligne, groupes, max_modalites = 400, seuil_p = 0.05, rv = NULL) {
+  verifier_factominer()
+
+  tab <- calculer_table_classes_modalites(
+    corpus_aligne = corpus_aligne,
+    groupes = groupes,
+    max_modalites = max_modalites
+  )
+
+  if (!is.null(rv)) {
+    ajouter_log(
+      rv,
+      paste0(
+        "AFC variables étoilées : table construite (",
+        nrow(tab),
+        " classes × ",
+        ncol(tab),
+        " modalités)."
+      )
+    )
+  }
+
+  ca <- FactoMineR::CA(tab, graph = FALSE)
+  rowcoord <- ca$row$coord
+  colcoord <- ca$col$coord
+
+  st <- .calculer_stats_colonnes(tab, seuil_p = seuil_p)
+  names(st)[names(st) == "feature"] <- "Modalite"
+
+  list(
+    table = tab,
+    ca = ca,
+    rowcoord = rowcoord,
+    colcoord = colcoord,
+    modalites_stats = st,
+    seuil_p = seuil_p
+  )
+}
+
+# Tracé AFC classes + variables étoilées
+tracer_afc_variables_etoilees <- function(
+  obj,
+  axes = c(1, 2),
+  top_modalites = 120,
+  activer_repel = TRUE,
+  cex_min = 0.8,
+  cex_max = 2.0,
+  repel_max_iter = 220
+) {
+  if (is.null(obj$ca) || is.null(obj$rowcoord) || is.null(obj$colcoord) || is.null(obj$modalites_stats)) {
+    stop("AFC variables étoilées : objet incomplet (coordonnées / stats manquantes).")
+  }
+
+  ax1 <- axes[1]
+  ax2 <- axes[2]
+
+  rc <- obj$rowcoord
+  cc <- obj$colcoord
+  st <- obj$modalites_stats
+
+  st <- st[!is.na(st$Modalite) & nzchar(st$Modalite), , drop = FALSE]
+  st <- st[order(-st$frequency), , drop = FALSE]
+
+  if (!is.null(top_modalites) && is.finite(top_modalites) && nrow(st) > top_modalites) {
+    st <- st[seq_len(top_modalites), , drop = FALSE]
+  }
+
+  st <- st[st$Modalite %in% rownames(cc), , drop = FALSE]
+  if (nrow(st) < 2) {
+    plot.new()
+    text(0.5, 0.5, "AFC variables étoilées : pas assez de modalités à tracer.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  mods <- st$Modalite
+  xy_m <- cc[mods, , drop = FALSE]
+  x_m <- xy_m[, ax1]
+  y_m <- xy_m[, ax2]
+
+  x_c <- rc[, ax1]
+  y_c <- rc[, ax2]
+
+  lim <- calculer_lim_sym(c(x_m, x_c), c(y_m, y_c))
+  plot(
+    0, 0,
+    type = "n",
+    xlab = paste0("Axe ", ax1),
+    ylab = paste0("Axe ", ax2),
+    xlim = lim, ylim = lim
+  )
+  abline(h = 0, v = 0, col = "gray80")
+
+  points(x_c, y_c, pch = 19, cex = 1.25)
+  text(x_c, y_c, labels = rownames(rc), pos = 3, cex = 1.0)
+
+  # Couleurs par classe (classe max)
+  classes <- sort(unique(rownames(rc)))
+  ncl <- length(classes)
+  pal <- if (requireNamespace("RColorBrewer", quietly = TRUE) && ncl <= 8) {
+    RColorBrewer::brewer.pal(max(3, ncl), "Set2")[seq_len(ncl)]
+  } else {
+    grDevices::rainbow(ncl)
+  }
+  col_map <- setNames(pal, classes)
+  col_m <- col_map[st$Classe_max]
+  col_m[is.na(col_m)] <- "gray40"
+
+  # Tailles : fréquence globale des modalités
+  poids <- suppressWarnings(as.numeric(st$frequency))
+  poids[!is.finite(poids)] <- 0
+  poids <- pmax(0, poids)
+
+  if (max(poids) == min(poids)) {
+    cex_vec <- rep((cex_min + cex_max) / 2, length(poids))
+  } else {
+    v <- sqrt(poids)
+    v <- (v - min(v)) / (max(v) - min(v))
+    cex_vec <- cex_min + v * (cex_max - cex_min)
+  }
+
+  if (isTRUE(activer_repel)) {
+    coords <- placer_labels_sans_chevauchement_spirale(
+      x = x_m, y = y_m, labels = mods, cex_vec = cex_vec, max_iter = repel_max_iter
+    )
+    x_lab <- coords$x
+    y_lab <- coords$y
+  } else {
+    x_lab <- x_m
+    y_lab <- y_m
+  }
+
+  points(x_lab, y_lab, pch = 16, cex = 0.5, col = col_m)
+  text(x_lab, y_lab, labels = mods, cex = cex_vec, col = col_m)
+}

iramuteq-like/affichage_iramuteq-like.R

@@ -0,0 +1,42 @@
+# Rôle du fichier: centraliser l'affichage des résultats IRaMuTeQ-like avec des sous-onglets dédiés.
+
+ui_resultats_chd_iramuteq <- function() {
+  tabPanel(
+    "Résultats CHD Iramuteq",
+    tabsetPanel(
+      id = "tabs_resultats_chd_iramuteq",
+      tabPanel(
+        "Dendrogramme",
+        tags$h3("Dendrogramme CHD (IRaMuTeQ-like)"),
+        radioButtons(
+          "iramuteq_dendro_display_method",
+          "Méthode d'affichage",
+          choices = c(
+            "Style IRaMuTeQ (barres + mots par classe)" = "iramuteq_blocks",
+            "Standard (labels près des classes)" = "standard",
+            "Compact (légende des termes en bas)" = "compact"
+          ),
+          selected = "iramuteq_blocks",
+          inline = FALSE
+        ),
+        plotOutput("plot_chd_iramuteq_dendro", height = "420px")
+      ),
+      tabPanel(
+        "Stats CHD",
+        tags$h3("Tableaux statistiques CHD par classe"),
+        uiOutput("ui_tables_stats_chd_iramuteq")
+      ),
+      tabPanel(
+        "Concordancier IRaMuTeQ-like",
+        tags$h3("Concordancier"),
+        uiOutput("ui_concordancier_iramuteq")
+      ),
+      tabPanel(
+        "Nuage de mots",
+        tags$h3("Nuage de mots par classe"),
+        selectInput("classe_viz_iramuteq", "Classe", choices = c("1"), selected = "1"),
+        uiOutput("ui_wordcloud_iramuteq")
+      )
+    )
+  )
+}

iramuteq-like/anacor.R

@@ -0,0 +1,114 @@
+#################################################################################
+
+
+write.sparse <- function (m, to) {
+  ## Writes in a format that SVDLIBC can read
+  stopifnot(inherits(m, "dgCMatrix"))
+  fh <- file(to, open="w")
+  
+  wl <- function(...) cat(..., "\n", file=fh)
+  
+  ## header
+  wl(dim(m), length(m@x))
+  
+  globalCount <- 1
+  nper <- diff(m@p)
+  for(i in 1:ncol(m)) {
+    wl(nper[i])  ## Number of entries in this column
+    if (nper[i]==0) next
+    for(j in 1:nper[i]) {
+      wl(m@i[globalCount], m@x[m@p[i]+j])
+      globalCount <- globalCount+1
+    }
+  }
+}
+
+my.svd <- function(x, nu, nv, libsvdc.path=NULL, sparse.path=NULL) {
+  print('my.svd')
+  stopifnot(nu==nv)
+  outfile <- file.path(tempdir(),'sout')
+  cmd <- paste(libsvdc.path, '-o', outfile, '-d')
+  #rc <- system(paste("/usr/bin/svd -o /tmp/sout -d", nu, "/tmp/sparse.m"))
+  rc <- system(paste(cmd, nu, sparse.path))
+  if (rc != 0)
+    stop("Couldn't run external svd code")
+  res1 <- paste(outfile,'-S', sep='')
+  d <- scan(res1, skip=1)
+#FIXME : sometimes, libsvdc doesn't find solution with 2 dimensions, but does with 3 
+  if (length(d)==1) {
+      nu <- nu + 1
+      #rc <- system(paste("/usr/bin/svd -o /tmp/sout -d", nu, "/tmp/sparse.m"))
+      rc <- system(paste(cmd, nu, sparse.path))
+      d <- scan(res1, skip=1)
+  }
+  utfile <- paste(outfile, '-Ut', sep='')
+  ut <- matrix(scan(utfile,skip=1),nrow=nu,byrow=TRUE)
+  if (nrow(ut)==3) {
+      ut <- ut[-3,]
+  }
+  vt <- NULL
+  list(d=d, u=-t(ut), v=vt)
+}
+###################################################################################
+
+#from anacor package
+boostana<-function (tab, ndim = 2, svd.method = 'svdR', libsvdc.path=NULL) 
+{
+    #tab <- as.matrix(tab)
+    if (ndim > min(dim(tab)) - 1) 
+        stop("Too many dimensions!")
+    name <- deparse(substitute(tab))
+    if (any(is.na(tab))) 
+	print('YA NA')        
+	#tab <- reconstitute(tab, eps = eps)
+    n <- dim(tab)[1]
+    m <- dim(tab)[2]
+    N <- sum(tab)
+    #tab <- as.matrix(tab)
+    #prop <- as.vector(t(tab))/N
+    r <- rowSums(tab)
+    c <- colSums(tab)
+    qdim <- ndim + 1
+    r <- ifelse(r == 0, 1, r)
+    c <- ifelse(c == 0, 1, c)
+    print('make z')
+    z1 <- t(tab)/sqrt(c)
+    z2 <- tab/sqrt(r)
+    z <- t(z1) * z2
+    if (svd.method == 'svdlibc') {
+        #START NEW SVD
+        z <- as(z, "dgCMatrix")
+        tmpmat <- tempfile(pattern='sparse')
+        print('write sparse matrix')
+        write.sparse(z, tmpmat)
+        print('do svd')
+        sv <- my.svd(z, qdim, qdim, libsvdc.path=libsvdc.path, sparse.path=tmpmat)
+        #END NEW SVD
+    } else if (svd.method == 'svdR') {
+        print('start R svd')
+        sv <- svd(z, nu = qdim, nv = qdim) 
+        print('end svd')
+    } else if (svd.method == 'irlba') {
+        if (!requireNamespace("irlba", quietly = TRUE)) {
+            warning("Package 'irlba' introuvable, bascule automatique vers 'svdR'.")
+            print('start R svd (fallback)')
+            sv <- svd(z, nu = qdim, nv = qdim)
+            print('end svd (fallback)')
+        } else {
+            print('irlba')
+            sv <- irlba::irlba(z, nv = qdim, nu = qdim)
+            print('end irlba')
+        }
+    }
+    sigmavec <- (sv$d)[2:qdim]
+	x <- ((sv$u)/sqrt(r))[, -1]
+    x <- x * sqrt(N)
+    x <- x * outer(rep(1, n), sigmavec)
+    dimlab <- paste("D", 1:ndim, sep = "")
+    colnames(x) <- dimlab# <- colnames(y) <- dimlab
+    rownames(x) <- rownames(tab)
+    result <- list(ndim = ndim, row.scores = x, 
+			singular.values = sigmavec, eigen.values = sigmavec^2)
+    class(result) <- "boostanacor"
+    result
+}

iramuteq-like/chd_afc_pipeline_iramuteq.R

@@ -0,0 +1,316 @@
+# Rôle du fichier: chd_afc_pipeline.R porte une partie du pipeline d'analyse Rainette.
+# Module CHD/AFC - préparation des données et génération des artefacts CHD
+# Ce fichier centralise les fonctions de préparation DFM/docvars, l'ajustement de `k`,
+# les utilitaires de graphes d'adjacence/cooccurrence, et la génération des exports
+# CHD (PNG + HTML) afin d'alléger `app.R` sans modifier le comportement existant.
+
+extraire_classes_alignees <- function(corpus_obj, doc_ids, nom_colonne = "Classes") {
+  dv <- docvars(corpus_obj)
+  if (!(nom_colonne %in% names(dv))) return(rep(NA_character_, length(doc_ids)))
+
+  doc_ids <- as.character(doc_ids)
+  dn_corpus <- as.character(docnames(corpus_obj))
+  idx <- match(doc_ids, dn_corpus)
+
+  out <- rep(NA_character_, length(doc_ids))
+  ok <- !is.na(idx)
+  if (any(ok)) {
+    out[ok] <- as.character(dv[[nom_colonne]][idx[ok]])
+  }
+
+  normaliser_classes(out)
+}
+
+construire_segment_source <- function(corpus_segmente) {
+  dv <- docvars(corpus_segmente)
+
+  if ("segment_source" %in% names(dv)) {
+    v <- as.character(dv$segment_source)
+    if (length(v) == ndoc(corpus_segmente)) return(v)
+  }
+
+  dn <- docnames(corpus_segmente)
+
+  if (any(grepl("_seg[0-9]+$", dn))) return(gsub("_seg[0-9]+$", "", dn))
+  if (any(grepl("_[0-9]+$", dn))) return(gsub("_[0-9]+$", "", dn))
+  if (any(grepl("-[0-9]+$", dn))) return(gsub("-[0-9]+$", "", dn))
+
+  dn
+}
+
+assurer_docvars_dfm_minimal <- function(dfm_obj, corpus_aligne) {
+  seg_source <- construire_segment_source(corpus_aligne)
+  dv <- data.frame(segment_source = seg_source, stringsAsFactors = FALSE)
+  rownames(dv) <- docnames(corpus_aligne)
+  docvars(dfm_obj) <- dv
+  dfm_obj
+}
+
+construire_dfm_avec_fallback_stopwords <- function(tok_base, min_docfreq, retirer_stopwords, langue_spacy, rv, libelle, source_dictionnaire = "spacy", lexique_source_stopwords = "quanteda") {
+  n_base <- compter_tokens(tok_base)
+  ajouter_log(rv, paste0(libelle, " : tokens (avant stopwords) = ", n_base))
+
+  if (isTRUE(retirer_stopwords)) {
+    stopwords_a_retirer <- obtenir_stopwords_analyse(
+      langue_spacy = langue_spacy,
+      source_dictionnaire = source_dictionnaire,
+      lexique_source_stopwords = lexique_source_stopwords,
+      rv = rv
+    )
+    tok_sw <- tokens_remove(tok_base, stopwords_a_retirer)
+    tok_sw <- tokens_tolower(tok_sw)
+    n_sw <- compter_tokens(tok_sw)
+    ajouter_log(rv, paste0(libelle, " : tokens (après stopwords) = ", n_sw))
+    tok_final <- tok_sw
+  } else {
+    ajouter_log(rv, paste0(libelle, " : suppression des stopwords désactivée."))
+    tok_final <- tokens_tolower(tok_base)
+  }
+
+  if (!isTRUE(retirer_stopwords) && isTRUE(min_docfreq > 1)) {
+    ajouter_log(rv, paste0(libelle, " : min_docfreq=", min_docfreq, " peut éliminer des nombres rares (ex: numéros de téléphone)."))
+  }
+
+  dfm_obj <- dfm(tok_final)
+  dfm_obj <- dfm_trim(dfm_obj, min_docfreq = min_docfreq)
+  ajouter_log(
+    rv,
+    paste0(
+      libelle,
+      " : DFM après trim = ", ndoc(dfm_obj), " docs ; ", nfeat(dfm_obj),
+      ifelse(isTRUE(retirer_stopwords), " termes (avec stopwords retirés)", " termes (sans suppression des stopwords)")
+    )
+  )
+
+  if (isTRUE(retirer_stopwords) && nfeat(dfm_obj) < 2) {
+    ajouter_log(rv, paste0(libelle, " : DFM trop pauvre avec stopwords retirés. Relance automatique sans suppression des stopwords."))
+    tok_final <- tokens_tolower(tok_base)
+    dfm_obj <- dfm(tok_final)
+    dfm_obj <- dfm_trim(dfm_obj, min_docfreq = min_docfreq)
+    ajouter_log(rv, paste0(libelle, " : DFM après trim = ", ndoc(dfm_obj), " docs ; ", nfeat(dfm_obj), " termes (sans stopwords)"))
+  }
+
+  list(tok = tok_final, dfm = dfm_obj)
+}
+
+supprimer_docs_vides_dfm <- function(dfm_obj, corpus_aligne, tok_aligne, rv) {
+  rs <- tryCatch(Matrix::rowSums(dfm_obj), error = function(e) NULL)
+
+  if (is.null(rs)) {
+    ajouter_log(rv, "Impossible de calculer rowSums(dfm). Aucune suppression de segments vides.")
+    return(list(dfm = dfm_obj, corpus = corpus_aligne, tok = tok_aligne))
+  }
+
+  n_vides <- sum(rs == 0)
+  if (n_vides > 0) {
+    ajouter_log(rv, paste0("Segments vides (aucun terme) détectés : ", n_vides, ". Suppression avant CHD."))
+    garder <- rs > 0
+    dfm_obj <- dfm_obj[garder, ]
+    noms <- docnames(dfm_obj)
+    corpus_aligne <- corpus_aligne[noms]
+    tok_aligne <- tok_aligne[noms]
+  }
+
+  list(dfm = dfm_obj, corpus = corpus_aligne, tok = tok_aligne)
+}
+
+calculer_k_effectif <- function(dfm_obj, k_demande, min_split_members, rv = NULL) {
+  n_docs <- ndoc(dfm_obj)
+  if (!is.finite(min_split_members) || is.na(min_split_members) || min_split_members < 1) {
+    min_split_members <- 1
+  }
+
+  k_max_theorique <- floor(n_docs / min_split_members)
+  if (!is.finite(k_max_theorique) || is.na(k_max_theorique)) k_max_theorique <- n_docs
+  k_max_theorique <- max(1, min(k_max_theorique, n_docs - 1))
+
+  k_effectif <- min(k_demande, k_max_theorique)
+
+  if (k_effectif < 2) {
+    stop(
+      "Paramètres incompatibles : min_split_members=", min_split_members,
+      " est trop élevé pour ", n_docs,
+      " segments. Réduis min_split_members ou augmente la taille du corpus segmenté."
+    )
+  }
+
+  if (!is.null(rv) && k_effectif < k_demande) {
+    ajouter_log(
+      rv,
+      paste0(
+        "k ajusté automatiquement de ", k_demande, " à ", k_effectif,
+        " pour respecter min_split_members=", min_split_members,
+        " (", n_docs, " segments disponibles)."
+      )
+    )
+  }
+
+  k_effectif
+}
+
+verifier_dfm_avant_rainette <- function(dfm_obj, input) {
+  if (ndoc(dfm_obj) < 2) {
+    stop("Après filtrages, il reste moins de 2 segments utilisables. Réduis les filtrages ou augmente segment_size.")
+  }
+  if (nfeat(dfm_obj) < 2) {
+    stop(
+      "Après filtrages, il reste moins de 2 termes dans le DFM. ",
+      "Même avec min_docfreq=1, cela arrive si le filtrage morphosyntaxique est trop strict et/ou si les stopwords retirent la majorité des formes. ",
+      "Élargis les catégories morphosyntaxiques ou augmente segment_size."
+    )
+  }
+}
+
+obtenir_objet_dendrogramme <- function(res) {
+  if (is.null(res)) return(NULL)
+
+  if (inherits(res, "hclust") || inherits(res, "dendrogram")) return(res)
+
+  if (is.list(res)) {
+    candidats <- c("tree", "hc", "hclust", "dendro", "dendrogram")
+    for (nm in candidats) {
+      if (!is.null(res[[nm]]) && (inherits(res[[nm]], "hclust") || inherits(res[[nm]], "dendrogram"))) {
+        return(res[[nm]])
+      }
+    }
+  }
+
+  NULL
+}
+
+construire_graphe_adjacence <- function(mat) {
+  if ("graph_from_adjacency_matrix" %in% getNamespaceExports("igraph")) {
+    igraph::graph_from_adjacency_matrix(mat, mode = "undirected", weighted = TRUE, diag = FALSE)
+  } else {
+    igraph::graph.adjacency(mat, mode = "undirected", weighted = TRUE, diag = FALSE)
+  }
+}
+
+generer_chd_explor_si_absente <- function(rv) {
+  if (is.null(rv$export_dir) || !nzchar(rv$export_dir)) return(FALSE)
+
+  explor_dir <- file.path(rv$export_dir, "explor")
+  dir.create(explor_dir, showWarnings = FALSE, recursive = TRUE)
+
+  chd_png <- file.path(explor_dir, "chd.png")
+  if (file.exists(chd_png)) return(TRUE)
+
+  chd_obj <- rv$res_chd
+  if (is.null(chd_obj)) chd_obj <- rv$res
+  if (is.null(chd_obj)) return(FALSE)
+
+  dfm_obj <- rv$dfm_chd
+  err_msg <- NULL
+
+  ecrire_png_secours <- function(message = NULL) {
+    grDevices::png(chd_png, width = 2000, height = 1500, res = 180)
+    tryCatch({
+      plot.new()
+      title("CHD (export)")
+      txt <- "CHD indisponible pour cet export."
+      if (!is.null(message) && nzchar(message)) {
+        txt <- paste0(txt, "\n", message)
+      }
+      text(0.5, 0.5, txt, cex = 1.1)
+    }, finally = {
+      try(grDevices::dev.off(), silent = TRUE)
+    })
+    file.exists(chd_png) && is.finite(file.info(chd_png)$size) && file.info(chd_png)$size > 0
+  }
+
+  dessiner_chd <- function(avec_dfm = FALSE) {
+    grDevices::png(chd_png, width = 2000, height = 1500, res = 180)
+    ok_plot <- FALSE
+
+    tryCatch({
+      if (isTRUE(avec_dfm) && !is.null(dfm_obj)) {
+        k_plot <- suppressWarnings(as.integer(rv$max_n_groups_chd))
+        if (!is.finite(k_plot) || is.na(k_plot) || k_plot < 2) {
+          if (!is.null(chd_obj$group)) {
+            k_plot <- suppressWarnings(max(as.integer(chd_obj$group), na.rm = TRUE))
+          }
+        }
+        if (!is.finite(k_plot) || is.na(k_plot) || k_plot < 2) k_plot <- 2L
+
+        args_plot <- list(
+          chd_obj,
+          dfm_obj,
+          k = k_plot,
+          measure = "chi2",
+          type = "bar",
+          n_terms = 20,
+          show_negative = FALSE,
+          text_size = 12
+        )
+
+        params_plot <- tryCatch(names(formals(rainette_plot)), error = function(e) character(0))
+        if ("same_scales" %in% params_plot) args_plot$same_scales <- TRUE
+        if ("free_scales" %in% params_plot) args_plot$free_scales <- FALSE
+
+        do.call(rainette_plot, args_plot)
+      } else {
+        rainette_plot(chd_obj)
+      }
+      ok_plot <- TRUE
+    }, error = function(e) {
+      err_msg <<- conditionMessage(e)
+    }, finally = {
+      try(grDevices::dev.off(), silent = TRUE)
+    })
+
+    isTRUE(ok_plot) && file.exists(chd_png) && is.finite(file.info(chd_png)$size) && file.info(chd_png)$size > 0
+  }
+
+  ok <- dessiner_chd(avec_dfm = FALSE)
+  if (!ok && !is.null(dfm_obj)) {
+    ok <- dessiner_chd(avec_dfm = TRUE)
+  }
+
+  if (!ok) {
+    if (!is.null(rv)) {
+      msg <- if (!is.null(err_msg) && nzchar(err_msg)) err_msg else "raison inconnue"
+      ajouter_log(rv, paste0("CHD PNG non généré (", msg, ")."))
+    }
+    if (file.exists(chd_png)) unlink(chd_png)
+
+    ok_fallback <- ecrire_png_secours(err_msg)
+    if (ok_fallback) {
+      if (!is.null(rv)) ajouter_log(rv, paste0("CHD PNG de secours généré : ", chd_png))
+      ok <- TRUE
+    }
+  } else if (!is.null(rv)) {
+    ajouter_log(rv, paste0("CHD PNG généré : ", chd_png))
+  }
+
+  ok
+}
+
+generer_chd_html_explor <- function(rv, chd_png_rel = NULL) {
+  if (is.null(rv$export_dir) || !nzchar(rv$export_dir)) return(NULL)
+
+  explor_dir <- file.path(rv$export_dir, "explor")
+  dir.create(explor_dir, showWarnings = FALSE, recursive = TRUE)
+
+  chd_html <- file.path(explor_dir, "chd.html")
+  img_part <- "<p><em>CHD non disponible dans l'export.</em></p>"
+  if (!is.null(chd_png_rel) && nzchar(chd_png_rel)) {
+    img_src <- basename(chd_png_rel)
+    img_part <- paste0("<p><img src='", img_src, "' style='max-width:100%;height:auto;border:1px solid #ddd;'/></p>")
+  }
+
+  con <- file(chd_html, open = "wt", encoding = "UTF-8")
+  on.exit(try(close(con), silent = TRUE), add = TRUE)
+
+  writeLines("<html><head><meta charset='utf-8'/><title>CHD Rainette</title>", con)
+  writeLines("<style>body{font-family:Arial,sans-serif;margin:20px;} h1{margin-top:0;}</style>", con)
+  writeLines("</head><body>", con)
+  writeLines("<h1>CHD (Rainette)</h1>", con)
+  writeLines(img_part, con)
+  writeLines("</body></html>", con)
+
+  if (!file.exists(chd_html)) return(NULL)
+  if (!is.finite(file.info(chd_html)$size) || file.info(chd_html)$size <= 0) return(NULL)
+
+  if (!is.null(rv)) ajouter_log(rv, paste0("CHD HTML généré : ", chd_html))
+  file.path("explor", "chd.html")
+}

iramuteq-like/chd_engine_iramuteq.R

@@ -0,0 +1,117 @@
+# Rôle du fichier: chd_engine_iramuteq.R encapsule le lancement du moteur CHD IRaMuTeQ-like.
+# Ce module sert de point d'entrée dédié pour exécuter la CHD historique et reconstruire
+# les classes terminales avec mincl (auto ou manuel).
+
+.obtenir_fonction_iramuteq <- function(nom_fonction,
+                                       chemin_module = "R/chd_iramuteq.R",
+                                       env = parent.frame()) {
+  fn <- get0(nom_fonction, mode = "function", inherits = TRUE)
+  if (!is.null(fn)) return(fn)
+
+  # Répertoire du projet (quand l'app est lancée hors du dossier racine).
+  racine_projet <- tryCatch({
+    if (requireNamespace("shiny", quietly = TRUE)) {
+      shiny::getShinyOption("appDir")
+    } else {
+      NULL
+    }
+  }, error = function(...) NULL)
+
+  # Répertoire courant du fichier R/chd_engine_iramuteq.R, si disponible.
+  fichier_courant <- tryCatch({
+    frames <- rev(sys.frames())
+    ofiles <- vapply(
+      frames,
+      function(fr) {
+        of <- get0("ofile", envir = fr, inherits = FALSE)
+        if (is.null(of)) "" else as.character(of)
+      },
+      FUN.VALUE = character(1)
+    )
+    ofiles <- ofiles[nzchar(ofiles)]
+    if (length(ofiles)) ofiles[[1]] else ""
+  }, error = function(...) "")
+  dir_fichier_courant <- if (nzchar(fichier_courant)) dirname(normalizePath(fichier_courant, mustWork = FALSE)) else ""
+  racine_depuis_fichier <- if (nzchar(dir_fichier_courant)) normalizePath(file.path(dir_fichier_courant, ".."), mustWork = FALSE) else ""
+
+  candidats <- unique(c(
+    chemin_module,
+    file.path("R", "chd_iramuteq.R"),
+    file.path("R", "chd_iramuteq_like.R"),
+    if (nzchar(racine_depuis_fichier)) file.path(racine_depuis_fichier, "iramuteq-like", "chd_iramuteq_compat.R") else "",
+    if (nzchar(racine_depuis_fichier)) file.path(racine_depuis_fichier, "iramuteq-like", "chd_iramuteq.R") else "",
+    if (nzchar(racine_depuis_fichier)) file.path(racine_depuis_fichier, "R", "chd_iramuteq.R") else "",
+    if (!is.null(racine_projet) && nzchar(racine_projet)) file.path(racine_projet, "iramuteq-like", "chd_iramuteq_compat.R") else "",
+    if (!is.null(racine_projet) && nzchar(racine_projet)) file.path(racine_projet, "iramuteq-like", "chd_iramuteq.R") else "",
+    if (!is.null(racine_projet) && nzchar(racine_projet)) file.path(racine_projet, "R", "chd_iramuteq.R") else "",
+    file.path(".", "iramuteq-like", "chd_iramuteq_compat.R"),
+    file.path(".", "iramuteq-like", "chd_iramuteq.R"),
+    file.path(".", "R", "chd_iramuteq.R"),
+    file.path(getwd(), "iramuteq-like", "chd_iramuteq_compat.R"),
+    file.path(getwd(), "iramuteq-like", "chd_iramuteq.R"),
+    file.path(getwd(), "R", "chd_iramuteq.R")
+  ))
+  candidats <- candidats[!is.na(candidats) & nzchar(candidats)]
+
+  for (cand in candidats) {
+    if (file.exists(cand)) {
+      source(cand, encoding = "UTF-8", local = env)
+      fn <- get0(nom_fonction, mode = "function", inherits = TRUE)
+      if (!is.null(fn)) return(fn)
+    }
+  }
+
+  stop(
+    "Moteur CHD IRaMuTeQ-like indisponible: ", nom_fonction,
+    "() introuvable. Module recherché dans: ",
+    paste(candidats, collapse = ", "),
+    "."
+  )
+}
+
+lancer_moteur_chd_iramuteq <- function(
+  dfm_obj,
+  k,
+  mincl_mode = c("auto", "manuel"),
+  mincl = 0,
+  classif_mode = c("simple", "double"),
+  svd_method = c("irlba", "svdR"),
+  mode_patate = FALSE,
+  libsvdc_path = NULL,
+  binariser = TRUE,
+  rscripts_dir = NULL
+) {
+  mincl_mode <- match.arg(mincl_mode)
+  classif_mode <- match.arg(classif_mode)
+  svd_method <- match.arg(svd_method)
+
+  calculer_chd_iramuteq_fn <- .obtenir_fonction_iramuteq("calculer_chd_iramuteq", env = environment())
+  reconstruire_classes_terminales_iramuteq_fn <- .obtenir_fonction_iramuteq("reconstruire_classes_terminales_iramuteq", env = environment())
+
+  chd_obj <- calculer_chd_iramuteq_fn(
+    dfm_obj = dfm_obj,
+    k = k,
+    mode_patate = mode_patate,
+    svd_method = svd_method,
+    libsvdc_path = libsvdc_path,
+    binariser = binariser,
+    rscripts_dir = rscripts_dir
+  )
+
+  classes_obj <- reconstruire_classes_terminales_iramuteq_fn(
+    chd_obj = chd_obj,
+    mincl = mincl,
+    mincl_mode = mincl_mode,
+    classif_mode = classif_mode,
+    nb_classes_cible = NULL,
+    respecter_nb_classes = FALSE
+  )
+
+  list(
+    engine = "iramuteq-like",
+    chd = chd_obj,
+    classes = classes_obj$classes,
+    terminales = classes_obj$terminales,
+    mincl = classes_obj$mincl
+  )
+}

iramuteq-like/chd_iramuteq.R

@@ -0,0 +1,892 @@
+# Rôle du fichier: chd_iramuteq.R introduit une base "IRaMuTeQ-like" pour la CHD.
+# Ce module prépare les entrées de CHD en respectant les options de nettoyage de l'application,
+# expose des utilitaires pour le calcul de mincl (convention IRaMuTeQ texte),
+# et fournit un calcul CHD réel en s'appuyant sur les scripts R historiques d'IRaMuTeQ.
+
+# Valeur mincl automatique (mode texte IRaMuTeQ):
+# mincl = round(n_uce / ind), avec ind = nbcl * 2 (double) sinon nbcl.
+calculer_mincl_auto_iramuteq <- function(n_uce, nbcl, classif_mode = c("double", "simple")) {
+  classif_mode <- match.arg(classif_mode)
+  n_uce <- as.integer(n_uce)
+  nbcl <- as.integer(nbcl)
+
+  if (!is.finite(n_uce) || is.na(n_uce) || n_uce < 1) {
+    stop("mincl auto IRaMuTeQ: n_uce invalide.")
+  }
+  if (!is.finite(nbcl) || is.na(nbcl) || nbcl < 1) {
+    stop("mincl auto IRaMuTeQ: nbcl invalide.")
+  }
+
+  ind <- if (identical(classif_mode, "double")) nbcl * 2L else nbcl
+  mincl <- round(n_uce / ind)
+  as.integer(max(1L, mincl))
+}
+
+# Normalise une liste d'options de nettoyage selon les clés utilisées dans l'UI.
+normaliser_options_nettoyage_iramuteq <- function(options_nettoyage = list()) {
+  opts <- list(
+    nettoyage_caracteres = isTRUE(options_nettoyage$nettoyage_caracteres),
+    forcer_minuscules_avant = isTRUE(options_nettoyage$forcer_minuscules_avant),
+    supprimer_chiffres = isTRUE(options_nettoyage$supprimer_chiffres),
+    supprimer_apostrophes = isTRUE(options_nettoyage$supprimer_apostrophes),
+    supprimer_ponctuation = isTRUE(options_nettoyage$supprimer_ponctuation),
+    retirer_stopwords = isTRUE(options_nettoyage$retirer_stopwords)
+  )
+  opts
+}
+
+# Prépare textes/tokens/dfm en tenant compte des options de nettoyage existantes de l'application.
+preparer_entrees_chd_iramuteq <- function(
+  textes,
+  langue = "fr",
+  options_nettoyage = list(),
+  appliquer_nettoyage_fun = NULL
+) {
+  if (!is.character(textes)) {
+    textes <- as.character(textes)
+  }
+  textes[is.na(textes)] <- ""
+
+  opts <- normaliser_options_nettoyage_iramuteq(options_nettoyage)
+
+  if (is.null(appliquer_nettoyage_fun)) {
+    if (exists("appliquer_nettoyage_et_minuscules", mode = "function", inherits = TRUE)) {
+      appliquer_nettoyage_fun <- get("appliquer_nettoyage_et_minuscules", mode = "function", inherits = TRUE)
+    } else {
+    op <- par(no.readonly = TRUE)
+    on.exit(par(op), add = TRUE)
+    par(mar = c(3.0, 2.6, 3.4, 8.5))
+
+      appliquer_nettoyage_fun <- function(textes,
+                                          activer_nettoyage = FALSE,
+                                          forcer_minuscules = FALSE,
+                                          supprimer_chiffres = FALSE,
+                                          supprimer_apostrophes = FALSE) {
+        x <- as.character(textes)
+        if (isTRUE(forcer_minuscules)) x <- tolower(x)
+        x
+      }
+    }
+  }
+
+  textes_prep <- appliquer_nettoyage_fun(
+    textes = textes,
+    activer_nettoyage = opts$nettoyage_caracteres,
+    forcer_minuscules = opts$forcer_minuscules_avant,
+    supprimer_chiffres = opts$supprimer_chiffres,
+    supprimer_apostrophes = opts$supprimer_apostrophes
+  )
+
+  if (!requireNamespace("quanteda", quietly = TRUE)) {
+    stop("CHD IRaMuTeQ-like: package quanteda requis pour préparer les entrées.")
+  }
+
+  tok <- quanteda::tokens(
+    textes_prep,
+    remove_punct = opts$supprimer_ponctuation,
+    remove_numbers = opts$supprimer_chiffres
+  )
+
+  if (opts$retirer_stopwords) {
+    sw <- quanteda::stopwords(language = langue)
+    tok <- quanteda::tokens_remove(tok, pattern = sw)
+  }
+
+  dfm_obj <- quanteda::dfm(tok)
+  list(textes = textes_prep, tok = tok, dfm = dfm_obj, options = opts)
+}
+
+.trouver_fichier_insensible_casse <- function(dir_path, filename) {
+  if (!dir.exists(dir_path)) return(NA_character_)
+  files <- list.files(dir_path, full.names = TRUE)
+  if (length(files) == 0) return(NA_character_)
+  bn <- basename(files)
+  idx <- which(tolower(bn) == tolower(filename))
+  if (length(idx) == 0) return(NA_character_)
+  files[idx[1]]
+}
+
+.trouver_rscripts_iramuteq <- function(base_dir = NULL) {
+  scripts <- c("anacor.R", "CHD.R", "chdtxt.R")
+    candidats <- unique(c(
+    base_dir,
+    "iramuteq-like",
+    "iramuteq-like/Rscripts",
+    "iramuteq_clone_v3/Rscripts"
+  ))
+  candidats <- candidats[!is.na(candidats) & nzchar(candidats)]
+
+  for (cand in candidats) {
+    paths <- vapply(scripts, function(sc) .trouver_fichier_insensible_casse(cand, sc), FUN.VALUE = character(1))
+    if (all(!is.na(paths))) {
+      return(unname(paths))
+    }
+  }
+
+  stop(
+    "CHD IRaMuTeQ-like: scripts R introuvables. Répertoires testés: ",
+    paste(candidats, collapse = ", "),
+    ". Fichiers attendus: ",
+    paste(scripts, collapse = ", "),
+    "."
+  )
+}
+
+.charger_scripts_iramuteq_chd <- function(base_dir = NULL) {
+  paths <- .trouver_rscripts_iramuteq(base_dir)
+  for (p in paths) {
+    source(p, encoding = "UTF-8", local = .GlobalEnv)
+  }
+  invisible(paths)
+}
+
+.normaliser_n1_chd <- function(n1) {
+  if (is.null(n1)) return(NULL)
+  if (is.data.frame(n1)) n1 <- as.matrix(n1)
+  if (is.vector(n1)) {
+    n1 <- matrix(as.integer(n1), ncol = 1)
+  }
+  if (!is.matrix(n1)) return(NULL)
+  if (nrow(n1) < 1 || ncol(n1) < 1) return(NULL)
+  n1
+}
+
+# Calcul CHD IRaMuTeQ-like (algorithme historique via scripts R IRaMuTeQ).
+calculer_chd_iramuteq <- function(
+  dfm_obj,
+  k = 3,
+  mode_patate = FALSE,
+  svd_method = c("irlba", "svdR"),
+  libsvdc_path = NULL,
+  binariser = TRUE,
+  rscripts_dir = NULL
+) {
+  svd_method <- match.arg(svd_method)
+
+  if (is.null(dfm_obj)) stop("CHD IRaMuTeQ-like: dfm_obj manquant.")
+  if (!is.finite(k) || is.na(k) || as.integer(k) < 2) stop("CHD IRaMuTeQ-like: k doit être >= 2.")
+
+  .charger_scripts_iramuteq_chd(rscripts_dir)
+
+  mat <- as.matrix(dfm_obj)
+  if (nrow(mat) < 2 || ncol(mat) < 2) {
+    stop("CHD IRaMuTeQ-like: matrice trop pauvre (>=2 lignes et >=2 colonnes requises).")
+  }
+
+  if (isTRUE(binariser)) {
+    mat <- ifelse(mat > 0, 1, 0)
+  }
+
+  rownames(mat) <- as.character(seq_len(nrow(mat)))
+
+  nb_tours <- as.integer(k) - 1L
+  if (nb_tours < 1) nb_tours <- 1L
+
+  chd <- CHD(
+    data.in = mat,
+    x = nb_tours,
+    mode.patate = isTRUE(mode_patate),
+    svd.method = svd_method,
+    libsvdc.path = libsvdc_path
+  )
+
+  n1 <- .normaliser_n1_chd(chd$n1)
+  if (is.null(n1) || nrow(n1) != nrow(mat)) {
+    stop("CHD IRaMuTeQ-like: sortie CHD invalide.")
+  }
+
+  chd$n1 <- n1
+
+  chd
+}
+
+# Reconstitue des classes finales depuis la sortie CHD et le principe find.terminales.
+reconstruire_classes_terminales_iramuteq <- function(
+  chd_obj,
+  mincl = 0,
+  mincl_mode = c("auto", "manuel"),
+  classif_mode = c("simple", "double"),
+  nb_classes_cible = NULL,
+  respecter_nb_classes = TRUE
+) {
+  mincl_mode <- match.arg(mincl_mode)
+  classif_mode <- match.arg(classif_mode)
+
+  n1 <- .normaliser_n1_chd(chd_obj$n1)
+  list_mere <- chd_obj$list_mere
+  list_fille <- chd_obj$list_fille
+
+  if (is.null(n1) || is.null(list_mere) || is.null(list_fille)) {
+    stop("CHD IRaMuTeQ-like: objet chd incomplet.")
+  }
+
+  nbcl <- length(unique(n1[, ncol(n1)]))
+  nbcl <- max(2L, as.integer(nbcl))
+
+  if (mincl_mode == "auto") {
+    mincl_use <- calculer_mincl_auto_iramuteq(
+      n_uce = nrow(n1),
+      nbcl = nbcl,
+      classif_mode = classif_mode
+    )
+  } else {
+    op <- par(no.readonly = TRUE)
+    on.exit(par(op), add = TRUE)
+    par(mar = c(3.0, 2.6, 3.4, 8.5))
+
+    mincl_use <- as.integer(mincl)
+    if (!is.finite(mincl_use) || is.na(mincl_use) || mincl_use < 1) mincl_use <- 1L
+  }
+
+  terminales <- find.terminales(n1, list_mere, list_fille, mincl = mincl_use)
+  if (is.character(terminales) && length(terminales) == 1 && terminales == "no clusters") {
+    stop("CHD IRaMuTeQ-like: aucune classe terminale retenue.")
+  }
+
+  feuilles <- unique(as.integer(n1[, ncol(n1)]))
+
+  if (isTRUE(respecter_nb_classes) && !is.null(nb_classes_cible) && is.finite(nb_classes_cible)) {
+    nb_classes_cible <- as.integer(nb_classes_cible)
+    if (nb_classes_cible >= 2 && length(feuilles) == nb_classes_cible && length(unique(terminales)) != nb_classes_cible) {
+      terminales <- sort(feuilles)
+      mincl_use <- 1L
+    }
+  }
+
+  classes_finales <- rep(0L, nrow(n1))
+  feuilles_docs <- suppressWarnings(as.integer(n1[, ncol(n1)]))
+
+  # Reproduction fidèle de iramuteq_clone_v3/Rscripts/chdtxt.R::make.classes
+  # (sans la partie manipulation du tree, non nécessaire au calcul des classes docs).
+  cl_names <- seq_along(terminales)
+  for (i in seq_along(terminales)) {
+    cl <- suppressWarnings(as.integer(terminales[[i]]))
+    if (!is.finite(cl)) next
+
+    if (cl %in% feuilles) {
+      classes_finales[which(feuilles_docs == cl)] <- cl_names[[i]]
+    } else {
+    op <- par(no.readonly = TRUE)
+    on.exit(par(op), add = TRUE)
+    par(mar = c(3.0, 2.6, 3.4, 8.5))
+
+      filles <- suppressWarnings(as.integer(getfille(list_fille, cl, NULL)))
+      tochange <- intersect(filles, feuilles)
+      for (cl_fille in tochange) {
+        classes_finales[which(feuilles_docs == cl_fille)] <- cl_names[[i]]
+      }
+    }
+  }
+
+  classes_finales[which(is.na(classes_finales))] <- 0L
+  list(
+    classes = classes_finales,
+    terminales = as.integer(terminales),
+    mincl = mincl_use
+  )
+}
+
+# Calcule une table de statistiques par classe dans l'esprit des sorties IRaMuTeQ.
+construire_stats_classes_iramuteq <- function(dfm_obj, classes, max_p = 1) {
+  if (is.null(dfm_obj)) stop("Stats IRaMuTeQ-like: dfm_obj manquant.")
+  if (is.null(classes)) stop("Stats IRaMuTeQ-like: classes manquantes.")
+
+  mat <- as.matrix(dfm_obj)
+  if (nrow(mat) != length(classes)) {
+    stop("Stats IRaMuTeQ-like: longueur de classes incohérente avec le DFM.")
+  }
+
+  classes <- as.integer(classes)
+  # Alignement IRaMuTeQ clone (BuildProf/chdfunct.R):
+  # les UCE non classées (classe 0) sont exclues du comptage
+  # des effectifs et des tableaux de contingence.
+  ok_docs <- !is.na(classes) & classes > 0L
+  mat <- mat[ok_docs, , drop = FALSE]
+  classes <- classes[ok_docs]
+
+  if (nrow(mat) < 2 || ncol(mat) < 1) return(data.frame())
+
+  # Alignement avec l'approche IRaMuTeQ historique (BuildProf):
+  # - contingence documentaire (présence/absence terme)
+  # - chi2 signé (sur/sous-représentation)
+  # - p-value issue de chisq.test(..., correct = FALSE)
+  mat_bin <- ifelse(mat > 0, 1L, 0L)
+  total_docs <- nrow(mat_bin)
+  docs_par_terme <- colSums(mat_bin)
+  occ_par_terme <- colSums(mat)
+
+  calc_chi_sign <- function(a, b, c, d) {
+    tb <- matrix(c(a, b, c, d), nrow = 2, byrow = TRUE)
+    chi <- suppressWarnings(stats::chisq.test(tb, correct = FALSE))
+    stat <- suppressWarnings(as.numeric(chi$statistic))
+    pval <- suppressWarnings(as.numeric(chi$p.value))
+    exp11 <- suppressWarnings(as.numeric(chi$expected[1, 1]))
+
+    if (!is.finite(stat) || is.na(stat)) stat <- 0
+    if (!is.finite(pval) || is.na(pval)) pval <- 1
+    if (!is.finite(exp11) || is.na(exp11)) exp11 <- a
+
+    signe <- if (a >= exp11) 1 else -1
+    c(chi2 = stat * signe, p = pval)
+  }
+
+  classes_uniques <- sort(unique(classes))
+  sorties <- vector("list", length(classes_uniques))
+
+  for (i in seq_along(classes_uniques)) {
+    cl <- classes_uniques[[i]]
+    in_cl <- classes == cl
+
+    docs_cl <- sum(in_cl)
+    if (docs_cl < 1) next
+
+    docs_terme_cl <- colSums(mat_bin[in_cl, , drop = FALSE])
+    docs_terme_hors <- pmax(0, docs_par_terme - docs_terme_cl)
+
+    n11 <- as.numeric(docs_terme_cl)
+    n12 <- as.numeric(docs_terme_hors)
+    n21 <- as.numeric(pmax(0, docs_cl - docs_terme_cl))
+    n22 <- as.numeric(pmax(0, (total_docs - docs_cl) - docs_terme_hors))
+
+    chi_p <- t(mapply(calc_chi_sign, n11, n12, n21, n22))
+
+    freq_cl <- colSums(mat[in_cl, , drop = FALSE])
+    docprop_cl <- if (docs_cl > 0) docs_terme_cl / docs_cl else rep(0, ncol(mat))
+    lr <- mapply(function(a, b, c, d) {
+      n <- a + b + c + d
+      r1 <- a + b
+      r2 <- c + d
+      c1 <- a + c
+      c2 <- b + d
+      expected <- c(r1 * c1 / n, r1 * c2 / n, r2 * c1 / n, r2 * c2 / n)
+      observed <- c(a, b, c, d)
+      idx <- observed > 0 & expected > 0
+      if (!any(idx)) return(0)
+      2 * sum(observed[idx] * log(observed[idx] / expected[idx]))
+    }, n11, n12, n21, n22)
+
+    df <- data.frame(
+      Terme = colnames(mat),
+      chi2 = as.numeric(chi_p[, "chi2"]),
+      lr = as.numeric(lr),
+      frequency = as.numeric(freq_cl),
+      docprop = as.numeric(docprop_cl),
+      # Alignement IRaMuTeQ: les colonnes d'effectifs affichées en table
+      # correspondent aux occurrences (et non au nombre de segments contenant le terme).
+      # Ex.: "23/46" signifie 23 occurrences dans la classe sur 46 occurrences au total.
+      eff_st = as.numeric(freq_cl),
+      eff_total = as.numeric(occ_par_terme),
+      pourcentage = as.numeric(ifelse(occ_par_terme > 0, 100 * freq_cl / occ_par_terme, 0)),
+      # Colonnes documentaires conservées pour diagnostic (chi2 calculé sur présence/absence doc).
+      eff_docs_st = as.numeric(docs_terme_cl),
+      eff_docs_total = as.numeric(docs_par_terme),
+      p = as.numeric(chi_p[, "p"]),
+      Classe = as.integer(cl),
+      stringsAsFactors = FALSE
+    )
+
+    df <- df[is.finite(df$chi2) & !is.na(df$chi2), , drop = FALSE]
+    if (is.finite(max_p) && !is.na(max_p) && max_p < 1) {
+      df <- df[df$p <= max_p, , drop = FALSE]
+    }
+    df <- df[order(-df$chi2, -df$frequency, -occ_par_terme[df$Terme]), , drop = FALSE]
+    sorties[[i]] <- df
+  }
+
+  out <- dplyr::bind_rows(sorties)
+  if (!nrow(out)) return(out)
+
+  out$Classe_brut <- as.character(out$Classe)
+  out$p_value <- out$p
+  out$p_value_filter <- ifelse(out$p <= max_p, paste0("≤ ", max_p), paste0("> ", max_p))
+  out
+}
+
+# Dendrogramme CHD basé sur la structure hiérarchique IRaMuTeQ (list_mere/list_fille).
+tracer_dendrogramme_chd_iramuteq <- function(chd_obj,
+                                              terminales = NULL,
+                                              classes = NULL,
+                                              res_stats_df = NULL,
+                                              top_n_terms = 4,
+                                              orientation = c("vertical", "horizontal"),
+                                              display_method = c("standard", "compact", "iramuteq_blocks")) {
+  orientation <- match.arg(orientation)
+  display_method <- match.arg(display_method)
+
+  if (is.null(chd_obj)) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  n1 <- .normaliser_n1_chd(chd_obj$n1)
+  if (is.null(chd_obj$list_fille) || is.null(n1)) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  list_fille <- chd_obj$list_fille
+  if (!is.list(list_fille) || length(list_fille) == 0) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible (list_fille vide).", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  noms <- names(list_fille)
+  if (is.null(noms) || any(!nzchar(noms))) noms <- as.character(seq_along(list_fille))
+  map_filles <- stats::setNames(lapply(list_fille, function(x) as.integer(x)), noms)
+
+  meres <- suppressWarnings(as.integer(names(map_filles)))
+  meres <- meres[is.finite(meres)]
+  enfants <- unique(as.integer(unlist(map_filles, use.names = FALSE)))
+  enfants <- enfants[is.finite(enfants)]
+
+  racines <- setdiff(meres, enfants)
+  racine <- if (length(racines)) racines[[1]] else if (length(meres)) meres[[1]] else NA_integer_
+  if (!is.finite(racine)) {
+    feuilles_n1 <- suppressWarnings(as.integer(n1[, ncol(n1)]))
+    feuilles_n1 <- feuilles_n1[is.finite(feuilles_n1)]
+    if (length(feuilles_n1)) racine <- min(feuilles_n1, na.rm = TRUE)
+  }
+
+  if (!is.finite(racine)) {
+    plot.new()
+    text(0.5, 0.5, "Structure CHD invalide.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  get_filles <- function(node) {
+    key <- as.character(node)
+    x <- map_filles[[key]]
+    x <- x[is.finite(x)]
+    if (is.null(x)) integer(0) else as.integer(x)
+  }
+
+  terminales <- suppressWarnings(as.integer(terminales))
+  terminales <- terminales[is.finite(terminales)]
+  terminales <- unique(terminales)
+
+  # Source de vérité pour le nombre de classes à afficher :
+  # 1) résultats statistiques CHD (si disponibles), sinon
+  # 2) vecteur des classes finales documentaires.
+  # Comme dans iramuteq_clone_v3 (cutree(..., k = clnb)), on borne l'affichage
+  # aux classes finales réellement exploitées.
+  classes_utiles <- integer(0)
+  if (!is.null(res_stats_df) && is.data.frame(res_stats_df) && "Classe" %in% names(res_stats_df)) {
+    classes_stats <- suppressWarnings(as.integer(res_stats_df$Classe))
+    classes_stats <- classes_stats[is.finite(classes_stats) & classes_stats > 0]
+    classes_utiles <- sort(unique(classes_stats))
+  }
+
+  if (!length(classes_utiles) && !is.null(classes)) {
+    classes_int <- suppressWarnings(as.integer(classes))
+    classes_int <- classes_int[is.finite(classes_int) & classes_int > 0]
+    classes_utiles <- sort(unique(classes_int))
+  }
+
+  if (length(classes_utiles) && length(terminales)) {
+    idx_valides <- classes_utiles[classes_utiles >= 1L & classes_utiles <= length(terminales)]
+    terminales <- terminales[idx_valides]
+    classes_utiles <- idx_valides
+  }
+
+  utiliser_terminales <- length(terminales) > 0
+
+  leaves <- integer(0)
+  visited <- integer(0)
+  walk_leaves <- function(node) {
+    if (node %in% visited) return(invisible(NULL))
+    visited <<- c(visited, node)
+
+    if (isTRUE(utiliser_terminales) && node %in% terminales) {
+      leaves <<- c(leaves, node)
+      return(invisible(NULL))
+    }
+
+    filles <- get_filles(node)
+    if (!length(filles)) {
+      if (!isTRUE(utiliser_terminales)) {
+        leaves <<- c(leaves, node)
+      }
+      return(invisible(NULL))
+    }
+    for (f in filles) walk_leaves(f)
+  }
+  walk_leaves(racine)
+
+  if (isTRUE(utiliser_terminales)) {
+    terminales_atteintes <- intersect(unique(terminales), unique(visited))
+    leaves <- unique(c(leaves, terminales_atteintes))
+  }
+
+  if (!length(leaves) && !length(classes_utiles)) {
+    leaves <- sort(unique(suppressWarnings(as.integer(n1[, ncol(n1)]))))
+    leaves <- leaves[is.finite(leaves)]
+  }
+  if (!length(leaves)) {
+    plot.new()
+    text(0.5, 0.5, "Aucune feuille exploitable pour le dendrogramme.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  leaves <- unique(leaves)
+  y_map <- stats::setNames(seq_along(leaves), as.character(leaves))
+  pos <- list()
+  seen <- integer(0)
+
+  layout_phylo <- function(node, depth = 0L) {
+    if (node %in% seen) return(pos[[as.character(node)]])
+    seen <<- c(seen, node)
+
+    if (isTRUE(utiliser_terminales) && node %in% leaves) {
+      y <- unname(y_map[[as.character(node)]])
+      if (is.null(y) || !is.finite(y)) y <- max(unname(y_map)) + 1
+      pos[[as.character(node)]] <<- c(x = depth, y = y)
+      return(pos[[as.character(node)]])
+    }
+
+    filles <- get_filles(node)
+    if (!length(filles)) {
+      y <- unname(y_map[[as.character(node)]])
+      if (is.null(y) || !is.finite(y)) y <- max(unname(y_map)) + 1
+      pos[[as.character(node)]] <<- c(x = depth, y = y)
+      return(pos[[as.character(node)]])
+    }
+
+    child_pos <- lapply(filles, function(f) layout_phylo(f, depth + 1L))
+    ys <- vapply(child_pos, function(v) as.numeric(v[["y"]]), numeric(1))
+    pos[[as.character(node)]] <<- c(x = depth, y = mean(ys))
+    return(pos[[as.character(node)]])
+  }
+
+  layout_phylo(racine, 0L)
+
+  if (!length(pos)) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible (positions vides).", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  all_pos <- do.call(rbind, pos)
+  if (is.null(dim(all_pos))) {
+    all_pos <- matrix(all_pos, nrow = 1L, dimnames = list(names(pos)[1], names(all_pos)))
+  }
+  all_pos <- as.matrix(all_pos)
+  if (is.null(colnames(all_pos)) || !all(c("x", "y") %in% colnames(all_pos))) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible (positions invalides).", cex = 1.1)
+    return(invisible(NULL))
+  }
+  depth_max <- max(all_pos[, "x"], na.rm = TRUE)
+  order_max <- max(all_pos[, "y"], na.rm = TRUE)
+
+  node_ids <- suppressWarnings(as.integer(rownames(all_pos)))
+  node_ids[!is.finite(node_ids)] <- NA_integer_
+  tip_idx <- which(node_ids %in% leaves)
+
+  tip_cols <- rep("#5B8FF9", nrow(all_pos))
+  if (length(terminales)) tip_cols[which(node_ids %in% terminales)] <- "#d62728"
+
+  tip_labels <- paste0("Classe ", rownames(all_pos)[tip_idx])
+  tip_nodes_chr <- rownames(all_pos)[tip_idx]
+  classe_par_noeud <- stats::setNames(rep(NA_integer_, length(tip_nodes_chr)), tip_nodes_chr)
+
+  if (length(terminales)) {
+    for (i in seq_along(terminales)) {
+      node <- terminales[[i]]
+      idx_node <- which(tip_nodes_chr == as.character(node))
+      if (!length(idx_node)) next
+      tip_labels[idx_node] <- paste0("Classe ", i)
+      classe_par_noeud[as.character(node)] <- i
+    }
+  }
+
+  if (!is.null(classes)) {
+    classes <- suppressWarnings(as.integer(classes))
+    classes <- classes[is.finite(classes) & classes > 0]
+    if (length(classes) && length(terminales)) {
+      pct_par_classe <- prop.table(table(classes)) * 100
+      for (i in seq_along(terminales)) {
+        node <- terminales[[i]]
+        idx_node <- which(tip_nodes_chr == as.character(node))
+        if (!length(idx_node)) next
+        pct <- unname(pct_par_classe[as.character(i)])
+        if (!is.finite(pct) || is.na(pct)) pct <- 0
+        tip_labels[idx_node] <- paste0("Classe ", i, " (", format(round(pct, 1), nsmall = 1), " %)")
+      }
+    }
+  }
+
+  top_n_terms <- suppressWarnings(as.integer(top_n_terms))
+  if (!is.finite(top_n_terms) || is.na(top_n_terms) || top_n_terms < 1L) top_n_terms <- 1L
+  termes_par_classe <- list()
+  if (!is.null(res_stats_df) && is.data.frame(res_stats_df) && nrow(res_stats_df) > 0 && all(c("Classe", "Terme") %in% names(res_stats_df))) {
+    df_terms <- res_stats_df
+    classes_num <- suppressWarnings(as.integer(df_terms$Classe))
+    df_terms <- df_terms[is.finite(classes_num) & !is.na(df_terms$Terme) & nzchar(as.character(df_terms$Terme)), , drop = FALSE]
+    df_terms$Classe <- suppressWarnings(as.integer(df_terms$Classe))
+
+    for (i in seq_along(terminales)) {
+      sous <- df_terms[df_terms$Classe == i, , drop = FALSE]
+      if (!nrow(sous)) next
+      if ("chi2" %in% names(sous)) {
+        chi <- suppressWarnings(as.numeric(sous$chi2))
+        chi[!is.finite(chi)] <- -Inf
+        sous <- sous[order(chi, decreasing = TRUE), , drop = FALSE]
+      }
+      termes <- unique(as.character(sous$Terme))
+      termes <- termes[nzchar(termes)]
+      if (length(termes)) {
+        termes_par_classe[[as.character(i)]] <- paste(utils::head(termes, top_n_terms), collapse = ", ")
+      }
+    }
+  }
+
+  if (identical(orientation, "vertical")) {
+    if (identical(display_method, "iramuteq_blocks")) {
+      op <- par(no.readonly = TRUE)
+      on.exit(par(op), add = TRUE)
+      par(mar = c(1.4, 1.4, 2.6, 1.4), xpd = NA)
+
+      class_ids <- sort(unique(na.omit(as.integer(classe_par_noeud))))
+      if (!length(class_ids) && length(terminales)) class_ids <- seq_along(terminales)
+      if (!length(class_ids)) {
+        plot.new()
+        text(0.5, 0.5, "Aucune classe terminale disponible.", cex = 1.1)
+        return(invisible(NULL))
+      }
+
+      cols_palette <- c("#ff3300", "#00ff00", "#1f3bff", "#ff00a8", "#00d4ff", "#ffaa00")
+      class_cols <- stats::setNames(cols_palette[(seq_along(class_ids) - 1L) %% length(cols_palette) + 1L], as.character(class_ids))
+
+      pct_par_classe <- NULL
+      if (!is.null(classes)) {
+        classes <- suppressWarnings(as.integer(classes))
+        classes <- classes[is.finite(classes) & classes > 0]
+        if (length(classes)) pct_par_classe <- prop.table(table(classes)) * 100
+      }
+
+      order_nodes <- tip_nodes_chr
+      if (!length(order_nodes) && length(terminales)) order_nodes <- as.character(terminales)
+      classes_ord <- suppressWarnings(as.integer(classe_par_noeud[order_nodes]))
+      keep <- is.finite(classes_ord)
+      order_nodes <- order_nodes[keep]
+      classes_ord <- classes_ord[keep]
+      if (!length(classes_ord)) classes_ord <- class_ids
+
+      n <- length(classes_ord)
+      x_pos <- seq(0.12, 0.88, length.out = n)
+
+      plot.new()
+      plot.window(xlim = c(0, 1), ylim = c(0, 1))
+
+      y_top <- 0.90
+      y_box_top <- 0.78
+      y_box_bot <- 0.64
+      box_w <- min(0.28, if (n > 1) 0.72 / (n - 1) else 0.3)
+
+      if (n >= 2) {
+        mid <- mean(x_pos)
+        segments(mid, y_top, min(x_pos), y_box_top + 0.02, lwd = 2.5, col = "#111111")
+        segments(mid, y_top, max(x_pos), y_box_top + 0.02, lwd = 2.5, col = "#111111")
+      }
+
+      for (i in seq_len(n)) {
+        cl <- classes_ord[i]
+        col_cl <- unname(class_cols[as.character(cl)])
+        if (is.na(col_cl) || !nzchar(col_cl)) col_cl <- "#1f3bff"
+        x <- x_pos[i]
+
+        rect(x - box_w / 2, y_box_bot, x + box_w / 2, y_box_top, col = col_cl, border = NA)
+        segments(x, y_box_top + 0.02, x, y_box_top, lwd = 2.5, col = "#111111")
+
+        text(x, y_box_top + 0.05, labels = paste0("classe ", cl), col = col_cl, cex = 1.2, font = 2)
+        pct <- if (!is.null(pct_par_classe)) unname(pct_par_classe[as.character(cl)]) else NA_real_
+        pct_lbl <- if (is.finite(pct)) paste0(format(round(pct, 1), trim = TRUE), " %") else ""
+        if (nzchar(pct_lbl)) text(x, y_box_bot + 0.015, labels = pct_lbl, cex = 0.9, col = "#111111")
+
+        termes <- character(0)
+        if (!is.null(termes_par_classe[[as.character(cl)]])) {
+          termes <- strsplit(termes_par_classe[[as.character(cl)]], "\\s*,\\s*")[[1]]
+          termes <- termes[nzchar(termes)]
+        }
+
+        if (length(termes)) {
+          y0 <- 0.58
+          step <- 0.055
+          for (j in seq_len(min(length(termes), 9L))) {
+            text(x - box_w / 2, y0 - (j - 1) * step, labels = termes[j], adj = c(0, 1), col = col_cl, cex = 1.6, font = 2)
+          }
+        }
+      }
+
+      title(main = "Dendrogramme CHD IRaMuTeQ-like (style IRaMuTeQ)")
+      return(invisible(NULL))
+    }
+
+    op <- par(no.readonly = TRUE)
+    on.exit(par(op), add = TRUE)
+    par(mar = c(3.2, 2.8, 3.6, 1.5))
+
+    all_pos_plot <- cbind(x = all_pos[, "y", drop = TRUE], y = depth_max - all_pos[, "x", drop = TRUE])
+    all_pos_plot <- as.matrix(all_pos_plot)
+    x_max <- max(all_pos_plot[, "x"], na.rm = TRUE)
+    y_max <- max(all_pos_plot[, "y"], na.rm = TRUE)
+
+    plot(
+      NA,
+      xlim = c(0.5, x_max + 0.5),
+      ylim = c(if (length(termes_par_classe) && identical(display_method, "standard")) -1.6 else -0.8, y_max + 0.8),
+      axes = FALSE,
+      xlab = "",
+      ylab = "",
+      main = if (identical(display_method, "compact")) "Dendrogramme CHD IRaMuTeQ-like (compact)" else "Dendrogramme CHD IRaMuTeQ-like"
+    )
+
+    for (mere_name in names(map_filles)) {
+      mere <- suppressWarnings(as.integer(mere_name))
+      if (!is.finite(mere)) next
+      p_m <- pos[[as.character(mere)]]
+      if (is.null(p_m)) next
+      p_m_plot <- c(x = p_m[["y"]], y = depth_max - p_m[["x"]])
+
+      filles <- as.integer(map_filles[[mere_name]])
+      filles <- filles[is.finite(filles)]
+      if (!length(filles)) next
+
+      x_child <- numeric(0)
+      for (f in filles) {
+        p_f <- pos[[as.character(f)]]
+        if (!is.null(p_f)) x_child <- c(x_child, p_f[["y"]])
+      }
+      if (length(x_child) >= 2) {
+        segments(min(x_child), p_m_plot[["y"]], max(x_child), p_m_plot[["y"]], col = "#2f4f4f", lwd = 1.6)
+      }
+
+      for (f in filles) {
+        p_f <- pos[[as.character(f)]]
+        if (is.null(p_f)) next
+        p_f_plot <- c(x = p_f[["y"]], y = depth_max - p_f[["x"]])
+        segments(p_f_plot[["x"]], p_m_plot[["y"]], p_f_plot[["x"]], p_f_plot[["y"]], col = "#2f4f4f", lwd = 1.6)
+      }
+    }
+
+    if (length(tip_idx)) {
+      points(all_pos_plot[tip_idx, "x", drop = TRUE], all_pos_plot[tip_idx, "y", drop = TRUE], pch = 19, col = tip_cols[tip_idx], cex = 0.95)
+      text(x = all_pos_plot[tip_idx, "x", drop = TRUE], y = all_pos_plot[tip_idx, "y", drop = TRUE] - 0.18, labels = tip_labels, adj = c(0.5, 1), cex = 0.78)
+
+      if (length(termes_par_classe) && identical(display_method, "standard")) {
+        for (j in seq_along(tip_idx)) {
+          node_id <- tip_nodes_chr[j]
+          class_id <- suppressWarnings(as.integer(classe_par_noeud[[node_id]]))
+          if (!is.finite(class_id)) next
+          termes_lbl <- termes_par_classe[[as.character(class_id)]]
+          if (is.null(termes_lbl) || !nzchar(termes_lbl)) next
+          text(
+            x = all_pos_plot[tip_idx[j], "x", drop = TRUE],
+            y = all_pos_plot[tip_idx[j], "y", drop = TRUE] - 0.56,
+            labels = termes_lbl,
+            adj = c(0.5, 1),
+            cex = 0.66,
+            col = "#333333"
+          )
+        }
+      }
+
+      if (length(termes_par_classe) && identical(display_method, "compact")) {
+        legend_lines <- unlist(lapply(sort(names(termes_par_classe)), function(cl_id) {
+          paste0("Classe ", cl_id, " : ", termes_par_classe[[cl_id]])
+        }), use.names = FALSE)
+
+        if (length(legend_lines)) {
+          texte_legend <- paste(legend_lines, collapse = "\n")
+          mtext(texte_legend, side = 1, line = 0.4, adj = 0, cex = 0.62, col = "#333333")
+        }
+      }
+    }
+  } else {
+    op <- par(no.readonly = TRUE)
+    on.exit(par(op), add = TRUE)
+    par(mar = c(3.0, 2.6, 3.4, 8.5))
+
+    plot(
+      NA,
+      xlim = c(-0.2, depth_max + 1.4),
+      ylim = c(order_max + 0.6, 0.4),
+      axes = FALSE,
+      xlab = "",
+      ylab = "",
+      main = if (identical(display_method, "compact")) "Dendrogramme CHD IRaMuTeQ-like (phylogramme compact)" else "Dendrogramme CHD IRaMuTeQ-like (phylogramme)"
+    )
+
+    for (mere_name in names(map_filles)) {
+      mere <- suppressWarnings(as.integer(mere_name))
+      if (!is.finite(mere)) next
+      p_m <- pos[[as.character(mere)]]
+      if (is.null(p_m)) next
+
+      filles <- as.integer(map_filles[[mere_name]])
+      filles <- filles[is.finite(filles)]
+      if (!length(filles)) next
+
+      y_child <- numeric(0)
+      for (f in filles) {
+        p_f <- pos[[as.character(f)]]
+        if (!is.null(p_f)) y_child <- c(y_child, p_f[["y"]])
+      }
+      if (length(y_child) >= 2) {
+        segments(p_m[["x"]], min(y_child), p_m[["x"]], max(y_child), col = "#2f4f4f", lwd = 1.6)
+      }
+
+      for (f in filles) {
+        p_f <- pos[[as.character(f)]]
+        if (is.null(p_f)) next
+        segments(p_m[["x"]], p_f[["y"]], p_f[["x"]], p_f[["y"]], col = "#2f4f4f", lwd = 1.6)
+      }
+    }
+
+    if (length(tip_idx)) {
+      points(all_pos[tip_idx, "x", drop = TRUE], all_pos[tip_idx, "y", drop = TRUE], pch = 19, col = tip_cols[tip_idx], cex = 0.95)
+      text(x = all_pos[tip_idx, "x", drop = TRUE] + 0.12, y = all_pos[tip_idx, "y", drop = TRUE], labels = tip_labels, adj = c(0, 0.5), cex = 0.78)
+
+      if (length(termes_par_classe) && identical(display_method, "standard")) {
+        for (j in seq_along(tip_idx)) {
+          node_id <- tip_nodes_chr[j]
+          class_id <- suppressWarnings(as.integer(classe_par_noeud[[node_id]]))
+          if (!is.finite(class_id)) next
+          termes_lbl <- termes_par_classe[[as.character(class_id)]]
+          if (is.null(termes_lbl) || !nzchar(termes_lbl)) next
+          text(
+            x = all_pos[tip_idx[j], "x", drop = TRUE] + 0.12,
+            y = all_pos[tip_idx[j], "y", drop = TRUE] + 0.28,
+            labels = termes_lbl,
+            adj = c(0, 0.5),
+            cex = 0.66,
+            col = "#333333"
+          )
+        }
+      }
+
+      if (length(termes_par_classe) && identical(display_method, "compact")) {
+        legend_lines <- unlist(lapply(sort(names(termes_par_classe)), function(cl_id) {
+          paste0("Classe ", cl_id, " : ", termes_par_classe[[cl_id]])
+        }), use.names = FALSE)
+
+        if (length(legend_lines)) {
+          legend(
+            "bottomright",
+            legend = legend_lines,
+            bty = "n",
+            cex = 0.64,
+            text.col = "#333333",
+            inset = c(-0.02, -0.02),
+            xpd = NA
+          )
+        }
+      }
+    }
+  }
+
+  invisible(NULL)
+}

iramuteq-like/chdtxt.R

@@ -0,0 +1,724 @@
+#Author: Pierre Ratinaud
+#Copyright (c) 2008-2020 Pierre Ratinaud
+#License: GNU/GPL
+
+
+#fonction pour la double classification
+#cette fonction doit etre splitter en 4 ou 5 fonctions
+
+AssignClasseToUce <- function(listuce, chd) {
+    print('assigne classe -> uce')
+    chd[listuce[,2]+1,]
+}
+
+fille<-function(classe,classeuce) {
+	listfm<-unique(unlist(classeuce[classeuce[,classe%/%2]==classe,]))
+	listf<-listfm[listfm>=classe]
+	listf<-unique(listf)
+	listf
+}
+
+
+croiseeff <- function(croise, classeuce1, classeuce2) {
+    cl1 <- 0
+    cl2 <- 1
+    for (i in 1:ncol(classeuce1)) {
+        cl1 <- cl1 + 2
+        cl2 <- cl2 + 2
+        clj1 <- 0
+        clj2 <- 1
+        for (j in 1:ncol(classeuce2)) {
+            clj1 <- clj1 + 2
+            clj2 <- clj2 + 2
+            croise[cl1 - 1, clj1 -1] <- length(which(classeuce1[,i] == cl1 & classeuce2[,j] == clj1))
+            croise[cl1 - 1, clj2 -1] <- length(which(classeuce1[,i] == cl1 & classeuce2[,j] == clj2))
+            croise[cl2 - 1, clj1 -1] <- length(which(classeuce1[,i] == cl2 & classeuce2[,j] == clj1))
+            croise[cl2 - 1, clj2 -1] <- length(which(classeuce1[,i] == cl2 & classeuce2[,j] == clj2))
+        }
+    }
+    croise
+}
+
+addallfille <- function(lf) {
+    nlf <- list()
+    for (i in 1:length(lf)) {
+        if (! is.null(lf[[i]])) {
+            nlf[[i]] <- lf[[i]]
+            filles <- lf[[i]]
+            f1 <- filles[1]
+            f2 <- filles[2]
+            if (f1 > length(lf)) {
+                for (j in (length(lf) + 1):f2) {
+                    nlf[[j]] <- 0
+                }
+            }
+        } else {
+            nlf[[i]] <- 0
+        }
+    }
+nlf
+}
+
+getfille <- function(nlf, classe, pf) {
+    if (!length(nlf[[classe]])) {
+        return(pf)
+    } else {
+		for (cl in nlf[[classe]]) {
+			pf <- c(pf, cl)
+			if (cl <= length(nlf)) {
+				pf <- getfille(nlf, cl, pf)
+			}
+		}
+	} 
+    return(pf)
+}
+
+getmere <- function(list_mere, classe) {
+    i <- as.numeric(classe)
+    pf <- NULL
+    while (i != 1 ) {
+        pf <- c(pf, list_mere[[i]])
+        i <- list_mere[[i]]
+    }
+    pf
+}
+
+getfillemere <- function(list_fille, list_mere, classe) {
+    return(c(getfille(list_fille, classe, NULL), getmere(list_mere, classe)))
+}
+
+getlength <- function(n1, clnb) {
+	colnb <- (clnb %/%2)
+	tab <- table(n1[,colnb])
+	eff <- tab[which(names(tab) == as.character(clnb))]
+	return(eff)
+}
+
+
+find.terminales <- function(n1, list_mere, list_fille, mincl) {
+	tab <- table(n1[,ncol(n1)])
+	clnames <- rownames(tab)
+	terminales <- clnames[which(tab >= mincl)]
+	tocheck <- setdiff(clnames, terminales)
+	if ("0" %in% terminales) {
+		terminales <- terminales[which(terminales != 0)]
+	}
+	if (length(terminales) == 0) {
+		return('no clusters')
+	}
+	if ("0" %in% tocheck) {
+		tocheck <- tocheck[which(tocheck != "0")]
+	}
+	print(terminales)
+	print(tocheck)
+	while (length(tocheck)!=0) {
+		for (val in tocheck) {
+			print(val)
+			mere <- list_mere[[as.numeric(val)]]
+			print('mere')
+			print(mere)
+			if (mere != 1) {
+				ln.mere <- getlength(n1, mere)
+				print('ln.mere')
+				print(ln.mere)
+				filles.mere <- getfille(list_fille, mere, NULL)
+				print('fille mere')
+				print(filles.mere)
+				filles.mere <- filles.mere[which(filles.mere != val)]
+				print(filles.mere)
+				if ((ln.mere >= mincl) & (length(intersect(filles.mere, tocheck)) == 0) & (length(intersect(filles.mere, terminales)) == 0 )) {
+					print('mere ok')
+					terminales <- c(terminales, mere)
+					for (f in c(filles.mere, val, mere)) {
+						tocheck <- tocheck[which(tocheck != f)]
+					}	
+				} else if ((ln.mere >= mincl) & (length(intersect(filles.mere, terminales)) == 0) & (length(intersect(filles.mere, tocheck))!=0)){
+					print('mere a checke cause fille ds tocheck')
+					tocheck <- tocheck[which(tocheck != val)]
+					tocheck <- c(mere, tocheck)
+
+				} else {
+					print('pas ok on vire du check')
+					tocheck <- tocheck[which(tocheck != val)]
+				}
+			} else {
+				print('mere == 1')
+				tocheck <- tocheck[which(tocheck != val)]
+			}
+			print('tocheck')
+			print(tocheck)
+		}
+		print(tocheck)
+	}
+	terminales
+}
+
+make.classes <- function(terminales, n1, tree, lf) {
+	term.n1 <- unique(n1[,ncol(n1)])
+	tree.tip <- tree$tip.label
+	cl.n1 <- n1[,ncol(n1)]
+	classes <- rep(NA, nrow(n1))
+	cl.names <- 1:length(terminales)
+	new.cl <- list()
+	for (i in 1:length(terminales)) {
+		if (terminales[i] %in% term.n1) {
+			classes[which(cl.n1==terminales[i])] <- cl.names[i]
+			new.cl[[terminales[i]]] <- cl.names[i]
+			tree.tip[which(tree.tip==terminales[i])] <- paste('a', cl.names[i], sep='')
+		} else {
+			filles <- getfille(lf, as.numeric(terminales[i]), NULL)
+			tochange <- intersect(filles, term.n1)
+			for (cl in tochange) {
+				classes[which(cl.n1==cl)] <- cl.names[i]
+				new.cl[[cl]] <- cl.names[i]
+				tree.tip[which(tree.tip==cl)] <- paste('a', cl.names[i], sep='')
+			}
+		}
+	}
+	make.tip <- function(x) {
+		if (substring(x,1,1)=='a') {
+			return(substring(x,2))
+		} else { 
+			return(0)
+		}
+	}
+	tree$tip.label <- tree.tip
+	ntree <- tree
+	tree$tip.label <- sapply(tree.tip, make.tip)
+	tovire <- sapply(tree.tip, function(x) {substring(x,1,1)!='a'})
+	tovire <- which(tovire)
+	ntree <-  drop.tip(ntree, tip=tovire)
+	en.double <- ntree$tip.label[duplicated(ntree$tip.label)]
+	en.double <- unique(en.double)
+	tovire <- sapply(en.double, function(x) {which(ntree$tip.label == x)[1]})
+	ntree <-  drop.tip(ntree, tip=tovire)
+	ntree$tip.label <- sapply(ntree$tip.label, function(x) {substring(x,2)})
+	classes[which(is.na(classes))] <- 0
+	res <- list(dendro_tot_cl = tree, tree.cl = ntree, n1=as.matrix(classes))
+	res
+}
+
+#nbt nbcl = nbt+1 tcl=((nbt+1) *2) - 2  n1[,ncol(n1)], nchd1[,ncol(nchd1)]
+Rchdtxt<-function(uceout, chd1, chd2 = NULL, mincl=0, classif_mode=0, nbt = 9) {
+	#FIXME: le nombre de classe peut etre inferieur
+    nbcl <- nbt + 1
+    tcl <- ((nbt+1) * 2) - 2
+    #Assignation des classes
+	classeuce1<-AssignClasseToUce(listuce1,chd1$n1)
+	if (classif_mode==0) {
+		classeuce2<-AssignClasseToUce(listuce2,chd2$n1)
+	}
+	#} else {
+	#	classeuce2<-classeuce1
+    #}
+
+	#calcul des poids (effectifs)
+
+    makepoids <- function(classeuce, poids) {
+        cl1 <- 0
+        cl2 <- 1
+        for (i in 1:nbt) {
+            cl1 <- cl1 + 2
+            cl2 <- cl2 + 2
+            poids[cl1 - 1] <- length(which(classeuce[,i] == cl1))
+            poids[cl2 - 1] <- length(which(classeuce[,i] == cl2))
+        }
+        poids
+    }
+
+#	makepoids<-function(classeuce,poids) {
+#	    for (classes in 2:(tcl + 1)){
+#		    for (i in 1:ncol(classeuce)) {
+#		        if (poids[(classes-1)]<length(classeuce[,i][classeuce[,i]==classes])) {
+#		            poids[(classes-1)]<-length(classeuce[,i][classeuce[,i]==classes])
+#		        }
+#		    }
+#	    }
+#	    poids
+#	}
+    print('make poids')
+	poids1<-vector(mode='integer',length = tcl)
+	poids1<-makepoids(classeuce1,poids1)
+	if (classif_mode==0) {
+		poids2<-vector(mode='integer',length = tcl)
+		poids2<-makepoids(classeuce2,poids2)
+	}# else {
+	#	poids2<-poids1
+	#}
+    
+    print('croisement classif')
+
+#    croise=matrix(ncol=tcl,nrow=tcl)
+#
+#    docroise <- function(croise, classeuce1, classeuce2) {
+#    	#production du tableau de contingence
+#    	for (i in 1:ncol(classeuce1)) {
+#    	    #poids[i]<-length(classeuce1[,i][x==classes])
+#    	    for (j in 1:ncol(classeuce2)) {
+#    		    tablecroise<-table(classeuce1[,i],classeuce2[,j])
+#    		    tabcolnames<-as.numeric(colnames(tablecroise))
+#    		    #tabcolnames<-c(tabcolnames[(length(tabcolnames)-1)],tabcolnames[length(tabcolnames)])
+#    		    tabrownames<-as.numeric(rownames(tablecroise))
+#    		    #tabrownames<-c(tabrownames[(length(tabrownames)-1)],tabrownames[length(tabrownames)])
+#    		    for (k in (ncol(tablecroise)-1):ncol(tablecroise)) {
+#    		        for (l in (nrow(tablecroise)-1):nrow(tablecroise)) {
+#    		            croise[(tabrownames[l]-1),(tabcolnames[k]-1)]<-tablecroise[l,k]
+#    		        }
+#    		    }
+#    	    }
+#    	}
+#        croise
+#    }
+	if (classif_mode==0) {
+    	croise <- croiseeff( matrix(ncol=tcl,nrow=tcl), classeuce1, classeuce2)
+	} else {
+		croise <- croiseeff( matrix(ncol=tcl,nrow=tcl), classeuce1, classeuce1)
+	}
+    #print(croise)
+    if (classif_mode == 0) {ind <- (nbcl * 2)} else {ind <- nbcl}
+	if (mincl==0){
+		mincl<-round(nrow(classeuce1)/ind)
+	}
+	#if (mincl<3){
+	#	mincl<-3
+	#}
+    print(mincl)	
+	#print('table1')
+	#print(croise)
+	#tableau des chi2 signes
+    print('croise chi2')
+	#chicroise<-croise
+
+#    nr <- nrow(classeuce1)
+#    newchicroise <- function(croise, mincl, nr, poids1, poids2) {
+#        chicroise <- croise
+#        chicroise[which(croise < mincl)] <- 0
+#        tocompute <- which(chicroise > 0, arr.ind = TRUE)
+#        for (i in 1:nrow(tocompute)) {
+#            chitable <- matrix(ncol=2,nrow=2)
+#            chitable[1,1] <- croise[tocompute[i,1],  tocompute[i,2]]
+#            chitable[1,2] <- poids1[tocompute[i,1]] - chitable[1,1]
+#            chitable[2,1] <- poids2[tocompute[i,2]] - chitable[1,1]
+#            chitable[2,2] <- nr - poids2[tocompute[i,2]] - chitable[1,2]
+#            chitest<-chisq.test(chitable,correct=FALSE)
+#            chicroise[tocompute[i,1],  tocompute[i,2]] <- ifelse(chitable[1,1] > chitest$expected[1,1], round(chitest$statistic,digits=7), -round(chitest$statistic,digits=7))
+#        }
+#        chicroise
+#    }
+#
+        
+
+	dochicroise <- function(croise, mincl) {
+        chicroise <- croise
+        for (i in 1:nrow(croise)) {
+	        for (j in 1:ncol(croise)) {
+	            if (croise[i,j]==0) {
+	                chicroise[i,j]<-0
+	            } else if (croise[i,j]<mincl) { 
+	                chicroise[i,j]<-0
+	            } else {
+	                chitable<-matrix(ncol=2,nrow=2)
+	                chitable[1,1]<-croise[i,j]
+	                chitable[1,2]<-poids1[i]-chitable[1,1]
+	                chitable[2,1]<-poids2[j]-chitable[1,1]
+	                chitable[2,2]<-nrow(classeuce1)-poids2[j]-chitable[1,2]
+	                chitest<-chisq.test(chitable,correct=FALSE)
+	                if ((chitable[1,1]-chitest$expected[1,1])<0) {
+	                    chicroise[i,j]<--round(chitest$statistic,digits=7)
+	                } else {
+	                    chicroise[i,j]<-round(chitest$statistic,digits=7)
+	        #print(chitest)
+	                }
+	            }
+	        }   
+	    }
+        chicroise
+    }
+
+	dochicroisesimple <- function(croise, mincl) {
+		chicroise <- croise
+		for (i in 1:nrow(croise)) {
+			for (j in 1:ncol(croise)) {
+				if (croise[i,j]==0) {
+					chicroise[i,j]<-0
+				} else if (croise[i,j]<mincl) { 
+					chicroise[i,j]<-0
+				} else {
+					chitable<-matrix(ncol=2,nrow=2)
+					chitable[1,1]<-croise[i,j]
+					chitable[1,2]<-poids1[i]-chitable[1,1]
+					chitable[2,1]<-poids1[j]-chitable[1,1]
+					chitable[2,2]<-nrow(classeuce1)-poids1[j]-chitable[1,2]
+					chitest<-chisq.test(chitable,correct=FALSE)
+					if ((chitable[1,1]-chitest$expected[1,1])<0) {
+						chicroise[i,j]<--round(chitest$statistic,digits=7)
+					} else {
+						chicroise[i,j]<-round(chitest$statistic,digits=7)
+						#print(chitest)
+					}
+				}
+			}   
+		}
+		chicroise
+	}
+	if (classif_mode == 0) {
+		chicroise <- dochicroise(croise, mincl)
+	} else {
+		chicroise <- dochicroisesimple(croise, mincl)
+	}
+    
+    print('fin croise')
+	#print(chicroise)
+	#determination des chi2 les plus fort
+	chicroiseori<-chicroise
+
+    doxy <- function(chicroise) {
+        listx <- NULL
+        listy <- NULL
+        listxy <- which(chicroise > 3.84, arr.ind = TRUE)
+        #print(listxy)
+        val <- chicroise[which(chicroise > 3.84)]
+        ord <- order(val, decreasing = TRUE)
+        listxy <- listxy[ord,]
+        #for (i in 1:nrow(listxy)) {
+        #    if ((!listxy[,2][i] %in% listx) & (!listxy[,1][i] %in% listy)) {
+        #        listx <- c(listx, listxy[,2][i])
+        #        listy <- c(listy, listxy[,1][i])
+        #    }
+        #}
+        xy <- list(x = listxy[,2], y = listxy[,1])
+        xy
+    }
+    xy <- doxy(chicroise)
+    listx <- xy$x
+    listy <- xy$y
+
+#	maxi<-vector()
+#	chimax<-vector()
+#	for (i in 1:tcl) {
+#	    maxi[i]<-which.max(chicroise)
+#	    chimax[i]<-chicroise[maxi[i]]
+#	    chicroise[maxi[i]]<-0
+#	}
+#	testpres<-function(x,listcoord) {
+#	    for (i in 1:length(listcoord)) {
+#		    if (x==listcoord[i]) {
+#		        return(-1)
+#		    } else {
+#		        a<-1
+#		    }
+#	    }
+#	    a
+#	}
+#	c.len=nrow(chicroise)
+#	r.len=ncol(chicroise)
+#	listx<-c(0)
+#	listy<-c(0)
+#	rang<-0
+#	cons<-list()
+#	#on garde une valeur par ligne / colonne
+#	for (i in 1:length(maxi)) {
+#	#coordonnées de chi2 max
+#        #coord <- arrayInd(maxi[i], dim(chicroise))
+#        #x.co <- coord[1,2]
+#        #y.co <- coord[1,1]
+#	    x.co<-ceiling(maxi[i]/c.len)
+#	    y.co<-maxi[i]-(x.co-1)*c.len
+#        #print(x.co)
+#        #print(y.co)
+#        #print(arrayInd(maxi[i], dim(chicroise)))
+#	    a<-testpres(x.co,listx)
+#	    b<-testpres(y.co,listy)
+#	    
+#	    if (a==1) {
+#			if (b==1) {
+#			    rang<-rang+1
+#			    listx[rang]<-x.co
+#			    listy[rang]<-y.co
+#			}
+#	    }
+#	    cons[[1]]<-listx
+#	    cons[[2]]<-listy
+#	}
+	#pour ecrire les resultats
+	for (i in 1:length(listx)) {
+	    txt<-paste(listx[i]+1,listy[i]+1,sep=' ')
+	    txt<-paste(txt,croise[listy[i],listx[i]],sep=' ')
+	    txt<-paste(txt,chicroiseori[listy[i],listx[i]],sep=' ')
+	    #print(txt)
+	}
+	#colonne de la classe
+	#trouver les filles et les meres 
+	trouvefillemere<-function(classe,chd) {
+	    unique(unlist(chd[chd[,classe%/%2]==classe,]))
+	}
+
+
+#----------------------------------------------------------------------
+    findbestcoord <- function(classeuce1, classeuce2, classif_mode, nbt) {
+        #fillemere1 <- NULL
+        #fillemere2 <- NULL
+
+        #fillemere1 <- unique(classeuce1)
+        #if (classif_mode == 0) {
+        #    fillemere2 <- unique(classeuce2)
+        #} else {
+        #    fillemere2 <- fillemere1
+        #}
+
+        #
+        listcoordok <- list()
+        maxcl <- 0
+        nb <- 0
+        lf1 <- addallfille(chd1$list_fille) 
+        if (classif_mode == 0) {
+            lf2 <- addallfille(chd2$list_fille)
+        } else {
+            lf2 <- lf1
+            listx<-listx[1:((nbt+1)*2)]
+            listy<-listy[1:((nbt+1)*2)]
+        }
+        lme1 <- chd1$list_mere
+        if (classif_mode == 0) {
+            lme2 <- chd2$list_mere
+        } else {
+            lme2 <- lme1
+        }
+        print('length listx')
+        print(length(listx))
+        #if (classif_mode == 0) {
+        for (first in 1:length(listx)) {
+            coordok <- NULL
+            f1 <- NULL
+            f2 <- NULL
+            listxp<-listx
+    	    listyp<-listy
+            
+    	    #listxp<-listx[first:length(listx)]
+    	    #listxp<-c(listxp,listx[1:(first-1)])
+    	    #listyp<-listy[first:length(listy)]
+    	    #listyp<-c(listyp,listy[1:(first-1)])
+            listxp <- listxp[order(listx, decreasing = TRUE)]
+            listyp <- listyp[order(listx, decreasing = TRUE)]
+            #listxp<-c(listxp[first:length(listx)], listx[1:(first-1)])
+            #listyp<-c(listyp[first:length(listy)], listy[1:(first-1)])
+            for (i in 1:length(listx)) {
+                if( (!(listxp[i]+1) %in% f1) & (!(listyp[i]+1) %in% f2) ) {
+                    #print(listyp[i]+1)
+                    #print('not in')
+                    #print(f2)
+                    coordok <- rbind(coordok, c(listyp[i] + 1,listxp[i] + 1))
+                    #print(c(listyp[i] + 1,listxp[i] + 1))
+                    un1 <- getfillemere(lf2, chd2$list_mere, listxp[i] + 1)
+                    f1 <- c(f1, un1)
+                    f1 <- c(f1, listxp[i] + 1)
+                    un2 <- getfillemere(lf1, chd1$list_mere, listyp[i] + 1)
+                    f2 <- c(f2, un2)
+                    f2 <- c(f2, listyp[i] + 1)
+                }
+                #print(coordok)
+            }
+            #if (nrow(coordok) > maxcl) {
+                nb <- 1
+            #    listcoordok <- list()
+                listcoordok[[nb]] <- coordok
+            #    maxcl <- nrow(coordok)
+            #} else if (nrow(coordok) == maxcl) {
+                nb <- nb + 1
+            #    listcoordok[[nb]] <- coordok
+            #}
+        }
+        #} else {
+#            stopid <- ((nbt+1) * 2) - 2
+#            for (first in 1:stopid) {
+#                coordok <- NULL
+#                f1 <- NULL
+#                f2 <- NULL
+#                listxp<-listx
+#                listyp<-listy
+#                
+#                #listxp<-listx[first:length(listx)]
+#                #listxp<-c(listxp,listx[1:(first-1)])
+#                #listyp<-listy[first:length(listy)]
+#                #listyp<-c(listyp,listy[1:(first-1)])
+#                listxp <- listxp[order(listx, decreasing = TRUE)]
+#                listyp <- listyp[order(listx, decreasing = TRUE)]
+#                #listxp<-c(listxp[first:length(listx)], listx[1:(first-1)])
+#                #listyp<-c(listyp[first:length(listy)], listy[1:(first-1)])
+#                for (i in 1:stopid) {
+#                    if( (!(listxp[i]+1) %in% f1) & (!(listyp[i]+1) %in% f2) ) {
+#                        #print(listyp[i]+1)
+#                        #print('not in')
+#                        #print(f2)
+#                        coordok <- rbind(coordok, c(listyp[i] + 1,listxp[i] + 1))
+#                        #print(c(listyp[i] + 1,listxp[i] + 1))
+#                        un1 <- getfillemere(lf2, chd2$list_mere, listxp[i] + 1)
+#                        f1 <- c(f1, un1)
+#                        f1 <- c(f1, listxp[i] + 1)
+#                        un2 <- getfillemere(lf1, chd1$list_mere, listyp[i] + 1)
+#                        f2 <- c(f2, un2)
+#                        f2 <- c(f2, listyp[i] + 1)
+#                    }
+#                    #print(coordok)
+#                }
+#                #if (nrow(coordok) > maxcl) {
+#                nb <- 1
+#                #    listcoordok <- list()
+#                listcoordok[[nb]] <- coordok
+#                #    maxcl <- nrow(coordok)
+#                #} else if (nrow(coordok) == maxcl) {
+#                nb <- nb + 1
+#                #    listcoordok[[nb]] <- coordok
+#                #}
+#            }            
+#        }
+        #print(listcoordok)
+        listcoordok <- unique(listcoordok)
+        print(listcoordok)
+        best <- 1
+        if (length(listcoordok) > 1) {
+            maxchi <- 0
+            for (i in 1:length(listcoordok)) {
+                chi <- NULL
+                uce <- NULL
+                for (j in 1:nrow(listcoordok[[i]])) {
+                    chi<-c(chi,chicroiseori[(listcoordok[[i]][j,1]-1),(listcoordok[[i]][j,2]-1)])
+                    uce<-c(uce,croise[(listcoordok[[i]][j,1]-1),(listcoordok[[i]][j,2]-1)])
+                }
+            	if (maxchi < sum(chi)) {
+            	    maxchi <- sum(chi)
+            	    suce <- sum(uce)
+            	    best <- i
+            	}
+            }
+        print(suce/nrow(classeuce1))
+        }
+        listcoordok[[best]]
+    }
+#---------------------------------------------------------------------------------   
+	#pour trouver une valeur dans une liste
+	#is.element(elem, list)
+	#== elem%in%list
+    oldfindbestcoord <- function(listx, listy) {
+    	coordok<-NULL
+    	trouvecoordok<-function(first) {
+    	    fillemere1<-NULL
+    	    fillemere2<-NULL
+    	    listxp<-listx
+    	    listyp<-listy
+    	    listxp<-listx[first:length(listx)]
+    	    listxp<-c(listxp,listx[1:(first-1)])
+    	    listyp<-listy[first:length(listy)]
+    	    listyp<-c(listyp,listy[1:(first-1)])
+    	    for (i in 1:length(listxp)) {
+    	        if (!(listxp[i]+1)%in%fillemere1) {
+    		        if (!(listyp[i]+1)%in%fillemere2) {
+    		            coordok<-rbind(coordok,c(listyp[i]+1,listxp[i]+1))
+    		            fillemere1<-c(fillemere1,trouvefillemere(listxp[i]+1,chd2$n1))
+    		            fillemere2<-c(fillemere2,trouvefillemere(listyp[i]+1,chd1$n1))
+    		        }
+    	       }
+    	    }
+    	    coordok
+    	}
+    #fonction pour trouver le nombre maximum de classes
+    	findmaxclasse<-function(listx,listy) {
+    	    listcoordok<-list()
+    	    maxcl<-0
+    	    nb<-1
+    	    for (i in 1:length(listy)) {
+    			coordok<-trouvecoordok(i)
+    			if (maxcl <= nrow(coordok)) {
+    			    maxcl<-nrow(coordok)
+    			    listcoordok[[nb]]<-coordok
+    			    nb<-nb+1
+    			}
+    	    }
+    	    listcoordok<-unique(listcoordok)
+            #print(listcoordok)
+    		#si plusieurs ensemble avec le meme nombre de classe, on conserve
+    		#la liste avec le plus fort chi2
+    	    if (length(listcoordok)>1) {
+    		    maxchi<-0
+    		    best<-NULL
+    		    for (i in 1:length(listcoordok)) {
+    		        chi<-NULL
+    		        uce<-NULL
+    		        if (nrow(listcoordok[[i]])==maxcl) {
+    		            for (j in 1:nrow(listcoordok[[i]])) {
+    		                chi<-c(chi,croise[(listcoordok[[i]][j,1]-1),(listcoordok[[i]][j,2]-1)])
+    		                uce<-c(uce,chicroiseori[(listcoordok[[i]][j,1]-1),(listcoordok[[i]][j,2]-1)])
+    		            }
+    		            if (maxchi < sum(chi)) {
+    		                maxchi <- sum(chi)
+    		                suce <- sum(uce)
+    		                best <- i
+    		            } 
+    		        }
+    		    }
+    	    }
+    	    print((maxchi/nrow(classeuce1)*100))
+    	    listcoordok[[best]]
+    	}
+        print('cherche max')
+	    coordok<-findmaxclasse(listx,listy)
+	    coordok
+    }
+	#findmaxclasse(listx,listy)
+	#coordok<-trouvecoordok(1)
+    #coordok <- oldfindbestcoord(listx, listy)
+    print('begin bestcoord')
+    coordok <- findbestcoord(listx, listy, classif_mode, nbt)
+
+
+	lfilletot<-function(classeuce,x) {
+	    listfille<-NULL
+	    for (classe in 1:nrow(coordok)) {
+			listfille<-unique(c(listfille,fille(coordok[classe,x],classeuce)))
+			listfille
+	    }
+	}
+    print('listfille')
+	listfille1<-lfilletot(classeuce1,1)
+	if (classif_mode == 0) {
+		listfille2<-lfilletot(classeuce2,2)
+	}
+
+	#utiliser rownames comme coordonnees dans un tableau de 0
+	Assignclasse<-function(classeuce,x) {
+	    nchd<-matrix(0,ncol=ncol(classeuce),nrow=nrow(classeuce))
+	    for (classe in 1:nrow(coordok)) {
+			clnb<-coordok[classe,x]
+			colnb<-clnb%/%2
+            nchd[which(classeuce[,colnb]==clnb), colnb:ncol(nchd)] <- classe
+	    }
+	    nchd
+	}
+	print('commence assigne new classe')
+	nchd1<-Assignclasse(classeuce1,1)
+	if (classif_mode==0) {
+		nchd2<-Assignclasse(classeuce2,2)
+	}
+	print('fini assign new classe')
+	#croisep<-matrix(ncol=nrow(coordok),nrow=nrow(coordok))
+	if (classif_mode==0) {
+    	nchd2[which(nchd1[,ncol(nchd1)]==0),] <- 0
+    	nchd2[which(nchd1[,ncol(nchd1)]!=nchd2[,ncol(nchd2)]),] <- 0
+    	nchd1[which(nchd2[,ncol(nchd2)]==0),] <- 0
+	}
+
+	print('fini croise')
+	elim<-which(nchd1[,ncol(nchd1)]==0)
+	keep<-which(nchd1[,ncol(nchd1)]!=0)
+	n1<-nchd1[nchd1[,ncol(nchd1)]!=0,]
+	if (classif_mode==0) {
+		n2<-nchd2[nchd2[,ncol(nchd2)]!=0,]
+	} else {
+		classeuce2 <- NULL
+	}
+	#clnb<-nrow(coordok)
+	print('fini')
+	write.csv2(nchd1[,ncol(nchd1)],uceout)
+	res <- list(n1 = nchd1, coord_ok = coordok, cuce1 = classeuce1, cuce2 = classeuce2)
+	res
+}

iramuteq-like/concordancier-iramuteq.R

@@ -0,0 +1,182 @@
+# Rôle du fichier: concordancier-iramuteq.R génère un concordancier HTML dédié au mode IRaMuTeQ-like.
+# Le rendu suit le style Rainette (segments par classe + surlignage),
+# avec une sélection des termes alignée sur les filtres statistiques IRaMuTeQ-like.
+
+.generer_concordancier_iramuteq_termes <- function(res_stats_df, classe, max_p = 1, filtrer_pvalue = TRUE) {
+  if (is.null(res_stats_df) || nrow(res_stats_df) == 0) return(character(0))
+  if (!all(c("Classe", "Terme") %in% names(res_stats_df))) return(character(0))
+
+  df <- res_stats_df
+  cl <- suppressWarnings(as.numeric(classe))
+  if (!is.na(cl)) {
+    classes_num <- suppressWarnings(as.numeric(df$Classe))
+    df <- df[!is.na(classes_num) & classes_num == cl, , drop = FALSE]
+  }
+
+  if (nrow(df) == 0) return(character(0))
+
+  # Filtres IRaMuTeQ-like: p <= max_p et, par défaut, uniquement les chi2 positifs.
+  if (isTRUE(filtrer_pvalue)) {
+    if ("p" %in% names(df) && is.finite(max_p) && !is.na(max_p)) {
+      p_vals <- suppressWarnings(as.numeric(df$p))
+      df <- df[!is.na(p_vals) & p_vals <= max_p, , drop = FALSE]
+    } else if ("p_value" %in% names(df) && is.finite(max_p) && !is.na(max_p)) {
+      p_vals <- suppressWarnings(as.numeric(df$p_value))
+      df <- df[!is.na(p_vals) & p_vals <= max_p, , drop = FALSE]
+    }
+  }
+
+  if ("chi2" %in% names(df)) {
+    chi2_vals <- suppressWarnings(as.numeric(df$chi2))
+    df <- df[!is.na(chi2_vals) & chi2_vals > 0, , drop = FALSE]
+    chi2_vals <- suppressWarnings(as.numeric(df$chi2))
+    df <- df[order(-chi2_vals), , drop = FALSE]
+  }
+
+  termes <- unique(as.character(df$Terme))
+  termes <- termes[!is.na(termes) & nzchar(trimws(termes))]
+  termes
+}
+
+generer_concordancier_iramuteq_html <- function(
+  chemin_sortie,
+  segments_by_class,
+  res_stats_df,
+  max_p,
+  filtrer_pvalue = TRUE,
+  textes_indexation,
+  avancer = NULL,
+  rv = NULL,
+  ...
+) {
+  if (!is.null(rv)) ajouter_log(rv, "Concordancier IRaMuTeQ-like : génération HTML (filtres IRaMuTeQ + surlignage Unicode).")
+
+  con <- file(chemin_sortie, open = "wt", encoding = "UTF-8")
+  on.exit(try(close(con), silent = TRUE), add = TRUE)
+
+  writeLines("<html><head><meta charset='utf-8'/>", con)
+  writeLines("<style>body{font-family:Arial,sans-serif;line-height:1.45;} span.highlight{background-color:yellow;} p.segment{margin:0 0 .45rem 0;} .classe-bloc{margin-bottom:1.25rem;padding-bottom:.8rem;border-bottom:1px solid #eee;}</style>", con)
+  writeLines("</head><body>", con)
+  writeLines("<h1>Concordancier IRaMuTeQ-like</h1>", con)
+  writeLines("<h2>Segments par classe</h2>", con)
+  writeLines(if (isTRUE(filtrer_pvalue)) "<h3>Filtrage: p ≤ seuil + χ² positif (puis fallback top χ²)</h3>" else "<h3>Filtrage: χ² positif (sans filtre p-value)</h3>", con)
+
+  noms_classes <- names(segments_by_class)
+  n_classes <- length(noms_classes)
+  if (n_classes == 0) n_classes <- 1
+
+  for (i in seq_along(noms_classes)) {
+    cl <- noms_classes[[i]]
+    if (!is.null(avancer)) avancer(0.75 + (i / n_classes) * 0.08, paste0("HTML IRaMuTeQ : classe ", cl))
+
+    writeLines("<div class='classe-bloc'>", con)
+    writeLines(paste0("<h2>Classe ", cl, "</h2>"), con)
+
+    segments <- segments_by_class[[cl]]
+    ids_cl <- names(segments)
+    if (length(ids_cl) == 0) {
+      writeLines("<p><em>Aucun segment.</em></p>", con)
+      writeLines("</div>", con)
+      next
+    }
+
+    textes_filtrage <- unname(segments)
+    if (!is.null(textes_indexation) && length(textes_indexation) > 0) {
+      tx <- textes_indexation[ids_cl]
+      ok_tx <- !is.na(tx) & nzchar(tx)
+      if (any(ok_tx)) textes_filtrage[ok_tx] <- tx[ok_tx]
+    }
+
+    termes_cl <- .generer_concordancier_iramuteq_termes(res_stats_df, cl, max_p = max_p, filtrer_pvalue = filtrer_pvalue)
+
+    if (length(termes_cl) == 0 && !is.null(res_stats_df) && nrow(res_stats_df) > 0 && "Classe" %in% names(res_stats_df)) {
+      df_cl <- res_stats_df[suppressWarnings(as.numeric(res_stats_df$Classe)) == suppressWarnings(as.numeric(cl)), , drop = FALSE]
+      if (nrow(df_cl) > 0 && "chi2" %in% names(df_cl) && "Terme" %in% names(df_cl)) {
+        chi2_vals <- suppressWarnings(as.numeric(df_cl$chi2))
+        idx <- !is.na(chi2_vals) & !is.na(df_cl$Terme) & nzchar(as.character(df_cl$Terme))
+        if (any(idx)) {
+          df_cl <- df_cl[idx, , drop = FALSE]
+          df_cl <- df_cl[order(-suppressWarnings(as.numeric(df_cl$chi2))), , drop = FALSE]
+          termes_cl <- unique(head(as.character(df_cl$Terme), 20))
+        }
+      }
+    }
+
+    termes_cl <- expandir_variantes_termes(termes_cl)
+    keep <- detecter_segments_contenant_termes_unicode(textes_filtrage, termes_cl)
+    keep[is.na(keep)] <- FALSE
+
+    segments_keep <- segments[keep]
+    if (length(segments_keep) == 0 && length(segments) > 0) {
+      segments_keep <- segments
+      if (!is.null(rv)) {
+        ajouter_log(rv, paste0(
+          "Concordancier IRaMuTeQ-like : classe ", cl,
+          " sans segment après filtrage, fallback sur tous les segments."
+        ))
+      }
+    }
+
+    writeLines(paste0("<p><em>Segments conservés : ", length(segments_keep), " / ", length(segments), "</em></p>"), con)
+
+    if (length(segments_keep) == 0) {
+      writeLines("<p><em>Aucun segment.</em></p>", con)
+      writeLines("</div>", con)
+      next
+    }
+
+    if (length(termes_cl) == 0) {
+      for (seg in echapper_segments_en_preservant_surlignage(unname(segments_keep), "<span class='highlight'>", "</span>")) {
+        writeLines(paste0("<p class='segment'>", seg, "</p>"), con)
+      }
+      writeLines("</div>", con)
+      next
+    }
+
+    motifs <- preparer_motifs_surlignage_nfd(termes_cl, taille_lot = 80)
+    segments_hl <- surligner_vecteur_html_unicode(
+      unname(segments_keep),
+      motifs,
+      "<span class='highlight'>",
+      "</span>",
+      on_error = function(e, pat) {
+        if (!is.null(rv)) {
+          ajouter_log(rv, paste0("Concordancier IRaMuTeQ-like : erreur regex [", pat, "] - ", conditionMessage(e)))
+        }
+      }
+    )
+
+    has_hl <- any(grepl("<span class='highlight'>", segments_hl, fixed = TRUE))
+    if (!has_hl) {
+      textes_keep_idx <- textes_filtrage[keep]
+      segments_hl_idx <- surligner_vecteur_html_unicode(
+        unname(textes_keep_idx),
+        motifs,
+        "<span class='highlight'>",
+        "</span>",
+        on_error = function(e, pat) {
+          if (!is.null(rv)) {
+            ajouter_log(rv, paste0("Concordancier IRaMuTeQ-like : erreur regex index [", pat, "] - ", conditionMessage(e)))
+          }
+        }
+      )
+      if (any(grepl("<span class='highlight'>", segments_hl_idx, fixed = TRUE))) {
+        segments_hl <- segments_hl_idx
+      }
+    }
+
+    if (length(segments_hl) == 0 && length(segments_keep) > 0) {
+      segments_hl <- unname(segments_keep)
+    }
+
+    for (seg in echapper_segments_en_preservant_surlignage(segments_hl, "<span class='highlight'>", "</span>")) {
+      writeLines(paste0("<p class='segment'>", seg, "</p>"), con)
+    }
+    writeLines("</div>", con)
+  }
+
+  writeLines("</body></html>", con)
+  close(con)
+  if (!is.null(rv)) ajouter_log(rv, paste0("Concordancier IRaMuTeQ-like : HTML écrit dans : ", chemin_sortie))
+  chemin_sortie
+}

iramuteq-like/cooccurrences_iramuteq.R

@@ -0,0 +1,76 @@
+# Rôle du fichier: cooccurrences.R regroupe l'analyse des cooccurrences par classe.
+
+generer_cooccurrences_par_classe <- function(tok_ok,
+                                             filtered_corpus_ok,
+                                             classes_uniques,
+                                             cooc_dir,
+                                             top_n,
+                                             top_feat,
+                                             window_cooc) {
+  top_n_demande <- suppressWarnings(as.integer(top_n))
+  if (!is.finite(top_n_demande) || is.na(top_n_demande)) top_n_demande <- 20L
+  top_n_demande <- max(5L, top_n_demande)
+
+  top_feat_demande <- suppressWarnings(as.integer(top_feat))
+  if (!is.finite(top_feat_demande) || is.na(top_feat_demande)) top_feat_demande <- 20L
+  top_feat_demande <- max(5L, top_feat_demande)
+
+  window_effectif <- suppressWarnings(as.integer(window_cooc))
+  if (!is.finite(window_effectif) || is.na(window_effectif)) window_effectif <- 5L
+  window_effectif <- max(1L, window_effectif)
+
+  for (cl in classes_uniques) {
+    tok_cl <- tok_ok[docvars(filtered_corpus_ok)$Classes == cl]
+    cooc_png <- file.path(cooc_dir, paste0("cluster_", cl, "_fcm_network.png"))
+
+    try({
+      if (length(tok_cl) > 0) {
+        fcm_cl <- fcm(tok_cl, context = "window", window = window_effectif, tri = FALSE)
+        term_freq <- sort(colSums(fcm_cl), decreasing = TRUE)
+
+        # On borne aussi par top_n pour garder une cohérence entre nuage de mots et graphe de cooccurrences.
+        top_feat_effectif <- min(top_feat_demande, top_n_demande)
+        feat_sel <- names(term_freq)[seq_len(min(top_feat_effectif, length(term_freq)))]
+        fcm_cl <- fcm_select(fcm_cl, feat_sel, selection = "keep")
+
+        adj <- as.matrix(fcm_cl)
+        g <- graph_from_adjacency_matrix(adj, mode = "undirected", weighted = TRUE, diag = FALSE)
+
+        num_nodes <- length(V(g))
+        palette_colors <- brewer.pal(min(8, num_nodes), "Set3")
+        V(g)$color <- palette_colors[seq_along(V(g))]
+
+        png(cooc_png, width = 1600, height = 1200)
+        plot(
+          g,
+          layout = layout_with_fr(g),
+          main = paste("Cooccurrences - Classe", cl),
+          vertex.size = 16,
+          vertex.color = V(g)$color,
+          vertex.label = V(g)$name,
+          vertex.label.cex = 1,
+          edge.width = E(g)$weight / 2,
+          edge.color = "gray80"
+        )
+        dev.off()
+      }
+    }, silent = TRUE)
+  }
+}
+
+construire_table_cooccurrences <- function(cooc_dir) {
+  cooc_files <- list.files(cooc_dir, pattern = "\\.png$", full.names = FALSE)
+  if (length(cooc_files) > 0) {
+    cooc_classes <- gsub("^cluster_([0-9]+)_fcm_network\\.png$", "\\1", cooc_files)
+    coocs_df <- data.frame(
+      classe = cooc_classes,
+      src = file.path("cooccurrences", cooc_files),
+      stringsAsFactors = FALSE
+    )
+    coocs_df <- coocs_df[order(suppressWarnings(as.integer(coocs_df$classe))), , drop = FALSE]
+  } else {
+    coocs_df <- data.frame(classe = character(0), src = character(0), stringsAsFactors = FALSE)
+  }
+
+  coocs_df
+}

iramuteq-like/dendogramme_iramuteq.R

@@ -0,0 +1,45 @@
+# Rôle du fichier: point d'entrée UI pour le tracé du dendrogramme IRaMuTeQ-like.
+
+tracer_dendogramme_iramuteq_ui <- function(rv,
+                                            top_n_terms = 4,
+                                            orientation = "vertical",
+                                            display_method = "compact") {
+  if (is.null(rv$res) && is.null(rv$res_chd)) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible.", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  chd_obj <- NULL
+  if (!is.null(rv$res$chd)) {
+    chd_obj <- rv$res$chd
+  } else if (!is.null(rv$res_chd)) {
+    chd_obj <- rv$res_chd
+  } else if (exists("obtenir_objet_dendrogramme", mode = "function", inherits = TRUE)) {
+    chd_obj <- obtenir_objet_dendrogramme(rv$res)
+  }
+
+  terminales <- if (!is.null(rv$res$terminales)) rv$res$terminales else NULL
+  classes <- if (!is.null(rv$res$classes)) rv$res$classes else NULL
+  if (is.null(classes) && !is.null(rv$filtered_corpus) && "Classes" %in% names(docvars(rv$filtered_corpus))) {
+    classes <- docvars(rv$filtered_corpus)$Classes
+  }
+
+  if (is.null(chd_obj)) {
+    plot.new()
+    text(0.5, 0.5, "Dendrogramme CHD indisponible (objet CHD introuvable).", cex = 1.1)
+    return(invisible(NULL))
+  }
+
+  tracer_dendrogramme_chd_iramuteq(
+    chd_obj = chd_obj,
+    terminales = terminales,
+    classes = classes,
+    res_stats_df = rv$res_stats_df,
+    top_n_terms = top_n_terms,
+    orientation = orientation,
+    display_method = display_method
+  )
+
+  invisible(NULL)
+}

iramuteq-like/nettoyage_iramuteq.R

@@ -0,0 +1,37 @@
+# Rôle du fichier: nettoyage_iramuteq.R isole la préparation texte du mode IRaMuTeQ-like.
+# Cette logique est volontairement séparée de Rainette car les conventions de préparation
+# ne sont pas identiques (script textprepa Python et dictionnaire lexique_fr imposé).
+
+appliquer_nettoyage_iramuteq <- function(textes,
+                                         activer_nettoyage = FALSE,
+                                         forcer_minuscules = FALSE,
+                                         supprimer_chiffres = FALSE,
+                                         supprimer_apostrophes = FALSE) {
+  x <- as.character(textes)
+  if (length(x) == 0) return(character(0))
+
+  x <- gsub("\u00A0", " ", x, fixed = TRUE)
+
+  if (isTRUE(supprimer_chiffres)) {
+    x <- gsub("[0-9]+", " ", x, perl = TRUE)
+  }
+
+  if (isTRUE(supprimer_apostrophes)) {
+    x <- gsub("(?i)\\b(?:[cdjlmnst]|qu)['’`´ʼʹ](?=\\p{L})", "", x, perl = TRUE)
+  }
+
+  if (isTRUE(activer_nettoyage)) {
+    regex_autorises <- "a-zA-Z0-9àÀâÂäÄáÁåÅãéÉèÈêÊëËìÌîÎïÏíÍóÓòÒôÔöÖõÕøØùÙûÛüÜúÚçÇßœŒ’ñÑ\\.:,;!\\?'"
+    regex_a_supprimer <- paste0("[^", regex_autorises, "]")
+    x <- gsub(regex_a_supprimer, " ", x, perl = TRUE)
+  }
+
+  x <- gsub("\\s+", " ", x, perl = TRUE)
+  x <- trimws(x)
+
+  if (isTRUE(forcer_minuscules)) {
+    x <- tolower(x)
+  }
+
+  x
+}

iramuteq-like/nlp_lexique_iramuteq.R

@@ -0,0 +1,200 @@
+# Rôle du fichier: nlp_lexique.R porte une partie du pipeline d'analyse Rainette.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+# Il facilite la maintenance en explicitant le périmètre et les points d'intégration.
+# Module NLP - lemmatisation via lexique externe (dictionnaires/lexique_fr.csv)
+# Ce module charge un lexique 3 colonnes au format canonique
+# (c_mot, c_lemme, c_morpho).
+# et applique une lemmatisation explicite sans fallback silencieux vers spaCy.
+
+charger_lexique_fr <- function(chemin = "dictionnaires/lexique_fr.csv") {
+  fichier <- tryCatch(normalizePath(chemin, mustWork = TRUE), error = function(e) NA_character_)
+  if (is.na(fichier) || !file.exists(fichier)) {
+    stop(
+      paste0(
+        "Lexique (fr) introuvable : fichier '", chemin,
+        "' absent. Ajoute dictionnaires/lexique_fr.csv (format lexique_fr ou IRaMuTeQ)."
+      )
+    )
+  }
+
+  lire_tsv <- function() {
+    read.delim(
+      fichier,
+      sep = "\t",
+      header = TRUE,
+      stringsAsFactors = FALSE,
+      fileEncoding = "UTF-8",
+      check.names = FALSE
+    )
+  }
+
+  lire_csv <- function() {
+    read.csv(
+      fichier,
+      sep = ",",
+      header = TRUE,
+      stringsAsFactors = FALSE,
+      fileEncoding = "UTF-8",
+      check.names = FALSE
+    )
+  }
+
+  lire_csv_point_virgule <- function() {
+    read.csv(
+      fichier,
+      sep = ";",
+      header = TRUE,
+      stringsAsFactors = FALSE,
+      fileEncoding = "UTF-8",
+      check.names = FALSE
+    )
+  }
+
+  lexique <- tryCatch(lire_tsv(), error = function(e) NULL)
+  if (is.null(lexique) || ncol(lexique) <= 1) {
+    lexique <- tryCatch(lire_csv(), error = function(e) NULL)
+  }
+  if (is.null(lexique) || ncol(lexique) <= 1) {
+    lexique <- tryCatch(lire_csv_point_virgule(), error = function(e) NULL)
+  }
+
+  if (is.null(lexique) || nrow(lexique) == 0) {
+    stop("Lexique (fr) invalide : fichier vide ou illisible.")
+  }
+
+  names(lexique) <- trimws(sub("^\ufeff", "", names(lexique)))
+
+  colonnes_attendues <- c("c_mot", "c_lemme", "c_morpho")
+  manquantes <- setdiff(colonnes_attendues, names(lexique))
+  if (length(manquantes) > 0) {
+    stop(
+      paste0(
+        "Lexique (fr) mal configuré : colonnes manquantes [",
+        paste(manquantes, collapse = ", "),
+        "]. Format attendu : c_mot, c_lemme, c_morpho."
+      )
+    )
+  }
+
+  lexique$c_mot <- tolower(trimws(as.character(lexique$c_mot)))
+  lexique$c_lemme <- tolower(trimws(as.character(lexique$c_lemme)))
+  lexique$c_morpho <- toupper(trimws(as.character(lexique$c_morpho)))
+
+  lexique <- lexique[
+    nzchar(lexique$c_mot) &
+      nzchar(lexique$c_lemme) &
+      nzchar(lexique$c_morpho),
+    ,
+    drop = FALSE
+  ]
+
+  if (nrow(lexique) == 0) {
+    stop("Lexique (fr) mal configuré : aucune entrée exploitable après nettoyage.")
+  }
+
+  lexique
+}
+
+construire_type_lexique_fr <- function(termes, lexique) {
+  if (is.null(termes)) return(character(0))
+  x <- tolower(trimws(as.character(termes)))
+  x[is.na(x)] <- ""
+
+  if (is.null(lexique) || !is.data.frame(lexique) || nrow(lexique) < 1) {
+    return(rep("", length(x)))
+  }
+
+  cols_ok <- all(c("c_mot", "c_lemme", "c_morpho") %in% names(lexique))
+  if (!cols_ok) {
+    return(rep("", length(x)))
+  }
+
+  key_mot <- tolower(trimws(as.character(lexique$c_mot)))
+  key_lemme <- tolower(trimws(as.character(lexique$c_lemme)))
+  val_type <- tolower(trimws(as.character(lexique$c_morpho)))
+
+  map_lemme <- tapply(val_type, key_lemme, function(v) unique(v)[1])
+  map_mot <- tapply(val_type, key_mot, function(v) unique(v)[1])
+
+  out <- unname(map_lemme[x])
+  idx_na <- is.na(out) | !nzchar(out)
+  if (any(idx_na)) {
+    out[idx_na] <- unname(map_mot[x[idx_na]])
+  }
+
+  out[is.na(out)] <- ""
+  out
+}
+
+
+lemmatiser_textes_lexique <- function(textes, lexique, rv = NULL) {
+  tok <- quanteda::tokens(
+    textes,
+    remove_punct = FALSE,
+    remove_numbers = FALSE
+  )
+
+  map_forme_lemme <- tapply(
+    lexique$c_lemme,
+    lexique$c_mot,
+    function(x) unique(x)[1]
+  )
+
+  liste_tok <- as.list(tok)
+  textes_lem <- vapply(liste_tok, function(v) {
+    if (length(v) == 0) return("")
+    v_low <- tolower(as.character(v))
+    lem <- unname(map_forme_lemme[v_low])
+    lem[is.na(lem) | !nzchar(lem)] <- v_low[is.na(lem) | !nzchar(lem)]
+    paste(lem, collapse = " ")
+  }, FUN.VALUE = character(1))
+
+  if (!is.null(rv)) {
+    ajouter_log(rv, "Lexique (fr) : lemmatisation forme->lemme appliquée sans spaCy.")
+  }
+
+  textes_lem
+}
+
+
+
+filtrer_textes_lexique_par_cgram <- function(textes, lexique, cgram_a_conserver, rv = NULL) {
+  cgram_keep <- unique(toupper(trimws(as.character(cgram_a_conserver))))
+  cgram_keep <- cgram_keep[nzchar(cgram_keep)]
+  if (length(cgram_keep) == 0) return(textes)
+
+  formes_keep <- unique(lexique$c_mot[lexique$c_morpho %in% cgram_keep])
+  formes_keep <- formes_keep[nzchar(formes_keep)]
+
+  tok <- quanteda::tokens(
+    textes,
+    remove_punct = FALSE,
+    remove_numbers = FALSE
+  )
+
+  liste_tok <- as.list(tok)
+  total_tokens <- 0L
+  total_conserves <- 0L
+
+  textes_filtres <- vapply(liste_tok, function(v) {
+    if (length(v) == 0) return("")
+    v_low <- tolower(trimws(as.character(v)))
+    total_tokens <<- total_tokens + length(v_low)
+    garder <- v_low %in% formes_keep
+    total_conserves <<- total_conserves + sum(garder)
+    paste(v_low[garder], collapse = " ")
+  }, FUN.VALUE = character(1))
+
+  if (!is.null(rv)) {
+    ajouter_log(
+      rv,
+      paste0(
+        "Lexique (fr) : filtrage c_morpho [", paste(cgram_keep, collapse = ", "),
+        "] => ", total_conserves, "/", total_tokens, " token(s) conservé(s)."
+      )
+    )
+  }
+
+  names(textes_filtres) <- names(textes)
+  textes_filtres
+}

iramuteq-like/pipeline_iramuteq_analysis_iramuteq.R

@@ -0,0 +1,33 @@
+# Rôle du fichier: pipeline_iramuteq_analysis.R porte le pipeline dédié au mode IRaMuTeQ-like.
+# Ce flux est volontairement séparé de Rainette/spaCy pour éviter tout mélange de logique.
+
+executer_pipeline_iramuteq <- function(input, rv, textes_chd) {
+  ajouter_log(rv, "IRaMuTeQ-like : pipeline lexical dédié (lexique_fr uniquement).")
+
+  tok_base <- tokens(
+    textes_chd,
+    remove_punct = isTRUE(input$supprimer_ponctuation),
+    remove_numbers = isTRUE(input$supprimer_chiffres)
+  )
+
+  res_dfm <- construire_dfm_avec_fallback_stopwords(
+    tok_base = tok_base,
+    min_docfreq = input$min_docfreq,
+    retirer_stopwords = isTRUE(input$retirer_stopwords),
+    langue_spacy = "fr",
+    rv = rv,
+    libelle = "IRaMuTeQ-like",
+    source_dictionnaire = "lexique_fr",
+    lexique_source_stopwords = "quanteda"
+  )
+
+  rv$spacy_tokens_df <- NULL
+  rv$lexique_fr_df <- NULL
+
+  list(
+    tok = res_dfm$tok,
+    dfm_obj = res_dfm$dfm,
+    langue_reference = "fr",
+    source_dictionnaire = "lexique_fr"
+  )
+}

iramuteq-like/pipeline_lexique_analysis_iramuteq.R

@@ -0,0 +1,91 @@
+# Rôle du fichier: pipeline_lexique_analysis.R porte une partie du pipeline d'analyse Rainette.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+# Il facilite la maintenance en explicitant le périmètre et les points d'intégration.
+executer_pipeline_lexique <- function(input, rv, textes_chd) {
+  filtrage_morpho <- isTRUE(input$filtrage_morpho)
+  utiliser_lemmes_lexique <- isTRUE(input$lexique_utiliser_lemmes)
+  langue_reference <- "fr"
+  lexique_source_stopwords <- "quanteda"
+
+  if (isTRUE(utiliser_lemmes_lexique) || isTRUE(filtrage_morpho)) {
+    lexique_fr <- charger_lexique_fr("dictionnaires/lexique_fr.csv")
+    ajouter_log(rv, paste0("Lexique (fr) chargé : ", nrow(lexique_fr), " entrées."))
+    rv$lexique_fr_df <- lexique_fr
+  } else {
+    lexique_fr <- NULL
+    rv$lexique_fr_df <- NULL
+    ajouter_log(rv, "Lexique (fr) sans lemmatisation/filtrage : conservation des formes d'origine.")
+  }
+
+  rv$spacy_tokens_df <- NULL
+
+  if (isTRUE(utiliser_lemmes_lexique) && !isTRUE(filtrage_morpho)) {
+    ajouter_log(rv, "Lexique (fr) sans filtrage morphosyntaxique : lemmatisation directe forme->lemme.")
+
+    textes_lexique <- lemmatiser_textes_lexique(
+      textes = textes_chd,
+      lexique = lexique_fr,
+      rv = rv
+    )
+
+  } else if (isTRUE(filtrage_morpho)) {
+    cgram_lexique_a_conserver <- toupper(trimws(as.character(input$pos_lexique_a_conserver)))
+    cgram_lexique_a_conserver <- unique(cgram_lexique_a_conserver[nzchar(cgram_lexique_a_conserver)])
+    if (is.null(cgram_lexique_a_conserver) || length(cgram_lexique_a_conserver) == 0) {
+      cgram_lexique_a_conserver <- c("NOM", "ADJ", "VER")
+    }
+
+    ajouter_log(
+      rv,
+      paste0(
+        "lexique_fr | filtrage morpho=1 (c_morpho: ",
+        paste(cgram_lexique_a_conserver, collapse = ", "),
+        ") | lemmes=", ifelse(utiliser_lemmes_lexique, "1", "0"),
+        " | stopwords: quanteda (Lexique fr)"
+      )
+    )
+
+    textes_lexique <- filtrer_textes_lexique_par_cgram(
+      textes = textes_chd,
+      lexique = lexique_fr,
+      cgram_a_conserver = cgram_lexique_a_conserver,
+      rv = rv
+    )
+
+    if (isTRUE(utiliser_lemmes_lexique)) {
+      textes_lexique <- lemmatiser_textes_lexique(
+        textes = textes_lexique,
+        lexique = lexique_fr,
+        rv = rv
+      )
+    }
+  } else {
+    ajouter_log(rv, "Lexique (fr) sans filtrage morphosyntaxique ni lemmatisation : pipeline standard.")
+    textes_lexique <- textes_chd
+  }
+
+  tok_base <- tokens(
+    textes_lexique,
+    remove_punct = isTRUE(input$supprimer_ponctuation),
+    remove_numbers = isTRUE(input$supprimer_chiffres)
+  )
+
+  res_dfm <- construire_dfm_avec_fallback_stopwords(
+    tok_base = tok_base,
+    min_docfreq = input$min_docfreq,
+    retirer_stopwords = isTRUE(input$retirer_stopwords),
+    langue_spacy = langue_reference,
+    rv = rv,
+    libelle = ifelse(utiliser_lemmes_lexique, "Lexique (fr)", "lexique_fr"),
+    source_dictionnaire = "lexique_fr",
+    lexique_source_stopwords = lexique_source_stopwords
+  )
+
+  list(
+    tok = res_dfm$tok,
+    dfm_obj = res_dfm$dfm,
+    langue_reference = langue_reference,
+    source_dictionnaire = "lexique_fr",
+    lexique_source_stopwords = lexique_source_stopwords
+  )
+}

iramuteq-like/server_events_lancer_iramuteq.R

@@ -0,0 +1,1133 @@
+# Rôle du fichier: server_events_lancer_iramuteq.R porte le pipeline d'analyse IRaMuTeQ-like.
+# Ce script centralise une responsabilité métier/technique utilisée par l'application.
+# Module server - événement principal `input$lancer`
+# Ce fichier encapsule le pipeline principal lancé au clic sur "Lancer l'analyse"
+# (préparation, CHD/AFC/NER, exports) pour alléger `app.R` à comportement constant.
+
+register_events_lancer <- function(input, output, session, rv) {
+    app_dir <- tryCatch(shiny::getShinyOption("appDir"), error = function(e) NULL)
+    if (is.null(app_dir) || !nzchar(app_dir)) app_dir <- getwd()
+    env_modules <- environment()
+
+    charger_module_langue <- function() {
+      candidats_langue <- unique(c(
+        file.path(app_dir, "iramuteq-like", "nlp_lexique_iramuteq.R"),
+        file.path(getwd(), "iramuteq-like", "nlp_lexique_iramuteq.R"),
+        file.path("iramuteq-like", "nlp_lexique_iramuteq.R"),
+        file.path(app_dir, "iramuteq-like", "nlp_lexique_iramuteq.R"),
+        file.path(getwd(), "iramuteq-like", "nlp_lexique_iramuteq.R"),
+        file.path("iramuteq-like", "nlp_lexique_iramuteq.R")
+      ))
+
+      dernier_chemin <- candidats_langue[[1]]
+      derniere_raison <- "fonction verifier_coherence_dictionnaire_langue absente après source"
+
+      for (chemin_langue in candidats_langue) {
+        dernier_chemin <- chemin_langue
+        if (!file.exists(chemin_langue)) next
+
+        source_res <- tryCatch({
+          source(chemin_langue, encoding = "UTF-8", local = env_modules)
+          NULL
+        }, error = function(e) e)
+
+        if (inherits(source_res, "error")) {
+          derniere_raison <- paste0("échec source: ", conditionMessage(source_res))
+          next
+        }
+
+        if (exists("verifier_coherence_dictionnaire_langue", mode = "function", envir = env_modules, inherits = TRUE)) {
+          return(list(ok = TRUE, chemin = chemin_langue, raison = ""))
+        }
+
+        derniere_raison <- "fonction verifier_coherence_dictionnaire_langue absente après source"
+      }
+
+      list(ok = FALSE, chemin = dernier_chemin, raison = derniere_raison)
+    }
+
+    if (!exists("appliquer_nettoyage_iramuteq", mode = "function", inherits = TRUE)) {
+      chemin_nettoyage_iramuteq <- file.path(app_dir, "iramuteq-like", "nettoyage_iramuteq.R")
+      if (file.exists(chemin_nettoyage_iramuteq)) {
+        source(chemin_nettoyage_iramuteq, encoding = "UTF-8", local = TRUE)
+      }
+    }
+
+    if (!exists("appliquer_nettoyage_rainette", mode = "function", inherits = TRUE)) {
+      appliquer_nettoyage_rainette <- function(textes,
+                                               activer_nettoyage = FALSE,
+                                               forcer_minuscules = FALSE,
+                                               supprimer_chiffres = FALSE,
+                                               supprimer_apostrophes = FALSE) {
+        ajouter_log(rv, "Avertissement: appliquer_nettoyage_rainette indisponible; nettoyage contourné pour préserver l'exécution.")
+        if (is.null(textes)) return(character(0))
+        x <- as.character(textes)
+        if (isTRUE(forcer_minuscules)) x <- tolower(x)
+        x
+      }
+    }
+
+    if (!exists("appliquer_nettoyage_iramuteq", mode = "function", inherits = TRUE)) {
+      appliquer_nettoyage_iramuteq <- appliquer_nettoyage_rainette
+    }
+
+
+    executer_textprepa_iramuteq <- function(ids, textes, input, rv) {
+      candidats_script <- unique(c(
+        file.path(app_dir, "iramuteq-like", "textprepa_iramuteq.py"),
+        file.path(getwd(), "iramuteq-like", "textprepa_iramuteq.py"),
+        file.path("iramuteq-like", "textprepa_iramuteq.py")
+      ))
+      script_path <- candidats_script[file.exists(candidats_script)][1]
+      if (is.na(script_path) || !nzchar(script_path)) {
+        stop("IRaMuTeQ-like: script textprepa_iramuteq.py introuvable.")
+      }
+
+      py_bin <- Sys.which("python3")
+      if (!nzchar(py_bin)) py_bin <- Sys.which("python")
+      if (!nzchar(py_bin)) {
+        stop("IRaMuTeQ-like: Python introuvable (python3/python).")
+      }
+
+      in_tsv <- tempfile(pattern = "iramuteq_prepa_in_", fileext = ".tsv")
+      out_tsv <- tempfile(pattern = "iramuteq_prepa_out_", fileext = ".tsv")
+
+      df_in <- data.frame(
+        doc_id = as.character(ids),
+        text = as.character(textes),
+        stringsAsFactors = FALSE
+      )
+      write.table(df_in, file = in_tsv, sep = "	", row.names = FALSE, col.names = TRUE, quote = TRUE, fileEncoding = "UTF-8")
+
+      args <- c(
+        script_path,
+        "--input", in_tsv,
+        "--output", out_tsv,
+        "--nettoyage_caracteres", ifelse(isTRUE(input$nettoyage_caracteres), "1", "0"),
+        "--forcer_minuscules_avant", ifelse(isTRUE(input$forcer_minuscules_avant), "1", "0"),
+        "--supprimer_chiffres", ifelse(isTRUE(input$supprimer_chiffres), "1", "0"),
+        "--supprimer_apostrophes", ifelse(isTRUE(input$supprimer_apostrophes), "1", "0")
+      )
+
+      res <- tryCatch(
+        system2(py_bin, args = args, stdout = TRUE, stderr = TRUE),
+        error = function(e) structure(conditionMessage(e), status = 1L)
+      )
+      status <- attr(res, "status")
+      if (is.null(status)) status <- 0L
+      if (!identical(as.integer(status), 0L) || !file.exists(out_tsv)) {
+        out_msg <- if (length(res)) paste(res, collapse = " | ") else "(aucun message)"
+        stop(paste0("IRaMuTeQ-like: échec textprepa_iramuteq.py (code ", status, ") : ", out_msg))
+      }
+
+      df_out <- read.delim(out_tsv, sep = "	", header = TRUE, stringsAsFactors = FALSE, quote = '"', encoding = "UTF-8")
+      if (!all(c("doc_id", "text") %in% names(df_out))) {
+        stop("IRaMuTeQ-like: sortie textprepa invalide (colonnes doc_id/text manquantes).")
+      }
+
+      ids_chr <- as.character(ids)
+      idx <- match(ids_chr, as.character(df_out$doc_id))
+      if (any(is.na(idx))) {
+        stop("IRaMuTeQ-like: alignement doc_id invalide après textprepa.")
+      }
+
+      textes_prep <- as.character(df_out$text[idx])
+      names(textes_prep) <- ids_chr
+      ajouter_log(rv, "IRaMuTeQ-like: préparation texte exécutée via iramuteq-like/textprepa_iramuteq.py")
+      textes_prep
+    }
+
+    formater_df_csv_6_decimales <- function(df) {
+      if (is.null(df)) return(df)
+      df_out <- df
+      for (nm in names(df_out)) {
+        col <- df_out[[nm]]
+        if (is.numeric(col)) {
+          df_out[[nm]] <- ifelse(
+            is.na(col),
+            NA_character_,
+            formatC(col, format = "f", digits = 6)
+          )
+        }
+      }
+      df_out
+    }
+
+    ecrire_csv_6_decimales <- function(df, chemin, row.names = FALSE) {
+      write.csv(formater_df_csv_6_decimales(df), chemin, row.names = row.names)
+    }
+
+    observeEvent(input$modele_chd, {
+      if (identical(as.character(input$modele_chd), "iramuteq")) {
+        updateRadioButtons(
+          session,
+          "source_dictionnaire",
+          choices = c("Lexique (fr)" = "lexique_fr"),
+          selected = "lexique_fr"
+        )
+        if (isTRUE(input$activer_ner)) {
+          updateCheckboxInput(session, "activer_ner", value = FALSE)
+          ajouter_log(rv, "Mode IRaMuTeQ-like : NER spaCy automatiquement désactivé (mode uniquement Lexique fr).")
+        }
+      } else {
+        updateRadioButtons(
+          session,
+          "source_dictionnaire",
+          choices = c("spaCy" = "spacy", "Lexique (fr)" = "lexique_fr"),
+          selected = if (identical(as.character(input$source_dictionnaire), "lexique_fr")) "lexique_fr" else "spacy"
+        )
+      }
+    }, ignoreInit = FALSE)
+
+    output$ui_concordancier_iramuteq <- renderUI({
+      req(rv$export_dir)
+
+      if (!identical(rv$res_type, "iramuteq")) {
+        return(tags$p("Concordancier IRaMuTeQ-like indisponible (mode Rainette actif)."))
+      }
+
+      if (is.null(rv$exports_prefix) || !nzchar(rv$exports_prefix)) {
+        return(tags$div(
+          style = "padding: 12px;",
+          tags$p("Préfixe de ressources invalide."),
+          tags$p("Relance l'analyse pour régénérer les exports.")
+        ))
+      }
+
+      if (!(rv$exports_prefix %in% names(shiny::resourcePaths()))) {
+        shiny::addResourcePath(rv$exports_prefix, rv$export_dir)
+      }
+
+      candidats_html <- c(
+        rv$html_file,
+        file.path(rv$export_dir, "segments_par_classe.html"),
+        file.path(rv$export_dir, "concordancier.html")
+      )
+      candidats_dyn <- list.files(
+        rv$export_dir,
+        pattern = "(segments.*classe|concord).*\\.html$",
+        ignore.case = TRUE,
+        full.names = TRUE
+      )
+      candidats_html <- c(candidats_html, candidats_dyn)
+      candidats_html <- unique(candidats_html[!is.na(candidats_html) & nzchar(candidats_html)])
+      html_existant <- candidats_html[file.exists(candidats_html)]
+
+      if (length(html_existant) == 0) {
+        return(tags$div(
+          style = "padding: 12px;",
+          tags$p("Le fichier du concordancier HTML n'est pas disponible pour cette analyse."),
+          tags$p("Relance l'analyse puis vérifie les logs si le problème persiste.")
+        ))
+      }
+
+      src_html <- html_existant[[1]]
+      nom_html <- basename(src_html)
+      src_dans_exports <- file.path(rv$export_dir, nom_html)
+
+      if (!isTRUE(file.exists(src_dans_exports))) {
+        ok_copy <- tryCatch(file.copy(src_html, src_dans_exports, overwrite = TRUE), error = function(e) FALSE)
+        if (isTRUE(ok_copy)) src_html <- src_dans_exports
+      } else {
+        src_html <- src_dans_exports
+      }
+
+      tags$iframe(
+        src = paste0("/", rv$exports_prefix, "/", basename(src_html)),
+        style = "width: 100%; height: 70vh; border: 1px solid #999;"
+      )
+    })
+
+    output$ui_wordcloud_iramuteq <- renderUI({
+      req(rv$export_dir, rv$exports_prefix)
+
+      if (!identical(rv$res_type, "iramuteq")) {
+        return(tags$p("Nuage de mots IRaMuTeQ-like indisponible (mode Rainette actif)."))
+      }
+
+      classe_sel <- as.character(input$classe_viz_iramuteq)
+      if (length(classe_sel) != 1 || is.na(classe_sel) || !nzchar(classe_sel)) {
+        return(tags$p("Sélectionne une classe pour afficher le nuage de mots."))
+      }
+
+      src_rel <- file.path("wordclouds", paste0("cluster_", classe_sel, "_wordcloud.png"))
+      if (!file.exists(file.path(rv$export_dir, src_rel))) {
+        return(tags$p("Aucun nuage de mots disponible pour cette classe."))
+      }
+
+      tags$div(
+        style = "text-align: center;",
+        tags$img(
+          src = paste0("/", rv$exports_prefix, "/", src_rel),
+          style = "max-width: 100%; height: auto; border: 1px solid #999; display: inline-block;"
+        )
+      )
+    })
+
+    normaliser_id_classe_local <- function(x) {
+      x_chr <- as.character(x)
+      x_chr <- trimws(x_chr)
+
+      x_num <- suppressWarnings(as.numeric(x_chr))
+      need_extract <- is.na(x_num) & !is.na(x_chr) & nzchar(x_chr)
+
+      if (any(need_extract)) {
+        extrait <- sub("^.*?(\\d+).*$", "\\1", x_chr[need_extract])
+        extrait[!grepl("\\d", x_chr[need_extract])] <- NA_character_
+        x_num[need_extract] <- suppressWarnings(as.numeric(extrait))
+      }
+
+      x_num
+    }
+
+    observeEvent(input$lancer, {
+      rv$logs <- ""
+      rv$statut <- "Vérification du fichier..."
+      rv$progression <- 0
+
+      rv$spacy_tokens_df <- NULL
+      rv$lexique_fr_df <- NULL
+      rv$textes_indexation <- NULL
+      rv$ner_df <- NULL
+      rv$ner_nb_segments <- NA_integer_
+      rv$afc_obj <- NULL
+      rv$afc_erreur <- NULL
+      rv$afc_vars_obj <- NULL
+      rv$afc_vars_erreur <- NULL
+
+      rv$afc_dir <- NULL
+      rv$afc_table_mots <- NULL
+      rv$afc_table_vars <- NULL
+      rv$afc_plot_classes <- NULL
+      rv$afc_plot_termes <- NULL
+      rv$afc_plot_vars <- NULL
+
+      rv$segments_file <- NULL
+      rv$stats_file <- NULL
+      rv$html_file <- NULL
+      rv$ner_file <- NULL
+      rv$zip_file <- NULL
+
+      rv$res <- NULL
+      rv$res_chd <- NULL
+      rv$dfm_chd <- NULL
+      rv$res_type <- "simple"
+      rv$max_n_groups <- NULL
+      rv$max_n_groups_chd <- NULL
+      rv$explor_assets <- NULL
+      rv$stats_corpus_df <- NULL
+      rv$stats_zipf_df <- NULL
+
+      ajouter_log(rv, "Clic sur 'Lancer l'analyse' reçu.")
+
+      modele_chd <- "iramuteq"
+      mode_iramuteq <- TRUE
+      source_dictionnaire <- "lexique_fr"
+      updateRadioButtons(
+        session,
+        "source_dictionnaire",
+        choices = c("Lexique (fr)" = "lexique_fr"),
+        selected = "lexique_fr"
+      )
+      updateRadioButtons(
+        session,
+        "modele_chd",
+        selected = "iramuteq"
+      )
+
+      if (is.null(input$fichier_corpus) || is.null(input$fichier_corpus$datapath) || !file.exists(input$fichier_corpus$datapath)) {
+        rv$statut <- "Aucun fichier uploadé."
+        rv$progression <- 0
+        ajouter_log(rv, "Aucun fichier uploadé côté serveur. Sélectionne un .txt puis relance.")
+        showNotification("Aucun fichier uploadé. Choisis un .txt.", type = "error", duration = 6)
+        return(invisible(NULL))
+      }
+
+      if (isTRUE(input$activer_ner) && mode_iramuteq) {
+        rv$statut <- "Configuration invalide : NER indisponible en mode IRaMuTeQ-like."
+        rv$progression <- 0
+        ajouter_log(rv, "Blocage de l'analyse : NER activé en mode IRaMuTeQ-like (mode uniquement Lexique fr).")
+        showNotification(
+          "Analyse bloquée : le mode IRaMuTeQ-like fonctionne uniquement avec Lexique (fr) et sans NER spaCy.",
+          type = "error",
+          duration = 8
+        )
+        return(invisible(NULL))
+      }
+
+      if (isTRUE(input$activer_ner) && !is.null(input$fichier_ner_json) && !is.null(input$fichier_ner_json$datapath) && file.exists(input$fichier_ner_json$datapath)) {
+        rv$ner_file <- input$fichier_ner_json$datapath
+        ajouter_log(rv, paste0("NER : dictionnaire JSON importé via l'UI : ", input$fichier_ner_json$name))
+      }
+
+        p <- Progress$new(session, min = 0, max = 1)
+        on.exit(try(p$close(), silent = TRUE), add = TRUE)
+
+        avancer <- function(valeur, detail) {
+          valeur <- max(0, min(1, valeur))
+          p$set(value = valeur, message = "Calculs CHD en cours", detail = detail)
+          rv$progression <- round(valeur * 100)
+        }
+
+        tryCatch({
+
+          avancer(0.02, "Préparation des répertoires")
+          rv$statut <- "Préparation des répertoires..."
+
+          rv$base_dir <- file.path(tempdir(), paste0("rainette_", session$token))
+          rv$export_dir <- file.path(rv$base_dir, "exports")
+          dir.create(rv$export_dir, showWarnings = FALSE, recursive = TRUE)
+          ajouter_log(rv, paste0("export_dir = ", rv$export_dir))
+
+          avancer(0.08, "Import du corpus")
+          rv$statut <- "Import du corpus..."
+          chemin_fichier <- input$fichier_corpus$datapath
+          md5 <- md5_fichier(chemin_fichier)
+          ajouter_log(rv, paste0("MD5 fichier = ", md5))
+
+          corpus <- import_corpus_iramuteq(chemin_fichier)
+          ajouter_log(rv, paste0("Nombre de documents importés : ", ndoc(corpus)))
+
+          avancer(0.14, "Segmentation")
+          rv$statut <- "Segmentation..."
+          segment_size <- input$segment_size
+          corpus <- split_segments(corpus, segment_size = segment_size)
+          ajouter_log(rv, paste0("Nombre de segments après découpage : ", ndoc(corpus)))
+
+          stats_corpus <- calculer_stats_corpus(
+            chemin_fichier = chemin_fichier,
+            corpus_segments = corpus,
+            nom_corpus = input$fichier_corpus$name
+          )
+          if (is.null(stats_corpus)) {
+            rv$stats_corpus_df <- NULL
+            rv$stats_zipf_df <- NULL
+          } else {
+            rv$stats_corpus_df <- stats_corpus$table
+            rv$stats_zipf_df <- stats_corpus$zipf
+          }
+
+          ids_orig <- as.character(docnames(corpus))
+          ids_corpus <- ids_orig
+          invalides <- is.na(ids_corpus) | !nzchar(trimws(ids_corpus))
+          if (any(invalides)) {
+            ids_corpus[invalides] <- paste0("doc_", which(invalides))
+          }
+
+          ids_uniques <- make.unique(ids_corpus, sep = "_dup")
+          modif_ids <- any(ids_uniques != ids_orig)
+          if (isTRUE(modif_ids)) {
+            n_problemes <- sum(invalides) + sum(duplicated(ids_corpus))
+            ajouter_log(rv, paste0("Docnames invalides/dupliqués détectés après segmentation : ", n_problemes, ". Renommage automatique via make.unique()."))
+          }
+
+          docnames(corpus) <- ids_uniques
+          ids_corpus <- as.character(docnames(corpus))
+
+          textes_orig <- as.character(corpus)
+
+          avancer(0.18, "Préparation texte (nettoyage / minuscules)")
+          rv$statut <- "Préparation texte..."
+
+          if (mode_iramuteq) {
+            textes_nettoyes <- appliquer_nettoyage_iramuteq(
+              textes = textes_orig,
+              activer_nettoyage = isTRUE(input$nettoyage_caracteres),
+              forcer_minuscules = isTRUE(input$forcer_minuscules_avant),
+              supprimer_chiffres = isTRUE(input$supprimer_chiffres),
+              supprimer_apostrophes = isTRUE(input$supprimer_apostrophes)
+            )
+
+            textes_chd <- executer_textprepa_iramuteq(
+              ids = ids_corpus,
+              textes = textes_nettoyes,
+              input = input,
+              rv = rv
+            )
+          } else {
+            textes_chd <- appliquer_nettoyage_rainette(
+              textes = textes_orig,
+              activer_nettoyage = isTRUE(input$nettoyage_caracteres),
+              forcer_minuscules = isTRUE(input$forcer_minuscules_avant),
+              supprimer_chiffres = isTRUE(input$supprimer_chiffres),
+              supprimer_apostrophes = isTRUE(input$supprimer_apostrophes)
+            )
+            names(textes_chd) <- ids_corpus
+          }
+
+          if (!exists("verifier_coherence_dictionnaire_langue", mode = "function", inherits = TRUE)) {
+            charge_langue <- charger_module_langue()
+            if (!isTRUE(charge_langue$ok)) {
+              stop(paste0("Module langue indisponible (", charge_langue$raison, ") : ", charge_langue$chemin))
+            }
+            ajouter_log(rv, paste0("Diagnostic langue: module chargé depuis ", charge_langue$chemin, "."))
+          }
+
+          source_dictionnaire <- "lexique_fr"
+
+          verifier_coherence_dictionnaire_langue(
+            textes_chd,
+            if (identical(source_dictionnaire, "lexique_fr")) "fr" else as.character(input$spacy_langue),
+            rv = rv
+          )
+
+          avancer(0.22, "Prétraitement + DFM")
+          rv$statut <- "Prétraitement et DFM..."
+
+          ajouter_log(
+            rv,
+            paste0(
+              "Diagnostic pipeline: dictionnaire=", source_dictionnaire,
+              " | langue UI=", as.character(input$spacy_langue),
+              " | filtrage_morpho=", ifelse(isTRUE(input$filtrage_morpho), "1", "0"),
+              " | retirer_stopwords=", ifelse(isTRUE(input$retirer_stopwords), "1", "0"),
+              " | supprimer_ponctuation=", ifelse(isTRUE(input$supprimer_ponctuation), "1", "0"),
+              " | supprimer_chiffres=", ifelse(isTRUE(input$supprimer_chiffres), "1", "0"),
+              " | supprimer_apostrophes=", ifelse(isTRUE(input$supprimer_apostrophes), "1", "0"),
+              " | nettoyage_caracteres=", ifelse(isTRUE(input$nettoyage_caracteres), "1", "0")
+            )
+          )
+
+          sortie_pipeline <- executer_pipeline_iramuteq(
+            input = input,
+            rv = rv,
+            textes_chd = textes_chd
+          )
+
+          tok <- sortie_pipeline$tok
+          dfm_obj <- sortie_pipeline$dfm_obj
+          langue_reference <- sortie_pipeline$langue_reference
+          source_dictionnaire <- sortie_pipeline$source_dictionnaire
+
+          if (anyDuplicated(docnames(dfm_obj)) > 0) {
+            dups_dfm <- sum(duplicated(as.character(docnames(dfm_obj))))
+            docnames(dfm_obj) <- make.unique(as.character(docnames(dfm_obj)), sep = "_dup")
+            ajouter_log(rv, paste0("DFM : docnames dupliqués détectés (", dups_dfm, "). Renommage automatique."))
+          }
+
+          included_segments <- as.character(docnames(dfm_obj))
+          included_segments <- included_segments[!is.na(included_segments) & nzchar(included_segments)]
+          included_segments <- unique(included_segments)
+
+          filtered_corpus <- corpus[included_segments]
+          if (anyDuplicated(docnames(filtered_corpus)) > 0) {
+            dups_corpus <- sum(duplicated(as.character(docnames(filtered_corpus))))
+            docnames(filtered_corpus) <- make.unique(as.character(docnames(filtered_corpus)), sep = "_dup")
+            ajouter_log(rv, paste0("Corpus filtré : docnames dupliqués détectés (", dups_corpus, "). Renommage automatique."))
+          }
+
+          tok <- tok[included_segments]
+          if (anyDuplicated(docnames(tok)) > 0) {
+            dups_tok <- sum(duplicated(as.character(docnames(tok))))
+            docnames(tok) <- make.unique(as.character(docnames(tok)), sep = "_dup")
+            ajouter_log(rv, paste0("Tokens : docnames dupliqués détectés (", dups_tok, "). Renommage automatique."))
+          }
+
+          dfm_obj <- assurer_docvars_dfm_minimal(dfm_obj, filtered_corpus)
+
+          tmp <- supprimer_docs_vides_dfm(dfm_obj, filtered_corpus, tok, rv)
+          dfm_obj <- tmp$dfm
+          filtered_corpus <- tmp$corpus
+          tok <- tmp$tok
+
+          ajouter_log(rv, paste0("Après suppression segments vides : ", ndoc(dfm_obj), " docs ; ", nfeat(dfm_obj), " termes."))
+          verifier_dfm_avant_rainette(dfm_obj, input)
+
+          rv$textes_indexation <- vapply(as.list(tok), function(x) paste(x, collapse = " "), FUN.VALUE = character(1))
+          names(rv$textes_indexation) <- docnames(dfm_obj)
+
+          avancer(0.52, "Classification (rainette / rainette2)")
+          rv$statut <- "Classification en cours..."
+
+          modele_chd <- "iramuteq"
+
+          type_classif <- as.character(input$type_classification)
+          if (!type_classif %in% c("simple", "double")) type_classif <- "simple"
+
+          groupes <- NULL
+          res_final <- NULL
+
+          if (identical(modele_chd, "iramuteq")) {
+
+            rv$res_type <- "iramuteq"
+            ajouter_log(rv, "Mode : classification IRaMuTeQ-like.")
+
+            k_iramuteq <- suppressWarnings(as.integer(input$k_iramuteq))
+            if (is.na(k_iramuteq) || k_iramuteq < 2L) k_iramuteq <- 10L
+
+            mincl_mode_iramuteq <- as.character(input$iramuteq_mincl_mode)
+            if (!mincl_mode_iramuteq %in% c("auto", "manuel")) mincl_mode_iramuteq <- "auto"
+
+            mincl_iramuteq <- suppressWarnings(as.integer(input$iramuteq_mincl))
+            if (is.na(mincl_iramuteq) || mincl_iramuteq < 1L) mincl_iramuteq <- 1L
+
+            classif_mode_iramuteq <- as.character(input$iramuteq_classif_mode)
+            if (!classif_mode_iramuteq %in% c("simple", "double")) classif_mode_iramuteq <- "simple"
+
+            svd_method_iramuteq <- as.character(input$iramuteq_svd_method)
+            if (!svd_method_iramuteq %in% c("irlba", "svdR")) svd_method_iramuteq <- "irlba"
+
+            ajouter_log(
+              rv,
+              paste0(
+                "Paramètres IRaMuTeQ-like : k=", k_iramuteq,
+                " | mincl_mode=", mincl_mode_iramuteq,
+                if (identical(mincl_mode_iramuteq, "manuel")) paste0(" | mincl=", mincl_iramuteq) else "",
+                " | classif_mode=", classif_mode_iramuteq,
+                " | svd_method=", svd_method_iramuteq,
+                " | mode_patate=", ifelse(isTRUE(input$iramuteq_mode_patate), "1", "0")
+              )
+            )
+
+            res_ira <- lancer_moteur_chd_iramuteq(
+              dfm_obj = dfm_obj,
+              k = k_iramuteq,
+              mincl_mode = mincl_mode_iramuteq,
+              mincl = mincl_iramuteq,
+              classif_mode = classif_mode_iramuteq,
+              svd_method = svd_method_iramuteq,
+              mode_patate = isTRUE(input$iramuteq_mode_patate),
+              binariser = TRUE
+            )
+
+            groupes <- as.integer(res_ira$classes)
+            if (all(is.na(groupes)) || length(unique(groupes[groupes > 0])) < 2) {
+              stop("IRaMuTeQ-like n'a pas pu produire au moins 2 classes exploitables.")
+            }
+
+            res_final <- res_ira
+            rv$res_chd <- NULL
+            rv$dfm_chd <- NULL
+            rv$max_n_groups <- length(unique(groupes[groupes > 0]))
+            rv$max_n_groups_chd <- rv$max_n_groups
+
+          } else if (type_classif == "simple") {
+
+            rv$res_type <- "simple"
+            ajouter_log(rv, "Mode : classification simple (rainette).")
+
+            k_effectif <- calculer_k_effectif(dfm_obj, input$k, input$min_split_members, rv)
+
+            res <- rainette(
+              dfm_obj,
+              k = k_effectif,
+              min_segment_size = input$min_segment_size,
+              min_split_members = input$min_split_members,
+              doc_id = "segment_source"
+            )
+
+            if (is.null(res) || is.null(res$group) || length(res$group) == 0) stop("Rainette n'a pas pu calculer de clusters. Diminue les filtrages, augmente segment_size, ou réduis k.")
+
+            groupes <- res$group
+            res_final <- res
+            rv$res_chd <- res
+            rv$dfm_chd <- dfm_obj
+            rv$max_n_groups <- max(res$group, na.rm = TRUE)
+            rv$max_n_groups_chd <- rv$max_n_groups
+
+          } else {
+
+            rv$res_type <- "double"
+            ajouter_log(rv, "Mode : classification double (rainette2).")
+
+            k_effectif <- calculer_k_effectif(dfm_obj, input$k, input$min_split_members, rv)
+
+            res1 <- rainette(dfm_obj, k = k_effectif, min_segment_size = input$min_segment_size, min_split_members = input$min_split_members, doc_id = "segment_source")
+            if (is.null(res1) || is.null(res1$group) || length(res1$group) == 0) stop("Classification 1 (rainette) impossible.")
+
+            res2 <- rainette(dfm_obj, k = k_effectif, min_segment_size = input$min_segment_size2, min_split_members = input$min_split_members, doc_id = "segment_source")
+            if (is.null(res2) || is.null(res2$group) || length(res2$group) == 0) stop("Classification 2 (rainette) impossible.")
+
+            res_d <- rainette2(res1, res2, max_k = input$max_k_double)
+            groupes <- cutree(res_d, k = k_effectif)
+
+            res_final <- res_d
+            rv$res_chd <- res1
+            rv$dfm_chd <- dfm_obj
+            rv$max_n_groups <- input$max_k_double
+            rv$max_n_groups_chd <- max(res1$group, na.rm = TRUE)
+          }
+
+          docvars(filtered_corpus)$Classes <- groupes
+
+          classes_calculees <- suppressWarnings(as.integer(docvars(filtered_corpus)$Classes))
+          idx_ok <- !is.na(classes_calculees) & classes_calculees > 0
+
+          nb_non_assignes <- sum(!idx_ok)
+          if (nb_non_assignes > 0) {
+            ajouter_log(
+              rv,
+              paste0(
+                "Segments non assignés à une classe terminale (Classe 0 / NA) : ",
+                nb_non_assignes,
+                ". Exclusion des calculs CHD/AFC."
+              )
+            )
+          }
+          filtered_corpus_ok <- filtered_corpus[idx_ok]
+          dfm_ok <- dfm_obj[idx_ok, ]
+          tok_ok <- tok[idx_ok]
+
+          if (ndoc(dfm_ok) < 2) stop("Après classification, il reste moins de 2 segments classés (hors NA).")
+          if (nfeat(dfm_ok) < 2) stop("Après classification, le DFM classé est trop pauvre (moins de 2 termes).")
+
+          rv$clusters <- sort(unique(docvars(filtered_corpus_ok)$Classes))
+          rv$res <- res_final
+          rv$dfm <- dfm_ok
+          rv$filtered_corpus <- filtered_corpus_ok
+          rv$res_stats_df <- NULL
+
+          avancer(0.58, "NER (si activé)")
+          rv$statut <- "NER (si activé)..."
+
+          if (isTRUE(input$activer_ner)) {
+            ajouter_log(rv, "NER ignoré : cette branche IRaMuTeQ-like est strictement sans spaCy.")
+          }
+
+          avancer(0.62, "Exports + stats")
+          rv$statut <- "Exports et statistiques..."
+
+          segments_vec <- as.character(filtered_corpus_ok)
+          names(segments_vec) <- docnames(filtered_corpus_ok)
+          segments_by_class <- split(segments_vec, docvars(filtered_corpus_ok)$Classes)
+
+          segments_file <- file.path(rv$export_dir, "segments_par_classe.txt")
+          writeLines(unlist(lapply(names(segments_by_class), function(cl) c(paste0("Classe ", cl, ":"), unname(segments_by_class[[cl]]), ""))), segments_file)
+
+          if (identical(rv$res_type, "iramuteq")) {
+            ajouter_log(rv, "Statistiques CHD : calcul IRaMuTeQ-like (contingence classe × terme).")
+            res_stats_df <- construire_stats_classes_iramuteq(
+              dfm_obj = dfm_ok,
+              classes = docvars(filtered_corpus_ok)$Classes,
+              max_p = 1
+            ) %>%
+              mutate(Classe = normaliser_id_classe_local(Classe)) %>%
+              arrange(Classe, desc(chi2))
+          } else {
+            res_stats_list <- rainette_stats(
+              dtm = dfm_ok,
+              groups = docvars(filtered_corpus_ok)$Classes,
+              measure = c("chi2", "lr", "frequency", "docprop"),
+              n_terms = 9999,
+              # Harmonisation avec le graphe CHD :
+              # - pas de chi2 négatifs dans l'onglet Statistiques
+              # - pas de coupe préalable sur p-value pour conserver le même
+              #   vivier de termes entre les vues (la colonne p_value_filter
+              #   reste disponible pour distinguer les termes significatifs).
+              show_negative = FALSE,
+              max_p = 1
+            )
+
+            labels_stats <- names(res_stats_list)
+            labels_groupes <- as.character(sort(unique(docvars(filtered_corpus_ok)$Classes)))
+
+            if (is.null(labels_stats) || length(labels_stats) != length(res_stats_list) || any(!nzchar(labels_stats))) {
+              labels_stats <- labels_groupes
+            }
+
+            if (length(labels_stats) != length(res_stats_list)) {
+              labels_stats <- as.character(seq_along(res_stats_list))
+            }
+
+            tailles_stats <- vapply(res_stats_list, nrow, integer(1))
+
+            res_stats_df <- bind_rows(res_stats_list) %>%
+              mutate(ClusterID = rep(labels_stats, times = tailles_stats)) %>%
+              rename(Terme = feature, Classe = ClusterID) %>%
+              mutate(
+                p_value = p,
+                Classe_brut = as.character(Classe),
+                Classe = normaliser_id_classe_local(Classe),
+                p_value_filter = ifelse(p <= input$max_p, paste0("≤ ", input$max_p), paste0("> ", input$max_p))
+              ) %>%
+              arrange(Classe, desc(chi2))
+          }
+
+          if (identical(source_dictionnaire, "lexique_fr") &&
+              !is.null(rv$lexique_fr_df) &&
+              is.data.frame(rv$lexique_fr_df) &&
+              nrow(rv$lexique_fr_df) > 0 &&
+              "Terme" %in% names(res_stats_df) &&
+              exists("construire_type_lexique_fr", mode = "function", inherits = TRUE)) {
+            res_stats_df$Type <- construire_type_lexique_fr(res_stats_df$Terme, rv$lexique_fr_df)
+          }
+
+          stats_file <- file.path(rv$export_dir, "stats_par_classe.csv")
+          ecrire_csv_6_decimales(res_stats_df, stats_file, row.names = FALSE)
+
+          rv$segments_file <- segments_file
+          rv$stats_file <- stats_file
+          rv$res_stats_df <- res_stats_df
+
+          avancer(0.72, "AFC (classes × termes)")
+          rv$statut <- "Calcul AFC classes × termes..."
+
+          rv$afc_obj <- NULL
+          rv$afc_erreur <- NULL
+          rv$afc_vars_obj <- NULL
+          rv$afc_vars_erreur <- NULL
+          rv$afc_dir <- file.path(rv$export_dir, "afc")
+          dir.create(rv$afc_dir, showWarnings = FALSE, recursive = TRUE)
+
+          filtrer_affichage_pvalue <- isTRUE(input$filtrer_affichage_pvalue)
+
+          termes_signif <- NULL
+          if (isTRUE(filtrer_affichage_pvalue)) {
+            termes_signif <- unique(subset(res_stats_df, p <= input$max_p)$Terme)
+            termes_signif <- termes_signif[!is.na(termes_signif) & nzchar(termes_signif)]
+            if (length(termes_signif) < 2) termes_signif <- NULL
+          }
+
+          tryCatch({
+            groupes_docs <- docvars(filtered_corpus_ok)$Classes
+
+            obj <- executer_afc_classes(
+              dfm_obj = dfm_ok,
+              groupes = groupes_docs,
+              termes_cibles = termes_signif,
+              max_termes = 400,
+              seuil_p = if (isTRUE(filtrer_affichage_pvalue)) input$max_p else 1,
+              rv = rv
+            )
+
+            if (!is.null(obj$termes_stats) && !is.null(rv$res_stats_df)) {
+              df_m <- obj$termes_stats
+              df_m$Classe_num <- suppressWarnings(as.numeric(gsub("^Classe\\s+", "", as.character(df_m$Classe_max))))
+              rs <- rv$res_stats_df
+
+              rs2 <- rs[, intersect(c("Terme", "Classe", "chi2", "p", "frequency", "docprop", "lr"), names(rs)), drop = FALSE]
+              rs2$Classe <- as.numeric(rs2$Classe)
+
+              m <- merge(
+                df_m,
+                rs2,
+                by.x = c("Terme", "Classe_num"),
+                by.y = c("Terme", "Classe"),
+                all.x = TRUE,
+                suffixes = c("_global", "_rainette")
+              )
+
+              if ("chi2" %in% names(m)) {
+                df_m$chi2 <- ifelse(is.na(m$chi2), df_m$chi2, m$chi2)
+              }
+              if ("p" %in% names(m)) {
+                df_m$p_value <- ifelse(is.na(m$p), df_m$p_value, m$p)
+              }
+
+              df_m$Classe_num <- NULL
+              obj$termes_stats <- df_m
+            }
+
+            obj$termes_stats <- construire_segments_exemples_afc(
+              termes_stats = obj$termes_stats,
+              dfm_obj = dfm_ok,
+              corpus_obj = filtered_corpus_ok
+            )
+
+            rv$afc_obj <- obj
+            ajouter_log(rv, "AFC classes × termes : calcul terminé.")
+
+          }, error = function(e) {
+            rv$afc_erreur <- paste0("AFC classes × termes : ", e$message)
+            ajouter_log(rv, rv$afc_erreur)
+            showNotification(rv$afc_erreur, type = "error", duration = 8)
+          })
+
+          avancer(0.74, "AFC (variables étoilées)")
+          rv$statut <- "Calcul AFC variables étoilées..."
+
+          tryCatch({
+            if (!is.null(docvars(filtered_corpus_ok)$Classes)) {
+              objv <- executer_afc_variables_etoilees(
+                corpus_aligne = filtered_corpus_ok,
+                groupes = docvars(filtered_corpus_ok)$Classes,
+                max_modalites = 400,
+                seuil_p = if (isTRUE(filtrer_affichage_pvalue)) input$max_p else 1,
+                rv = rv
+              )
+              rv$afc_vars_obj <- objv
+              ajouter_log(rv, "AFC variables étoilées : calcul terminé.")
+            }
+          }, error = function(e) {
+            rv$afc_vars_erreur <- paste0("AFC variables étoilées : ", e$message)
+            ajouter_log(rv, rv$afc_vars_erreur)
+          })
+
+          if (!is.null(rv$afc_obj) && !is.null(rv$afc_obj$ca)) {
+
+            afc_classes_png <- file.path(rv$afc_dir, "afc_classes.png")
+            afc_termes_png <- file.path(rv$afc_dir, "afc_termes.png")
+
+            activer_repel <- TRUE
+            if (!is.null(input$afc_reduire_chevauchement)) activer_repel <- isTRUE(input$afc_reduire_chevauchement)
+
+            taille_sel <- "frequency"
+            if (!is.null(input$afc_taille_mots) && nzchar(as.character(input$afc_taille_mots))) {
+              taille_sel <- as.character(input$afc_taille_mots)
+            }
+            if (!taille_sel %in% c("frequency", "chi2")) taille_sel <- "frequency"
+
+            top_termes <- 120
+            if (!is.null(input$afc_top_termes) && is.finite(input$afc_top_termes)) top_termes <- as.integer(input$afc_top_termes)
+
+            png(afc_classes_png, width = 1800, height = 1400, res = 180)
+            try(tracer_afc_classes_seules(rv$afc_obj, axes = c(1, 2), cex_labels = 1.05), silent = TRUE)
+            dev.off()
+
+            png(afc_termes_png, width = 2000, height = 1600, res = 180)
+            try(tracer_afc_classes_termes(rv$afc_obj, axes = c(1, 2), top_termes = top_termes, taille_sel = taille_sel, activer_repel = activer_repel), silent = TRUE)
+            dev.off()
+
+            rv$afc_plot_classes <- afc_classes_png
+            rv$afc_plot_termes <- afc_termes_png
+
+            ecrire_csv_6_decimales(rv$afc_obj$table, file.path(rv$afc_dir, "table_classes_termes.csv"), row.names = TRUE)
+            ecrire_csv_6_decimales(rv$afc_obj$rowcoord, file.path(rv$afc_dir, "coords_classes.csv"), row.names = TRUE)
+            ecrire_csv_6_decimales(rv$afc_obj$colcoord, file.path(rv$afc_dir, "coords_termes.csv"), row.names = TRUE)
+            ecrire_csv_6_decimales(rv$afc_obj$termes_stats, file.path(rv$afc_dir, "stats_termes.csv"), row.names = FALSE)
+
+            if (!is.null(rv$afc_obj$ca$eig)) {
+              ecrire_csv_6_decimales(as.data.frame(rv$afc_obj$ca$eig), file.path(rv$afc_dir, "valeurs_propres.csv"), row.names = TRUE)
+            }
+
+            rv$afc_table_mots <- rv$afc_obj$termes_stats
+          }
+
+          if (!is.null(rv$afc_vars_obj) && !is.null(rv$afc_vars_obj$ca)) {
+
+            afc_vars_png <- file.path(rv$afc_dir, "afc_variables_etoilees.png")
+
+            activer_repel2 <- TRUE
+            if (!is.null(input$afc_reduire_chevauchement)) activer_repel2 <- isTRUE(input$afc_reduire_chevauchement)
+
+            top_mod <- 120
+            if (!is.null(input$afc_top_modalites) && is.finite(input$afc_top_modalites)) top_mod <- as.integer(input$afc_top_modalites)
+
+            png(afc_vars_png, width = 2000, height = 1600, res = 180)
+            try(tracer_afc_variables_etoilees(rv$afc_vars_obj, axes = c(1, 2), top_modalites = top_mod, activer_repel = activer_repel2), silent = TRUE)
+            dev.off()
+
+            rv$afc_plot_vars <- afc_vars_png
+
+            ecrire_csv_6_decimales(rv$afc_vars_obj$table, file.path(rv$afc_dir, "table_classes_variables.csv"), row.names = TRUE)
+            ecrire_csv_6_decimales(rv$afc_vars_obj$rowcoord, file.path(rv$afc_dir, "coords_classes_vars.csv"), row.names = TRUE)
+            ecrire_csv_6_decimales(rv$afc_vars_obj$colcoord, file.path(rv$afc_dir, "coords_modalites.csv"), row.names = TRUE)
+            ecrire_csv_6_decimales(rv$afc_vars_obj$modalites_stats, file.path(rv$afc_dir, "stats_modalites.csv"), row.names = FALSE)
+
+            if (!is.null(rv$afc_vars_obj$ca$eig)) {
+              ecrire_csv_6_decimales(as.data.frame(rv$afc_vars_obj$ca$eig), file.path(rv$afc_dir, "valeurs_propres_vars.csv"), row.names = TRUE)
+            }
+
+            rv$afc_table_vars <- rv$afc_vars_obj$modalites_stats
+          }
+
+          avancer(0.76, "Concordancier HTML")
+          rv$statut <- "Concordancier..."
+
+          html_file <- file.path(rv$export_dir, "segments_par_classe.html")
+          textes_index_ok <- rv$textes_indexation[docnames(dfm_ok)]
+          names(textes_index_ok) <- docnames(dfm_ok)
+
+          wordcloud_dir <- file.path(rv$export_dir, "wordclouds")
+          dir.create(wordcloud_dir, showWarnings = FALSE, recursive = TRUE)
+          cooc_dir <- file.path(rv$export_dir, "cooccurrences")
+          dir.create(cooc_dir, showWarnings = FALSE, recursive = TRUE)
+
+          classes_uniques <- sort(unique(as.integer(docvars(filtered_corpus_ok)$Classes)))
+          classes_uniques <- classes_uniques[is.finite(classes_uniques)]
+
+          if (length(classes_uniques) > 0) {
+            classes_choices <- as.character(classes_uniques)
+            updateSelectInput(
+              session,
+              "classe_viz_iramuteq",
+              choices = classes_choices,
+              selected = classes_choices[[1]]
+            )
+          }
+
+          if (!identical(rv$res_type, "iramuteq")) {
+            for (cl in classes_uniques) {
+            top_n_demande <- suppressWarnings(as.integer(input$top_n))
+            if (!is.finite(top_n_demande) || is.na(top_n_demande)) top_n_demande <- 20L
+            top_n_demande <- max(5L, top_n_demande)
+
+            if (isTRUE(input$filtrer_affichage_pvalue)) {
+              df_stats_cl <- subset(res_stats_df, Classe == cl & p <= input$max_p)
+            } else {
+              df_stats_cl <- subset(res_stats_df, Classe == cl)
+            }
+            if (nrow(df_stats_cl) > 0) {
+              df_stats_cl <- df_stats_cl[order(-df_stats_cl$chi2), , drop = FALSE]
+              df_stats_cl <- head(df_stats_cl, top_n_demande)
+
+              wc_png <- file.path(wordcloud_dir, paste0("cluster_", cl, "_wordcloud.png"))
+              try({
+                png(wc_png, width = 800, height = 600)
+                suppressWarnings(wordcloud(
+                  words = df_stats_cl$Terme,
+                  freq = df_stats_cl$chi2,
+                  scale = c(10, 0.5),
+                  min.freq = 0,
+                  max.words = nrow(df_stats_cl),
+                  colors = brewer.pal(8, "Dark2")
+                ))
+                dev.off()
+              }, silent = TRUE)
+            }
+
+            }
+
+            generer_cooccurrences_par_classe(
+              tok_ok = tok_ok,
+              filtered_corpus_ok = filtered_corpus_ok,
+              classes_uniques = classes_uniques,
+              cooc_dir = cooc_dir,
+              top_n = input$top_n,
+              top_feat = input$top_feat,
+              window_cooc = input$window_cooc
+            )
+          } else {
+            generer_wordclouds_iramuteq(
+              res_stats_df = res_stats_df,
+              classes_uniques = classes_uniques,
+              wordcloud_dir = wordcloud_dir,
+              top_n = input$top_n,
+              filtrer_pvalue = isTRUE(input$filtrer_affichage_pvalue),
+              max_p = input$max_p
+            )
+            ajouter_log(rv, "Mode IRaMuTeQ-like : nuages de mots générés via wordcloud_iramuteq.R (cooccurrences Explore rainette désactivées).")
+          }
+
+          explor_assets <- NULL
+          ok_chd_png <- FALSE
+          if (!identical(rv$res_type, "iramuteq")) {
+            ok_chd_png <- generer_chd_explor_si_absente(rv)
+          }
+
+          chd_png_rel <- NULL
+          if (isTRUE(ok_chd_png) && file.exists(file.path(rv$export_dir, "explor", "chd.png"))) {
+            chd_png_rel <- file.path("explor", "chd.png")
+          }
+          chd_html_rel <- generer_chd_html_explor(rv, chd_png_rel)
+
+          wc_files <- list.files(wordcloud_dir, pattern = "\\.png$", full.names = FALSE)
+          if (length(wc_files) > 0) {
+            wc_classes <- gsub("^cluster_([0-9]+)_wordcloud\\.png$", "\\1", wc_files)
+            wordclouds_df <- data.frame(
+              classe = wc_classes,
+              src = file.path("wordclouds", wc_files),
+              stringsAsFactors = FALSE
+            )
+            wordclouds_df <- wordclouds_df[order(suppressWarnings(as.integer(wordclouds_df$classe))), , drop = FALSE]
+          } else {
+            wordclouds_df <- data.frame(classe = character(0), src = character(0), stringsAsFactors = FALSE)
+          }
+
+          coocs_df <- construire_table_cooccurrences(cooc_dir)
+
+          explor_assets <- list(
+            chd = chd_png_rel,
+            chd_html = chd_html_rel,
+            wordclouds = wordclouds_df,
+            coocs = coocs_df
+          )
+          rv$explor_assets <- explor_assets
+
+          args_concordancier <- list(
+            chemin_sortie = html_file,
+            segments_by_class = segments_by_class,
+            res_stats_df = res_stats_df,
+            max_p = if (isTRUE(input$filtrer_affichage_pvalue)) input$max_p else 1,
+            filtrer_pvalue = isTRUE(input$filtrer_affichage_pvalue),
+            textes_indexation = textes_index_ok,
+            spacy_tokens_df = rv$spacy_tokens_df,
+            lexique_fr_df = rv$lexique_fr_df,
+            source_dictionnaire = source_dictionnaire,
+            avancer = avancer,
+            rv = rv
+          )
+
+          # Priorité explicite au concordancier IRaMuTeQ-like lorsque le mode
+          # IRaMuTeQ est sélectionné dans l'UI (même si rv$res_type est désynchronisé).
+          mode_iramuteq_actif <- identical(as.character(input$modele_chd), "iramuteq") ||
+            identical(rv$res_type, "iramuteq")
+
+          fonction_concordancier <- if (isTRUE(mode_iramuteq_actif)) {
+            generer_concordancier_iramuteq_html
+          } else if (identical(source_dictionnaire, "lexique_fr")) {
+            generer_concordancier_lexique_html
+          } else {
+            generer_concordancier_spacy_html
+          }
+
+          html_genere <- do.call(fonction_concordancier, args_concordancier)
+
+          candidats_html <- unique(c(
+            html_genere,
+            html_file,
+            file.path(rv$export_dir, "concordancier.html")
+          ))
+          candidats_html <- candidats_html[is.character(candidats_html) & !is.na(candidats_html) & nzchar(candidats_html)]
+          html_existants <- candidats_html[file.exists(candidats_html)]
+
+          if (length(html_existants) == 0) {
+            html_fallback <- file.path(rv$export_dir, "concordancier.html")
+            args_concordancier$chemin_sortie <- html_fallback
+            ajouter_log(rv, "Concordancier HTML introuvable après la première génération. Nouvelle tentative vers exports/concordancier.html.")
+            html_retry <- tryCatch(
+              do.call(fonction_concordancier, args_concordancier),
+              error = function(e) {
+                ajouter_log(rv, paste0("Concordancier HTML : échec de la relance - ", e$message))
+                NA_character_
+              }
+            )
+
+            candidats_retry <- unique(c(html_retry, html_fallback, html_genere, html_file))
+            candidats_retry <- candidats_retry[is.character(candidats_retry) & !is.na(candidats_retry) & nzchar(candidats_retry)]
+            html_existants <- candidats_retry[file.exists(candidats_retry)]
+          }
+
+          if (length(html_existants) > 0) {
+            rv$html_file <- html_existants[[1]]
+            ajouter_log(rv, paste0("Concordancier HTML validé : ", rv$html_file))
+          } else {
+            rv$html_file <- html_file
+            ajouter_log(rv, "Concordancier HTML introuvable après relance. Vérifier les logs de génération du concordancier.")
+          }
+
+          avancer(0.96, "ZIP")
+          rv$statut <- "Création ZIP..."
+          rv$zip_file <- file.path(rv$base_dir, "exports_rainette.zip")
+          if (file.exists(rv$zip_file)) unlink(rv$zip_file)
+
+          ancien_wd <- getwd()
+          setwd(rv$base_dir)
+          utils::zip(zipfile = rv$zip_file, files = "exports")
+          setwd(ancien_wd)
+
+          exports_prefix <- as.character(rv$exports_prefix)
+          if (length(exports_prefix) > 1) exports_prefix <- exports_prefix[[1]]
+          if (!length(exports_prefix) || is.na(exports_prefix) || !nzchar(exports_prefix)) {
+            # Fallback robuste: évite une erreur "missing value where TRUE/FALSE needed"
+            # lorsque le token de session est indisponible.
+            exports_prefix <- paste0("exports_", format(Sys.time(), "%Y%m%d%H%M%S"))
+            rv$exports_prefix <- exports_prefix
+          }
+
+          if (!(exports_prefix %in% names(shiny::resourcePaths()))) {
+            shiny::addResourcePath(exports_prefix, rv$export_dir)
+          }
+
+          rv$statut <- "Analyse terminée."
+          rv$progression <- 100
+          ajouter_log(rv, "Analyse terminée.")
+          showNotification("Analyse terminée.", type = "message", duration = 5)
+
+        }, error = function(e) {
+          rv$statut <- paste0("Erreur : ", e$message)
+          ajouter_log(rv, paste0("ERREUR : ", e$message))
+          showNotification(e$message, type = "error", duration = 8)
+        })
+    })
+}

iramuteq-like/stats_chd.R

@@ -0,0 +1,136 @@
+# Rôle du fichier: stats_chd.R centralise la table des statistiques CHD pour le mode IRaMuTeQ-like.
+
+formatter_6_decimales_chd <- function(x) {
+  ifelse(is.na(x), NA_character_, formatC(as.numeric(x), format = "f", digits = 6))
+}
+
+.inferer_type_terme_iramuteq <- function(termes) {
+  x <- tolower(as.character(termes))
+  out <- rep("", length(x))
+
+  extraire_tag <- function(pattern, value) {
+    idx <- grepl(pattern, x)
+    out[idx] <<- value
+  }
+
+  extraire_tag("(^|[_/])nom$", "nom")
+  extraire_tag("(^|[_/])adj$", "adj")
+  extraire_tag("(^|[_/])ver$", "ver")
+  extraire_tag("(^|[_/])adv$", "adv")
+  extraire_tag("(^|[_/])nr$", "nr")
+
+  out
+}
+
+.normaliser_type_terme_iramuteq <- function(type_vals, termes) {
+  types <- tolower(trimws(as.character(type_vals)))
+  types[is.na(types)] <- ""
+  types[types %in% c("", "na", "nan", "null")] <- ""
+
+  types_inf <- .inferer_type_terme_iramuteq(termes)
+  idx_manquant <- !nzchar(types)
+  types[idx_manquant] <- types_inf[idx_manquant]
+  types
+}
+
+extraire_stats_chd_classe <- function(res_stats_df,
+                                      classe,
+                                      n_max = 50,
+                                      show_negative = FALSE,
+                                      max_p = 1,
+                                      seuil_p_significativite = 0.05,
+                                      style = c("iramuteq_clone", "legacy")) {
+  style <- match.arg(style)
+
+  if (is.null(res_stats_df) || nrow(res_stats_df) == 0) {
+    return(data.frame(Message = "Statistiques indisponibles.", stringsAsFactors = FALSE))
+  }
+
+  cl <- suppressWarnings(as.numeric(classe))
+  df <- res_stats_df
+  if (is.finite(cl) && !is.na(cl) && "Classe" %in% names(df)) {
+    df <- df[suppressWarnings(as.numeric(df$Classe)) == cl, , drop = FALSE]
+  }
+
+  colonnes_possibles <- intersect(
+    c("Terme", "chi2", "lr", "frequency", "docprop", "eff_st", "eff_total", "pourcentage", "p", "p_value", "p_value_filter", "Type", "type", "pos", "POS"),
+    names(df)
+  )
+  df <- df[, colonnes_possibles, drop = FALSE]
+
+  if ("p" %in% names(df) && is.finite(max_p) && !is.na(max_p) && max_p < 1) {
+    df <- df[suppressWarnings(as.numeric(df$p)) <= max_p, , drop = FALSE]
+  }
+
+  if ("chi2" %in% names(df)) {
+    chi2_vals <- suppressWarnings(as.numeric(df$chi2))
+    if (!isTRUE(show_negative)) {
+      df <- df[is.finite(chi2_vals) & chi2_vals > 0, , drop = FALSE]
+      chi2_vals <- suppressWarnings(as.numeric(df$chi2))
+    }
+
+    frequency_vals <- rep(-Inf, nrow(df))
+    if ("frequency" %in% names(df)) {
+      frequency_vals <- suppressWarnings(as.numeric(df$frequency))
+      frequency_vals[!is.finite(frequency_vals)] <- -Inf
+    }
+
+    chi2_sort <- chi2_vals
+    chi2_sort[!is.finite(chi2_sort)] <- -Inf
+    df <- df[order(-chi2_sort, -frequency_vals), , drop = FALSE]
+  }
+  df <- utils::head(df, n_max)
+
+  if (identical(style, "iramuteq_clone")) {
+    eff_st <- if ("eff_st" %in% names(df)) suppressWarnings(as.numeric(df$eff_st)) else round(suppressWarnings(as.numeric(df$docprop)) * suppressWarnings(as.numeric(df$eff_total)))
+    eff_total <- if ("eff_total" %in% names(df)) suppressWarnings(as.numeric(df$eff_total)) else suppressWarnings(as.numeric(df$frequency))
+    pourcentage <- if ("pourcentage" %in% names(df)) suppressWarnings(as.numeric(df$pourcentage)) else ifelse(eff_total > 0, 100 * eff_st / eff_total, NA_real_)
+    chi2_vals <- if ("chi2" %in% names(df)) suppressWarnings(as.numeric(df$chi2)) else NA_real_
+    p_vals <- if ("p" %in% names(df)) suppressWarnings(as.numeric(df$p)) else if ("p_value" %in% names(df)) suppressWarnings(as.numeric(df$p_value)) else NA_real_
+    formes <- if ("Terme" %in% names(df)) as.character(df$Terme) else rep("", nrow(df))
+    type_source <- if ("Type" %in% names(df)) df$Type else if ("type" %in% names(df)) df$type else if ("pos" %in% names(df)) df$pos else if ("POS" %in% names(df)) df$POS else rep("", nrow(df))
+    types <- .normaliser_type_terme_iramuteq(type_source, formes)
+
+    out <- data.frame(
+      num = seq_len(nrow(df)) - 1L,
+      forme = formes,
+      `eff. s.t.` = as.integer(round(eff_st)),
+      `eff. total` = as.integer(round(eff_total)),
+      pourcentage = ifelse(is.na(pourcentage), NA_character_, formatC(pourcentage, format = "f", digits = 2)),
+      chi2 = ifelse(is.na(chi2_vals), NA_character_, formatC(chi2_vals, format = "f", digits = 3)),
+      `p.value` = ifelse(is.na(p_vals), NA_character_, formatC(p_vals, format = "f", digits = 6)),
+      `p.value < 0.01` = ifelse(!is.na(p_vals) & p_vals < 0.01, "Oui", ""),
+      Type = types,
+      check.names = FALSE,
+      stringsAsFactors = FALSE
+    )
+
+    seuil_sig <- suppressWarnings(as.numeric(seuil_p_significativite))
+    if (is.finite(seuil_sig) && !is.na(seuil_sig) && nrow(out) > 0) {
+      idx_non_signif <- !is.na(p_vals) & p_vals > seuil_sig
+      if (any(idx_non_signif)) {
+        colonnes_colorables <- names(out)
+        out[idx_non_signif, colonnes_colorables] <- lapply(out[idx_non_signif, colonnes_colorables, drop = FALSE], function(col_vals) {
+          ifelse(
+            is.na(col_vals),
+            NA_character_,
+            sprintf("<span style='color:#842029;'>%s</span>", as.character(col_vals))
+          )
+        })
+      }
+    }
+
+    return(out)
+  }
+
+  colonnes_num <- intersect(c("chi2", "lr", "docprop", "p", "p_value"), names(df))
+  for (col in colonnes_num) {
+    df[[col]] <- formatter_6_decimales_chd(df[[col]])
+  }
+
+  if ("frequency" %in% names(df)) {
+    df$frequency <- ifelse(is.na(df$frequency), NA_character_, formatC(as.numeric(df$frequency), format = "f", digits = 6))
+  }
+
+  df
+}

iramuteq-like/textprepa_iramuteq.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Préparation de corpus IRaMuTeQ-like (branche lexique_fr) pour audit de reproductibilité.
+
+Entrée  : TSV (doc_id, text)
+Sortie  : TSV (doc_id, text_prepared)
+Optionnel: TSV de tokens (doc_id, token)
+
+Objectif:
+- Reproduire au plus près le pré-nettoyage de `nettoyage.R`
+- Offrir un point d'audit unique pour comparer les formes avec IRaMuTeQ desktop
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import re
+from typing import Iterable, List, Tuple
+
+ALLOWED_CHARS = "a-zA-Z0-9àÀâÂäÄáÁåÅãéÉèÈêÊëËìÌîÎïÏíÍóÓòÒôÔöÖõÕøØùÙûÛüÜúÚçÇßœŒ’ñÑ\\.:,;!\\?'"
+RE_REMOVE_DISALLOWED = re.compile(rf"[^{ALLOWED_CHARS}]")
+RE_MULTI_SPACES = re.compile(r"\s+")
+RE_NUMBERS = re.compile(r"[0-9]+")
+# Équivalent pratique de (?i)\b(?:[cdjlmnst]|qu)['’`´ʼʹ](?=\p{L})
+RE_FR_ELISIONS = re.compile(r"(?i)\b(?:[cdjlmnst]|qu)['’`´ʼʹ](?=[A-Za-zÀ-ÖØ-öø-ÿŒœ])")
+# Token "mot" avec apostrophe interne possible
+RE_WORD = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿŒœ0-9]+(?:['’][A-Za-zÀ-ÖØ-öø-ÿŒœ0-9]+)*")
+
+
+def read_tsv(path: str) -> Tuple[List[str], List[str]]:
+    ids: List[str] = []
+    texts: List[str] = []
+    with open(path, "r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        if reader.fieldnames is None or "doc_id" not in reader.fieldnames or "text" not in reader.fieldnames:
+            raise ValueError("TSV invalide: colonnes attendues 'doc_id' et 'text'.")
+        for row in reader:
+            ids.append((row.get("doc_id") or "").strip())
+            texts.append(row.get("text") or "")
+    return ids, texts
+
+
+def write_tsv(path: str, ids: Iterable[str], texts: Iterable[str]) -> None:
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["doc_id", "text"], delimiter="\t")
+        writer.writeheader()
+        for did, txt in zip(ids, texts):
+            writer.writerow({"doc_id": did, "text": txt})
+
+
+def write_tokens(path: str, rows: List[Tuple[str, str]]) -> None:
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["doc_id", "token"], delimiter="\t")
+        writer.writeheader()
+        for did, tok in rows:
+            writer.writerow({"doc_id": did, "token": tok})
+
+
+def prepare_text(
+    text: str,
+    nettoyer_caracteres: bool,
+    lower: bool,
+    remove_numbers: bool,
+    strip_fr_elisions: bool,
+) -> str:
+    out = text.replace("\u00A0", " ")
+
+    if remove_numbers:
+        out = RE_NUMBERS.sub(" ", out)
+
+    if strip_fr_elisions:
+        out = RE_FR_ELISIONS.sub("", out)
+
+    if nettoyer_caracteres:
+        out = RE_REMOVE_DISALLOWED.sub(" ", out)
+
+    out = RE_MULTI_SPACES.sub(" ", out).strip()
+
+    if lower:
+        out = out.lower()
+
+    return out
+
+
+def tokenize(prepared: str, remove_numbers: bool, lower_tokens: bool) -> List[str]:
+    tokens = RE_WORD.findall(prepared)
+    if remove_numbers:
+        tokens = [t for t in tokens if not t.isdigit()]
+    if lower_tokens:
+        tokens = [t.lower() for t in tokens]
+    return tokens
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    p.add_argument("--input", required=True, help="TSV entrée (doc_id, text)")
+    p.add_argument("--output", required=True, help="TSV sortie (doc_id, text préparé)")
+    p.add_argument("--nettoyage_caracteres", default="0", help="1 pour activer le nettoyage des caractères")
+    p.add_argument("--forcer_minuscules_avant", default="0", help="1 pour forcer les minuscules")
+    p.add_argument("--supprimer_chiffres", default="0", help="1 pour supprimer les chiffres")
+    p.add_argument("--supprimer_apostrophes", default="0", help="1 pour retirer les élisions FR (c', d', l', qu', ...)")
+    p.add_argument("--output_tokens", default="", help="TSV optionnel de tokens (doc_id, token)")
+    args = p.parse_args()
+
+    nettoyer_caracteres = str(args.nettoyage_caracteres).strip() == "1"
+    lower = str(args.forcer_minuscules_avant).strip() == "1"
+    remove_numbers = str(args.supprimer_chiffres).strip() == "1"
+    strip_fr_elisions = str(args.supprimer_apostrophes).strip() == "1"
+
+    ids, texts = read_tsv(args.input)
+
+    prepared = [
+        prepare_text(
+            t,
+            nettoyer_caracteres=nettoyer_caracteres,
+            lower=lower,
+            remove_numbers=remove_numbers,
+            strip_fr_elisions=strip_fr_elisions,
+        )
+        for t in texts
+    ]
+
+    write_tsv(args.output, ids, prepared)
+
+    if args.output_tokens:
+        rows: List[Tuple[str, str]] = []
+        for did, txt in zip(ids, prepared):
+            for tok in tokenize(txt, remove_numbers=remove_numbers, lower_tokens=True):
+                rows.append((did, tok))
+        write_tokens(args.output_tokens, rows)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

iramuteq-like/ui_options_iramuteq.R

@@ -0,0 +1,36 @@
+# Rôle du fichier: iramuteq-like/ui_options_iramuteq.R définit les options UI
+# spécifiques au mode IRaMuTeQ-like.
+
+library(shiny)
+
+ui_options_iramuteq <- function() {
+  tagList(
+    tags$div(class = "sidebar-section-title", "Paramètres CHD (IRaMuTeQ-like)"),
+    numericInput("k_iramuteq", "Nombre de classes terminales de la phase 1", value = 10, min = 2, step = 1),
+    radioButtons(
+      "iramuteq_mincl_mode",
+      "Nombre minimum d'UCE par classe terminale (mincl)",
+      choices = c("Automatique" = "auto", "Manuel" = "manuel"),
+      selected = "auto",
+      inline = FALSE
+    ),
+    conditionalPanel(
+      condition = "input.iramuteq_mincl_mode == 'manuel'",
+      numericInput("iramuteq_mincl", "mincl (manuel)", value = 5, min = 1, step = 1)
+    ),
+    radioButtons(
+      "iramuteq_classif_mode",
+      "Type de classification terminale",
+      choices = c("Simple" = "simple", "Double" = "double"),
+      selected = "simple",
+      inline = FALSE
+    ),
+    selectInput(
+      "iramuteq_svd_method",
+      "Méthode SVD",
+      choices = c("irlba" = "irlba", "svdR" = "svdR"),
+      selected = "irlba"
+    ),
+    checkboxInput("iramuteq_mode_patate", "Mode patate (moins précis, plus rapide)", value = FALSE)
+  )
+}

iramuteq-like/wordcloud_iramuteq.R

@@ -0,0 +1,69 @@
+# Rôle du fichier: générer des nuages de mots dédiés au mode IRaMuTeQ-like.
+
+generer_wordclouds_iramuteq <- function(res_stats_df,
+                                        classes_uniques,
+                                        wordcloud_dir,
+                                        top_n = 20L,
+                                        filtrer_pvalue = FALSE,
+                                        max_p = 1) {
+  if (is.null(res_stats_df) || !is.data.frame(res_stats_df) || nrow(res_stats_df) == 0) {
+    return(invisible(NULL))
+  }
+
+  dir.create(wordcloud_dir, showWarnings = FALSE, recursive = TRUE)
+
+  top_n <- suppressWarnings(as.integer(top_n))
+  if (!is.finite(top_n) || is.na(top_n)) top_n <- 20L
+  top_n <- max(5L, top_n)
+
+  classe_col <- if ("Classe" %in% names(res_stats_df)) "Classe" else NULL
+  terme_col <- if ("Terme" %in% names(res_stats_df)) "Terme" else if ("forme" %in% names(res_stats_df)) "forme" else NULL
+  chi2_col <- if ("chi2" %in% names(res_stats_df)) "chi2" else NULL
+  p_col <- if ("p" %in% names(res_stats_df)) "p" else if ("p_value" %in% names(res_stats_df)) "p_value" else NULL
+
+  if (is.null(classe_col) || is.null(terme_col) || is.null(chi2_col)) {
+    return(invisible(NULL))
+  }
+
+  classes_num <- suppressWarnings(as.numeric(res_stats_df[[classe_col]]))
+
+  for (cl in classes_uniques) {
+    cl_num <- suppressWarnings(as.numeric(cl))
+    if (!is.finite(cl_num) || is.na(cl_num)) next
+
+    df_stats_cl <- res_stats_df[is.finite(classes_num) & !is.na(classes_num) & classes_num == cl_num, , drop = FALSE]
+    if (nrow(df_stats_cl) == 0) next
+
+    if (isTRUE(filtrer_pvalue) && !is.null(p_col) && is.finite(max_p) && !is.na(max_p)) {
+      p_vals <- suppressWarnings(as.numeric(df_stats_cl[[p_col]]))
+      df_stats_cl <- df_stats_cl[is.finite(p_vals) & !is.na(p_vals) & p_vals <= max_p, , drop = FALSE]
+    }
+    if (nrow(df_stats_cl) == 0) next
+
+    chi2_vals <- suppressWarnings(as.numeric(df_stats_cl[[chi2_col]]))
+    df_stats_cl <- df_stats_cl[is.finite(chi2_vals) & !is.na(chi2_vals), , drop = FALSE]
+    if (nrow(df_stats_cl) == 0) next
+
+    chi2_vals <- suppressWarnings(as.numeric(df_stats_cl[[chi2_col]]))
+    df_stats_cl <- df_stats_cl[order(-chi2_vals), , drop = FALSE]
+    df_stats_cl <- head(df_stats_cl, top_n)
+
+    wc_png <- file.path(wordcloud_dir, paste0("cluster_", cl, "_wordcloud.png"))
+    try({
+      png(wc_png, width = 800, height = 600)
+      chi2_vals <- suppressWarnings(as.numeric(df_stats_cl[[chi2_col]]))
+      suppressWarnings(wordcloud::wordcloud(
+        words = as.character(df_stats_cl[[terme_col]]),
+        freq = pmax(chi2_vals, 0),
+        scale = c(8, 0.8),
+        min.freq = 0,
+        random.order = FALSE,
+        max.words = nrow(df_stats_cl),
+        colors = RColorBrewer::brewer.pal(8, "Dark2")
+      ))
+      dev.off()
+    }, silent = TRUE)
+  }
+
+  invisible(NULL)
+}

penguins.csv

@@ -0,0 +1,345 @@
+Species,Island,Bill Length (mm),Bill Depth (mm),Flipper Length (mm),Body Mass (g),Sex,Year
+Adelie,Torgersen,39.1,18.7,181,3750,male,2007
+Adelie,Torgersen,39.5,17.4,186,3800,female,2007
+Adelie,Torgersen,40.3,18,195,3250,female,2007
+Adelie,Torgersen,NA,NA,NA,NA,NA,2007
+Adelie,Torgersen,36.7,19.3,193,3450,female,2007
+Adelie,Torgersen,39.3,20.6,190,3650,male,2007
+Adelie,Torgersen,38.9,17.8,181,3625,female,2007
+Adelie,Torgersen,39.2,19.6,195,4675,male,2007
+Adelie,Torgersen,34.1,18.1,193,3475,NA,2007
+Adelie,Torgersen,42,20.2,190,4250,NA,2007
+Adelie,Torgersen,37.8,17.1,186,3300,NA,2007
+Adelie,Torgersen,37.8,17.3,180,3700,NA,2007
+Adelie,Torgersen,41.1,17.6,182,3200,female,2007
+Adelie,Torgersen,38.6,21.2,191,3800,male,2007
+Adelie,Torgersen,34.6,21.1,198,4400,male,2007
+Adelie,Torgersen,36.6,17.8,185,3700,female,2007
+Adelie,Torgersen,38.7,19,195,3450,female,2007
+Adelie,Torgersen,42.5,20.7,197,4500,male,2007
+Adelie,Torgersen,34.4,18.4,184,3325,female,2007
+Adelie,Torgersen,46,21.5,194,4200,male,2007
+Adelie,Biscoe,37.8,18.3,174,3400,female,2007
+Adelie,Biscoe,37.7,18.7,180,3600,male,2007
+Adelie,Biscoe,35.9,19.2,189,3800,female,2007
+Adelie,Biscoe,38.2,18.1,185,3950,male,2007
+Adelie,Biscoe,38.8,17.2,180,3800,male,2007
+Adelie,Biscoe,35.3,18.9,187,3800,female,2007
+Adelie,Biscoe,40.6,18.6,183,3550,male,2007
+Adelie,Biscoe,40.5,17.9,187,3200,female,2007
+Adelie,Biscoe,37.9,18.6,172,3150,female,2007
+Adelie,Biscoe,40.5,18.9,180,3950,male,2007
+Adelie,Dream,39.5,16.7,178,3250,female,2007
+Adelie,Dream,37.2,18.1,178,3900,male,2007
+Adelie,Dream,39.5,17.8,188,3300,female,2007
+Adelie,Dream,40.9,18.9,184,3900,male,2007
+Adelie,Dream,36.4,17,195,3325,female,2007
+Adelie,Dream,39.2,21.1,196,4150,male,2007
+Adelie,Dream,38.8,20,190,3950,male,2007
+Adelie,Dream,42.2,18.5,180,3550,female,2007
+Adelie,Dream,37.6,19.3,181,3300,female,2007
+Adelie,Dream,39.8,19.1,184,4650,male,2007
+Adelie,Dream,36.5,18,182,3150,female,2007
+Adelie,Dream,40.8,18.4,195,3900,male,2007
+Adelie,Dream,36,18.5,186,3100,female,2007
+Adelie,Dream,44.1,19.7,196,4400,male,2007
+Adelie,Dream,37,16.9,185,3000,female,2007
+Adelie,Dream,39.6,18.8,190,4600,male,2007
+Adelie,Dream,41.1,19,182,3425,male,2007
+Adelie,Dream,37.5,18.9,179,2975,NA,2007
+Adelie,Dream,36,17.9,190,3450,female,2007
+Adelie,Dream,42.3,21.2,191,4150,male,2007
+Adelie,Biscoe,39.6,17.7,186,3500,female,2008
+Adelie,Biscoe,40.1,18.9,188,4300,male,2008
+Adelie,Biscoe,35,17.9,190,3450,female,2008
+Adelie,Biscoe,42,19.5,200,4050,male,2008
+Adelie,Biscoe,34.5,18.1,187,2900,female,2008
+Adelie,Biscoe,41.4,18.6,191,3700,male,2008
+Adelie,Biscoe,39,17.5,186,3550,female,2008
+Adelie,Biscoe,40.6,18.8,193,3800,male,2008
+Adelie,Biscoe,36.5,16.6,181,2850,female,2008
+Adelie,Biscoe,37.6,19.1,194,3750,male,2008
+Adelie,Biscoe,35.7,16.9,185,3150,female,2008
+Adelie,Biscoe,41.3,21.1,195,4400,male,2008
+Adelie,Biscoe,37.6,17,185,3600,female,2008
+Adelie,Biscoe,41.1,18.2,192,4050,male,2008
+Adelie,Biscoe,36.4,17.1,184,2850,female,2008
+Adelie,Biscoe,41.6,18,192,3950,male,2008
+Adelie,Biscoe,35.5,16.2,195,3350,female,2008
+Adelie,Biscoe,41.1,19.1,188,4100,male,2008
+Adelie,Torgersen,35.9,16.6,190,3050,female,2008
+Adelie,Torgersen,41.8,19.4,198,4450,male,2008
+Adelie,Torgersen,33.5,19,190,3600,female,2008
+Adelie,Torgersen,39.7,18.4,190,3900,male,2008
+Adelie,Torgersen,39.6,17.2,196,3550,female,2008
+Adelie,Torgersen,45.8,18.9,197,4150,male,2008
+Adelie,Torgersen,35.5,17.5,190,3700,female,2008
+Adelie,Torgersen,42.8,18.5,195,4250,male,2008
+Adelie,Torgersen,40.9,16.8,191,3700,female,2008
+Adelie,Torgersen,37.2,19.4,184,3900,male,2008
+Adelie,Torgersen,36.2,16.1,187,3550,female,2008
+Adelie,Torgersen,42.1,19.1,195,4000,male,2008
+Adelie,Torgersen,34.6,17.2,189,3200,female,2008
+Adelie,Torgersen,42.9,17.6,196,4700,male,2008
+Adelie,Torgersen,36.7,18.8,187,3800,female,2008
+Adelie,Torgersen,35.1,19.4,193,4200,male,2008
+Adelie,Dream,37.3,17.8,191,3350,female,2008
+Adelie,Dream,41.3,20.3,194,3550,male,2008
+Adelie,Dream,36.3,19.5,190,3800,male,2008
+Adelie,Dream,36.9,18.6,189,3500,female,2008
+Adelie,Dream,38.3,19.2,189,3950,male,2008
+Adelie,Dream,38.9,18.8,190,3600,female,2008
+Adelie,Dream,35.7,18,202,3550,female,2008
+Adelie,Dream,41.1,18.1,205,4300,male,2008
+Adelie,Dream,34,17.1,185,3400,female,2008
+Adelie,Dream,39.6,18.1,186,4450,male,2008
+Adelie,Dream,36.2,17.3,187,3300,female,2008
+Adelie,Dream,40.8,18.9,208,4300,male,2008
+Adelie,Dream,38.1,18.6,190,3700,female,2008
+Adelie,Dream,40.3,18.5,196,4350,male,2008
+Adelie,Dream,33.1,16.1,178,2900,female,2008
+Adelie,Dream,43.2,18.5,192,4100,male,2008
+Adelie,Biscoe,35,17.9,192,3725,female,2009
+Adelie,Biscoe,41,20,203,4725,male,2009
+Adelie,Biscoe,37.7,16,183,3075,female,2009
+Adelie,Biscoe,37.8,20,190,4250,male,2009
+Adelie,Biscoe,37.9,18.6,193,2925,female,2009
+Adelie,Biscoe,39.7,18.9,184,3550,male,2009
+Adelie,Biscoe,38.6,17.2,199,3750,female,2009
+Adelie,Biscoe,38.2,20,190,3900,male,2009
+Adelie,Biscoe,38.1,17,181,3175,female,2009
+Adelie,Biscoe,43.2,19,197,4775,male,2009
+Adelie,Biscoe,38.1,16.5,198,3825,female,2009
+Adelie,Biscoe,45.6,20.3,191,4600,male,2009
+Adelie,Biscoe,39.7,17.7,193,3200,female,2009
+Adelie,Biscoe,42.2,19.5,197,4275,male,2009
+Adelie,Biscoe,39.6,20.7,191,3900,female,2009
+Adelie,Biscoe,42.7,18.3,196,4075,male,2009
+Adelie,Torgersen,38.6,17,188,2900,female,2009
+Adelie,Torgersen,37.3,20.5,199,3775,male,2009
+Adelie,Torgersen,35.7,17,189,3350,female,2009
+Adelie,Torgersen,41.1,18.6,189,3325,male,2009
+Adelie,Torgersen,36.2,17.2,187,3150,female,2009
+Adelie,Torgersen,37.7,19.8,198,3500,male,2009
+Adelie,Torgersen,40.2,17,176,3450,female,2009
+Adelie,Torgersen,41.4,18.5,202,3875,male,2009
+Adelie,Torgersen,35.2,15.9,186,3050,female,2009
+Adelie,Torgersen,40.6,19,199,4000,male,2009
+Adelie,Torgersen,38.8,17.6,191,3275,female,2009
+Adelie,Torgersen,41.5,18.3,195,4300,male,2009
+Adelie,Torgersen,39,17.1,191,3050,female,2009
+Adelie,Torgersen,44.1,18,210,4000,male,2009
+Adelie,Torgersen,38.5,17.9,190,3325,female,2009
+Adelie,Torgersen,43.1,19.2,197,3500,male,2009
+Adelie,Dream,36.8,18.5,193,3500,female,2009
+Adelie,Dream,37.5,18.5,199,4475,male,2009
+Adelie,Dream,38.1,17.6,187,3425,female,2009
+Adelie,Dream,41.1,17.5,190,3900,male,2009
+Adelie,Dream,35.6,17.5,191,3175,female,2009
+Adelie,Dream,40.2,20.1,200,3975,male,2009
+Adelie,Dream,37,16.5,185,3400,female,2009
+Adelie,Dream,39.7,17.9,193,4250,male,2009
+Adelie,Dream,40.2,17.1,193,3400,female,2009
+Adelie,Dream,40.6,17.2,187,3475,male,2009
+Adelie,Dream,32.1,15.5,188,3050,female,2009
+Adelie,Dream,40.7,17,190,3725,male,2009
+Adelie,Dream,37.3,16.8,192,3000,female,2009
+Adelie,Dream,39,18.7,185,3650,male,2009
+Adelie,Dream,39.2,18.6,190,4250,male,2009
+Adelie,Dream,36.6,18.4,184,3475,female,2009
+Adelie,Dream,36,17.8,195,3450,female,2009
+Adelie,Dream,37.8,18.1,193,3750,male,2009
+Adelie,Dream,36,17.1,187,3700,female,2009
+Adelie,Dream,41.5,18.5,201,4000,male,2009
+Gentoo,Biscoe,46.1,13.2,211,4500,female,2007
+Gentoo,Biscoe,50,16.3,230,5700,male,2007
+Gentoo,Biscoe,48.7,14.1,210,4450,female,2007
+Gentoo,Biscoe,50,15.2,218,5700,male,2007
+Gentoo,Biscoe,47.6,14.5,215,5400,male,2007
+Gentoo,Biscoe,46.5,13.5,210,4550,female,2007
+Gentoo,Biscoe,45.4,14.6,211,4800,female,2007
+Gentoo,Biscoe,46.7,15.3,219,5200,male,2007
+Gentoo,Biscoe,43.3,13.4,209,4400,female,2007
+Gentoo,Biscoe,46.8,15.4,215,5150,male,2007
+Gentoo,Biscoe,40.9,13.7,214,4650,female,2007
+Gentoo,Biscoe,49,16.1,216,5550,male,2007
+Gentoo,Biscoe,45.5,13.7,214,4650,female,2007
+Gentoo,Biscoe,48.4,14.6,213,5850,male,2007
+Gentoo,Biscoe,45.8,14.6,210,4200,female,2007
+Gentoo,Biscoe,49.3,15.7,217,5850,male,2007
+Gentoo,Biscoe,42,13.5,210,4150,female,2007
+Gentoo,Biscoe,49.2,15.2,221,6300,male,2007
+Gentoo,Biscoe,46.2,14.5,209,4800,female,2007
+Gentoo,Biscoe,48.7,15.1,222,5350,male,2007
+Gentoo,Biscoe,50.2,14.3,218,5700,male,2007
+Gentoo,Biscoe,45.1,14.5,215,5000,female,2007
+Gentoo,Biscoe,46.5,14.5,213,4400,female,2007
+Gentoo,Biscoe,46.3,15.8,215,5050,male,2007
+Gentoo,Biscoe,42.9,13.1,215,5000,female,2007
+Gentoo,Biscoe,46.1,15.1,215,5100,male,2007
+Gentoo,Biscoe,44.5,14.3,216,4100,NA,2007
+Gentoo,Biscoe,47.8,15,215,5650,male,2007
+Gentoo,Biscoe,48.2,14.3,210,4600,female,2007
+Gentoo,Biscoe,50,15.3,220,5550,male,2007
+Gentoo,Biscoe,47.3,15.3,222,5250,male,2007
+Gentoo,Biscoe,42.8,14.2,209,4700,female,2007
+Gentoo,Biscoe,45.1,14.5,207,5050,female,2007
+Gentoo,Biscoe,59.6,17,230,6050,male,2007
+Gentoo,Biscoe,49.1,14.8,220,5150,female,2008
+Gentoo,Biscoe,48.4,16.3,220,5400,male,2008
+Gentoo,Biscoe,42.6,13.7,213,4950,female,2008
+Gentoo,Biscoe,44.4,17.3,219,5250,male,2008
+Gentoo,Biscoe,44,13.6,208,4350,female,2008
+Gentoo,Biscoe,48.7,15.7,208,5350,male,2008
+Gentoo,Biscoe,42.7,13.7,208,3950,female,2008
+Gentoo,Biscoe,49.6,16,225,5700,male,2008
+Gentoo,Biscoe,45.3,13.7,210,4300,female,2008
+Gentoo,Biscoe,49.6,15,216,4750,male,2008
+Gentoo,Biscoe,50.5,15.9,222,5550,male,2008
+Gentoo,Biscoe,43.6,13.9,217,4900,female,2008
+Gentoo,Biscoe,45.5,13.9,210,4200,female,2008
+Gentoo,Biscoe,50.5,15.9,225,5400,male,2008
+Gentoo,Biscoe,44.9,13.3,213,5100,female,2008
+Gentoo,Biscoe,45.2,15.8,215,5300,male,2008
+Gentoo,Biscoe,46.6,14.2,210,4850,female,2008
+Gentoo,Biscoe,48.5,14.1,220,5300,male,2008
+Gentoo,Biscoe,45.1,14.4,210,4400,female,2008
+Gentoo,Biscoe,50.1,15,225,5000,male,2008
+Gentoo,Biscoe,46.5,14.4,217,4900,female,2008
+Gentoo,Biscoe,45,15.4,220,5050,male,2008
+Gentoo,Biscoe,43.8,13.9,208,4300,female,2008
+Gentoo,Biscoe,45.5,15,220,5000,male,2008
+Gentoo,Biscoe,43.2,14.5,208,4450,female,2008
+Gentoo,Biscoe,50.4,15.3,224,5550,male,2008
+Gentoo,Biscoe,45.3,13.8,208,4200,female,2008
+Gentoo,Biscoe,46.2,14.9,221,5300,male,2008
+Gentoo,Biscoe,45.7,13.9,214,4400,female,2008
+Gentoo,Biscoe,54.3,15.7,231,5650,male,2008
+Gentoo,Biscoe,45.8,14.2,219,4700,female,2008
+Gentoo,Biscoe,49.8,16.8,230,5700,male,2008
+Gentoo,Biscoe,46.2,14.4,214,4650,NA,2008
+Gentoo,Biscoe,49.5,16.2,229,5800,male,2008
+Gentoo,Biscoe,43.5,14.2,220,4700,female,2008
+Gentoo,Biscoe,50.7,15,223,5550,male,2008
+Gentoo,Biscoe,47.7,15,216,4750,female,2008
+Gentoo,Biscoe,46.4,15.6,221,5000,male,2008
+Gentoo,Biscoe,48.2,15.6,221,5100,male,2008
+Gentoo,Biscoe,46.5,14.8,217,5200,female,2008
+Gentoo,Biscoe,46.4,15,216,4700,female,2008
+Gentoo,Biscoe,48.6,16,230,5800,male,2008
+Gentoo,Biscoe,47.5,14.2,209,4600,female,2008
+Gentoo,Biscoe,51.1,16.3,220,6000,male,2008
+Gentoo,Biscoe,45.2,13.8,215,4750,female,2008
+Gentoo,Biscoe,45.2,16.4,223,5950,male,2008
+Gentoo,Biscoe,49.1,14.5,212,4625,female,2009
+Gentoo,Biscoe,52.5,15.6,221,5450,male,2009
+Gentoo,Biscoe,47.4,14.6,212,4725,female,2009
+Gentoo,Biscoe,50,15.9,224,5350,male,2009
+Gentoo,Biscoe,44.9,13.8,212,4750,female,2009
+Gentoo,Biscoe,50.8,17.3,228,5600,male,2009
+Gentoo,Biscoe,43.4,14.4,218,4600,female,2009
+Gentoo,Biscoe,51.3,14.2,218,5300,male,2009
+Gentoo,Biscoe,47.5,14,212,4875,female,2009
+Gentoo,Biscoe,52.1,17,230,5550,male,2009
+Gentoo,Biscoe,47.5,15,218,4950,female,2009
+Gentoo,Biscoe,52.2,17.1,228,5400,male,2009
+Gentoo,Biscoe,45.5,14.5,212,4750,female,2009
+Gentoo,Biscoe,49.5,16.1,224,5650,male,2009
+Gentoo,Biscoe,44.5,14.7,214,4850,female,2009
+Gentoo,Biscoe,50.8,15.7,226,5200,male,2009
+Gentoo,Biscoe,49.4,15.8,216,4925,male,2009
+Gentoo,Biscoe,46.9,14.6,222,4875,female,2009
+Gentoo,Biscoe,48.4,14.4,203,4625,female,2009
+Gentoo,Biscoe,51.1,16.5,225,5250,male,2009
+Gentoo,Biscoe,48.5,15,219,4850,female,2009
+Gentoo,Biscoe,55.9,17,228,5600,male,2009
+Gentoo,Biscoe,47.2,15.5,215,4975,female,2009
+Gentoo,Biscoe,49.1,15,228,5500,male,2009
+Gentoo,Biscoe,47.3,13.8,216,4725,NA,2009
+Gentoo,Biscoe,46.8,16.1,215,5500,male,2009
+Gentoo,Biscoe,41.7,14.7,210,4700,female,2009
+Gentoo,Biscoe,53.4,15.8,219,5500,male,2009
+Gentoo,Biscoe,43.3,14,208,4575,female,2009
+Gentoo,Biscoe,48.1,15.1,209,5500,male,2009
+Gentoo,Biscoe,50.5,15.2,216,5000,female,2009
+Gentoo,Biscoe,49.8,15.9,229,5950,male,2009
+Gentoo,Biscoe,43.5,15.2,213,4650,female,2009
+Gentoo,Biscoe,51.5,16.3,230,5500,male,2009
+Gentoo,Biscoe,46.2,14.1,217,4375,female,2009
+Gentoo,Biscoe,55.1,16,230,5850,male,2009
+Gentoo,Biscoe,44.5,15.7,217,4875,NA,2009
+Gentoo,Biscoe,48.8,16.2,222,6000,male,2009
+Gentoo,Biscoe,47.2,13.7,214,4925,female,2009
+Gentoo,Biscoe,NA,NA,NA,NA,NA,2009
+Gentoo,Biscoe,46.8,14.3,215,4850,female,2009
+Gentoo,Biscoe,50.4,15.7,222,5750,male,2009
+Gentoo,Biscoe,45.2,14.8,212,5200,female,2009
+Gentoo,Biscoe,49.9,16.1,213,5400,male,2009
+Chinstrap,Dream,46.5,17.9,192,3500,female,2007
+Chinstrap,Dream,50,19.5,196,3900,male,2007
+Chinstrap,Dream,51.3,19.2,193,3650,male,2007
+Chinstrap,Dream,45.4,18.7,188,3525,female,2007
+Chinstrap,Dream,52.7,19.8,197,3725,male,2007
+Chinstrap,Dream,45.2,17.8,198,3950,female,2007
+Chinstrap,Dream,46.1,18.2,178,3250,female,2007
+Chinstrap,Dream,51.3,18.2,197,3750,male,2007
+Chinstrap,Dream,46,18.9,195,4150,female,2007
+Chinstrap,Dream,51.3,19.9,198,3700,male,2007
+Chinstrap,Dream,46.6,17.8,193,3800,female,2007
+Chinstrap,Dream,51.7,20.3,194,3775,male,2007
+Chinstrap,Dream,47,17.3,185,3700,female,2007
+Chinstrap,Dream,52,18.1,201,4050,male,2007
+Chinstrap,Dream,45.9,17.1,190,3575,female,2007
+Chinstrap,Dream,50.5,19.6,201,4050,male,2007
+Chinstrap,Dream,50.3,20,197,3300,male,2007
+Chinstrap,Dream,58,17.8,181,3700,female,2007
+Chinstrap,Dream,46.4,18.6,190,3450,female,2007
+Chinstrap,Dream,49.2,18.2,195,4400,male,2007
+Chinstrap,Dream,42.4,17.3,181,3600,female,2007
+Chinstrap,Dream,48.5,17.5,191,3400,male,2007
+Chinstrap,Dream,43.2,16.6,187,2900,female,2007
+Chinstrap,Dream,50.6,19.4,193,3800,male,2007
+Chinstrap,Dream,46.7,17.9,195,3300,female,2007
+Chinstrap,Dream,52,19,197,4150,male,2007
+Chinstrap,Dream,50.5,18.4,200,3400,female,2008
+Chinstrap,Dream,49.5,19,200,3800,male,2008
+Chinstrap,Dream,46.4,17.8,191,3700,female,2008
+Chinstrap,Dream,52.8,20,205,4550,male,2008
+Chinstrap,Dream,40.9,16.6,187,3200,female,2008
+Chinstrap,Dream,54.2,20.8,201,4300,male,2008
+Chinstrap,Dream,42.5,16.7,187,3350,female,2008
+Chinstrap,Dream,51,18.8,203,4100,male,2008
+Chinstrap,Dream,49.7,18.6,195,3600,male,2008
+Chinstrap,Dream,47.5,16.8,199,3900,female,2008
+Chinstrap,Dream,47.6,18.3,195,3850,female,2008
+Chinstrap,Dream,52,20.7,210,4800,male,2008
+Chinstrap,Dream,46.9,16.6,192,2700,female,2008
+Chinstrap,Dream,53.5,19.9,205,4500,male,2008
+Chinstrap,Dream,49,19.5,210,3950,male,2008
+Chinstrap,Dream,46.2,17.5,187,3650,female,2008
+Chinstrap,Dream,50.9,19.1,196,3550,male,2008
+Chinstrap,Dream,45.5,17,196,3500,female,2008
+Chinstrap,Dream,50.9,17.9,196,3675,female,2009
+Chinstrap,Dream,50.8,18.5,201,4450,male,2009
+Chinstrap,Dream,50.1,17.9,190,3400,female,2009
+Chinstrap,Dream,49,19.6,212,4300,male,2009
+Chinstrap,Dream,51.5,18.7,187,3250,male,2009
+Chinstrap,Dream,49.8,17.3,198,3675,female,2009
+Chinstrap,Dream,48.1,16.4,199,3325,female,2009
+Chinstrap,Dream,51.4,19,201,3950,male,2009
+Chinstrap,Dream,45.7,17.3,193,3600,female,2009
+Chinstrap,Dream,50.7,19.7,203,4050,male,2009
+Chinstrap,Dream,42.5,17.3,187,3350,female,2009
+Chinstrap,Dream,52.2,18.8,197,3450,male,2009
+Chinstrap,Dream,45.2,16.6,191,3250,female,2009
+Chinstrap,Dream,49.3,19.9,203,4050,male,2009
+Chinstrap,Dream,50.2,18.8,202,3800,male,2009
+Chinstrap,Dream,45.6,19.4,194,3525,female,2009
+Chinstrap,Dream,51.9,19.5,206,3950,male,2009
+Chinstrap,Dream,46.8,16.5,189,3650,female,2009
+Chinstrap,Dream,45.7,17,195,3650,female,2009
+Chinstrap,Dream,55.8,19.8,207,4000,male,2009
+Chinstrap,Dream,43.5,18.1,202,3400,female,2009
+Chinstrap,Dream,49.6,18.2,193,3775,male,2009
+Chinstrap,Dream,50.8,19,210,4100,male,2009
+Chinstrap,Dream,50.2,18.7,198,3775,female,2009

ui.R

@@ -0,0 +1,421 @@
+# Rôle du fichier: ui.R porte une partie du pipeline d'analyse Rainette.
+# ui.R
+
+library(shiny)
+library(htmltools)
+
+
+if (!exists("ui_options_iramuteq", mode = "function", inherits = TRUE)) {
+  app_dir <- tryCatch(shiny::getShinyOption("appDir"), error = function(e) NULL)
+  if (is.null(app_dir) || !nzchar(app_dir)) app_dir <- getwd()
+  chemin_options_iramuteq <- file.path(app_dir, "iramuteq-like", "ui_options_iramuteq.R")
+
+  if (file.exists(chemin_options_iramuteq)) {
+    source(chemin_options_iramuteq, encoding = "UTF-8", local = TRUE)
+  }
+}
+
+
+if (!exists("ui_resultats_chd_iramuteq", mode = "function", inherits = TRUE)) {
+  app_dir <- tryCatch(shiny::getShinyOption("appDir"), error = function(e) NULL)
+  if (is.null(app_dir) || !nzchar(app_dir)) app_dir <- getwd()
+  chemin_affichage_iramuteq <- file.path(app_dir, "iramuteq-like", "affichage_iramuteq-like.R")
+
+  if (file.exists(chemin_affichage_iramuteq)) {
+    source(chemin_affichage_iramuteq, encoding = "UTF-8", local = TRUE)
+  }
+}
+
+if (!exists("ui_aide_huggingface", mode = "function")) {
+  if (file.exists("help.md")) {
+    ui_aide_huggingface <- function() {
+      tagList(
+        tags$h2("Aide"),
+        includeMarkdown("help/help.md")
+      )
+    }
+  } else {
+    ui_aide_huggingface <- function() {
+      tagList(
+        tags$h2("Aide"),
+        tags$p("Le fichier help.md est introuvable. Ajoute help.md à la racine du projet.")
+      )
+    }
+  }
+}
+
+if (!exists("REGEX_CARACTERES_A_SUPPRIMER", inherits = TRUE)) {
+  app_dir <- tryCatch(shiny::getShinyOption("appDir"), error = function(e) NULL)
+  if (is.null(app_dir) || !nzchar(app_dir)) app_dir <- getwd()
+  chemin_nettoyage <- file.path(app_dir, "rainette", "nettoyage_rainette.R")
+
+  if (file.exists(chemin_nettoyage)) {
+    source(chemin_nettoyage, encoding = "UTF-8", local = TRUE)
+  }
+}
+
+if (!exists("REGEX_CARACTERES_A_SUPPRIMER", inherits = TRUE)) {
+  # Fallback explicite : évite d'afficher un message d'erreur permanent dans l'UI
+  # quand le fichier rainette/nettoyage_rainette.R n'a pas pu être sourcé dans cet environnement.
+  REGEX_CARACTERES_AUTORISES <- "a-zA-Z0-9àÀâÂäÄáÁåÅãéÉèÈêÊëËìÌîÎïÏíÍóÓòÒôÔöÖõÕøØùÙûÛüÜúÚçÇßœŒ’ñÑ\\.:,;!\\?'"
+  REGEX_CARACTERES_A_SUPPRIMER <- paste0("[^", REGEX_CARACTERES_AUTORISES, "]")
+}
+
+ui <- fluidPage(
+  tags$head(
+    tags$style(HTML("
+      #shiny-modal .modal-dialog {
+        width: 96vw !important;
+        max-width: 96vw !important;
+      }
+      #shiny-modal .modal-body {
+        max-height: 88vh !important;
+        overflow-y: auto !important;
+      }
+      .sidebar-section-title {
+        font-weight: 700;
+        font-size: 18px !important;
+        color: #1e5aa8 !important;
+        margin-top: 12px;
+        margin-bottom: 6px;
+      }
+      small {
+        color: #842029 !important;
+      }
+    "))
+  ),
+
+  tags$h2(
+    style = "color: #1e5aa8;",
+    "IRaMuTeQ-Lite"
+  ),
+  tags$p(
+    style = "font-size: 14px;",
+    "Tentaive de reproduction de la CHD (Méthode Reinert) du logiciel IRaMuTeQ",
+    tags$br(),
+    "En test j'ai également expérimenté la recherche de NER dans le corpus s'appuyant sur la librairie Spacy (modele \"md\").",
+    tags$br(),
+    "Pour plus d’informations, vous pouvez consulter mon site : www.codeandcortex.fr",
+    tags$br(),
+    "version beta 0.4 - 18-02-2026"
+  ),
+
+  sidebarLayout(
+    sidebarPanel(
+      fileInput("fichier_corpus", "Uploader un corpus IRaMuTeQ (.txt)", accept = c(".txt")),
+
+      radioButtons(
+        "modele_chd",
+        "Méthode Iramuteq-like",
+        choices = c(
+          "IRaMuTeQ-like" = "iramuteq"
+        ),
+        selected = "iramuteq",
+        inline = FALSE
+      ),
+
+      tags$div(class = "sidebar-section-title", "Paramètres communs CHD"),
+      numericInput("segment_size", "segment_size", value = 40, min = 5, step = 1),
+      numericInput("min_docfreq", "Fréquence minimale des termes (min_docfreq)", value = 3, min = 1, step = 1),
+      numericInput("max_p", "max_p (p-value)", value = 0.05, min = 0, max = 1, step = 0.01),
+      checkboxInput(
+        "filtrer_affichage_pvalue",
+        "Filtrer l'affichage des résultats par p-value (p ≤ max_p)",
+        value = TRUE
+      ),
+
+      conditionalPanel(
+        condition = "input.modele_chd == 'rainette'",
+        ui_options_rainette()
+      ),
+
+      conditionalPanel(
+        condition = "input.modele_chd == 'iramuteq'",
+        ui_options_iramuteq()
+      ),
+
+      tags$div(class = "sidebar-section-title", "Dictionnaire"),
+      radioButtons(
+        "source_dictionnaire",
+        "Source de lemmatisation",
+        choices = c("spaCy" = "spacy", "Lexique (fr)" = "lexique_fr"),
+        selected = "spacy",
+        inline = FALSE
+      ),
+      conditionalPanel(
+        condition = "input.modele_chd == 'iramuteq'",
+        tags$small("En mode IRaMuTeQ-like, seul le dictionnaire Lexique (fr) est utilisé automatiquement."),
+        tags$small("Dans ce mode, le filtrage des stopwords utilise la liste française de quanteda (pas spaCy).")
+      ),
+      conditionalPanel(
+        condition = "input.source_dictionnaire == 'spacy'",
+        selectInput(
+          "spacy_langue",
+          "Langue spaCy",
+          choices = c("Français" = "fr", "Anglais" = "en", "Espagnol" = "es", "Italien" = "it", "Allemand" = "de", "Portugais" = "pt", "Catalan" = "ca"),
+          selected = "fr"
+        )
+      ),
+      conditionalPanel(
+        condition = "input.source_dictionnaire == 'spacy'",
+        checkboxInput("spacy_utiliser_lemmes", "Lemmatisation via spaCy uniquement", value = FALSE)
+      ),
+      conditionalPanel(
+        condition = "input.source_dictionnaire == 'lexique_fr'",
+        checkboxInput("lexique_utiliser_lemmes", "Lemmatisation via les lemmes de lexique_fr (forme → c_lemme)", value = TRUE)
+      ),
+      uiOutput("ui_spacy_langue_detection"),
+
+
+      tags$div(class = "sidebar-section-title", "Nettoyage"),
+
+      conditionalPanel(
+        condition = "input.modele_chd == 'iramuteq'",
+        tags$div(
+          style = "margin: 0 0 8px 0; padding: 8px; background: #f7fbff; border-left: 3px solid #1e5aa8;",
+          tags$strong("Options IRaMuTeQ-like (iramuteq-like/textprepa_iramuteq.py)"),
+          tags$br(),
+          tags$small("Ces options pilotent la préparation du texte avant la tokenisation en mode IRaMuTeQ-like.")
+        )
+      ),
+
+      checkboxInput("nettoyage_caracteres", "Nettoyage caractères (regex)", value = FALSE),
+      checkboxInput("forcer_minuscules_avant", "Passage en minuscules avant tokenisation", value = FALSE),
+      checkboxInput("supprimer_ponctuation", "Supprimer la ponctuation", value = FALSE),
+      tags$small("Supprime la ponctuation à la tokenisation quanteda (remove_punct), pour les deux sources (spaCy et lexique_fr), par ex. . , ; : ! ? ' ’ \" - ( ) [ ] …"),
+      checkboxInput("supprimer_chiffres", "Supprimer les chiffres (0-9)", value = FALSE),
+      checkboxInput("supprimer_apostrophes", "Traiter les élisions FR (c'est→est, m'écrire→écrire)", value = FALSE),
+      checkboxInput("retirer_stopwords", "Retirer les stopwords (spaCy si source spaCy, quanteda si source Lexique fr)", value = FALSE),
+      tags$small("La normalisation en minuscules est appliquée automatiquement avant la construction du DFM."),
+      checkboxInput("filtrage_morpho", "Filtrage morphosyntaxique", value = FALSE),
+      tags$small("Le filtrage morphosyntaxique s'applique à spaCy ou lexique_fr selon la source sélectionnée."),
+      conditionalPanel(
+        condition = "input.filtrage_morpho == true",
+        conditionalPanel(
+          condition = "input.source_dictionnaire == 'spacy'",
+          selectizeInput(
+            "pos_spacy_a_conserver",
+            "POS à conserver (spaCy)",
+            choices = c(
+              "ADJ", "ADP", "ADV", "AUX", "CCONJ", "DET", "INTJ", "NOUN",
+              "NUM", "PART", "PRON", "PROPN", "PUNCT", "SCONJ", "SYM", "VERB", "X"
+            ),
+            selected = c("NOUN", "VERB"),
+            multiple = TRUE,
+            options = list(plugins = list("remove_button"))
+          )
+        ),
+        conditionalPanel(
+          condition = "input.source_dictionnaire == 'lexique_fr'",
+          selectizeInput(
+            "pos_lexique_a_conserver",
+            "Catégories c_morpho à conserver (lexique_fr)",
+            choices = c(
+              "NOM", "VER", "AUX", "ADJ", "ADV", "PRE", "CON", "ONO",
+              "ADJ:NUM", "ADJ:POS", "ADJ:IND", "ADJ:INT", "ADJ:DEM",
+              "PRO:PER", "PRO:POS", "PRO:DEM", "PRO:IND", "PRO:REL", "PRO:INT",
+              "ART:DEF", "ART:IND"
+            ),
+            selected = c("NOM", "VER", "ADJ"),
+            multiple = TRUE,
+            options = list(plugins = list("remove_button"))
+          )
+        )
+      ),
+      tags$small("Regex appliquée quand “Nettoyage caractères (regex)” est activé :"),
+      tags$pre(
+        style = "white-space: pre-wrap; font-size: 11px; border: 1px solid #ddd; padding: 6px;",
+        REGEX_CARACTERES_A_SUPPRIMER
+      ),
+      tags$small("Les caractères présents dans la liste entre crochets sont conservés ; tous les autres (ex. @ # & / emoji) sont remplacés par des espaces."),
+      tags$small("L'option “Supprimer la ponctuation” pilote remove_punct, même si elle est autorisée par la regex ci-dessus."),
+      tags$small("Cette option conserve les apostrophes lexicales (ex. aujourd'hui) et ne traite que les élisions en début de mot."),
+
+      tags$div(class = "sidebar-section-title", "Paramètres SpaCy/NER"),
+
+      checkboxInput("activer_ner", "Activer NER (spaCy)", value = FALSE),
+      uiOutput("ui_ner_lexique_incompatibilite"),
+      conditionalPanel(
+        condition = "input.activer_ner == true",
+        fileInput(
+          "fichier_ner_json",
+          "Importer un dictionnaire NER (.json)",
+          accept = c(".json", "application/json")
+        ),
+        tags$small("Optionnel : importez un dictionnaire NER JSON si vous voulez personnaliser les entités. Si vous ne fournissez pas de fichier, l'analyse utilise le NER spaCy classique.")
+      ),
+
+      tags$hr(),
+
+      tags$div(class = "sidebar-section-title", "Paramètres AFC"),
+
+      checkboxInput("afc_reduire_chevauchement", "Réduire les chevauchements des mots (AFC)", value = FALSE),
+
+      radioButtons(
+        "afc_taille_mots",
+        "Taille des mots (AFC termes)",
+        choices = c("Fréquence" = "frequency", "Chi2" = "chi2"),
+        selected = "frequency",
+        inline = FALSE
+      ),
+
+      tags$hr(),
+
+      tags$div(
+        style = "display: flex; gap: 8px; flex-wrap: wrap; align-items: center;",
+        actionButton("lancer", "Lancer l'analyse"),
+        actionButton("explor", "Explor rainette", class = "btn-primary")
+      ),
+
+      tags$hr(),
+
+      downloadButton("dl_zip", "Télécharger exports (zip)"),
+      downloadButton("dl_afc_zip", "Télécharger AFC (zip)")
+    ),
+
+    mainPanel(
+      tabsetPanel(
+        id = "onglets_principaux",
+
+        tabPanel(
+          "Analyse",
+          tags$h3("Statut"),
+          textOutput("statut"),
+          tags$h3("Journal"),
+          tags$pre(style = "white-space: pre-wrap;", textOutput("logs")),
+          tags$h3("Analyse du corpus (mode debug)"),
+          uiOutput("ui_table_stats_corpus"),
+          tags$div(
+            style = "width: 600px;",
+            plotOutput("plot_stats_zipf", height = "600px", width = "600px")
+          ),
+          tags$h3("Répartition des classes"),
+          tableOutput("table_classes")
+        ),
+
+        tabPanel(
+          "Explore rainette",
+          tags$h3("Explore_rainette"),
+          selectInput("classe_viz", "Classe", choices = c("1"), selected = "1"),
+          tabsetPanel(
+            tabPanel(
+              "CHD",
+              tags$h4("Dendrogramme CHD (Rainette)"),
+              plotOutput("plot_chd_rainette_dendro", height = "360px"),
+              tags$hr(),
+              fluidRow(
+                column(
+                  4,
+                  sliderInput("k_plot", "Nombre de classes (k)", min = 2, max = 2, value = 2, step = 1),
+                  selectInput(
+                    "measure_plot", "Statistiques",
+                    choices = c(
+                      "Frequency - Terms" = "frequency",
+                      "Keyness - Chi-squared" = "chi2",
+                      "Keyness - Likelihood ratio" = "lr",
+                      "Frequency - Documents proportion" = "docprop"
+                    ),
+                    selected = "frequency"
+                  ),
+                  selectInput("type_plot", "Type", choices = c("bar", "cloud"), selected = "bar"),
+                  numericInput("n_terms_plot", "Nombre de termes", value = 20, min = 5, max = 1000, step = 1),
+                  conditionalPanel(
+                    "input.measure_plot != 'docprop'",
+                    checkboxInput("same_scales_plot", "Forcer les mêmes échelles", value = TRUE)
+                  ),
+                  checkboxInput("show_negative_plot", "Afficher les valeurs négatives", value = FALSE),
+                  numericInput("text_size_plot", "Taille du texte", value = 12, min = 6, max = 30, step = 1)
+                ),
+                column(
+                  8,
+                  plotOutput("plot_chd", height = "70vh")
+                )
+              )
+            ),
+            tabPanel("Concordancier HTML", uiOutput("ui_concordancier_explore")),
+            tabPanel("Nuage de mots", uiOutput("ui_wordcloud")),
+            tabPanel("Statistiques", tableOutput("table_stats_classe"))
+          )
+        ),
+
+
+
+        ui_resultats_chd_iramuteq(),
+
+        tabPanel(
+          "Prévisu corpus",
+          tags$h3("Corpus importé"),
+          uiOutput("ui_corpus_preview")
+        ),
+
+        
+        tabPanel(
+          "AFC",
+          tags$h3("AFC"),
+          uiOutput("ui_afc_statut"),
+          uiOutput("ui_afc_erreurs"),
+
+          tags$h4("AFC des classes (Représentation des classes)"),
+          plotOutput("plot_afc_classes", height = "620px"),
+
+          tags$h4("AFC des termes"),
+          tags$p("Les mots sont colorés selon la classe où ils sont le plus surreprésentés (résidus standardisés) et leur taille est proportionnelle à leur fréquence globale ou chi2 (selon le choix)."),
+          plotOutput("plot_afc", height = "720px"),
+          tags$h4("Table des mots projetés (fréquence, chi2, p-value, segment exemple)"),
+          uiOutput("ui_table_afc_mots_par_classe"),
+
+          tags$h4("AFC des variables étoilées"),
+          plotOutput("plot_afc_vars", height = "720px"),
+          tags$h4("Table des modalités projetées"),
+          tableOutput("table_afc_vars"),
+
+          tags$h4("Valeurs propres"),
+          tableOutput("table_afc_eig")
+        ),
+        
+        tabPanel(
+          "NER (beta)",
+          tags$h3("Détection d'entités nommées (spaCy)"),
+          uiOutput("ui_ner_statut"),
+          tags$h3("Résumé"),
+          tableOutput("table_ner_resume"),
+          tags$h3("Détails"),
+          tableOutput("table_ner_details"),
+          tags$h3("Nuage de mots (entités)"),
+          plotOutput("plot_ner_wordcloud", height = "520px"),
+          tags$h3("Nuages par classe"),
+          uiOutput("ui_ner_wordcloud_par_classe")
+        ),
+
+        tabPanel(
+          "Aide",
+          ui_aide_huggingface()
+        ),
+
+        tabPanel(
+          "Aide POS/Spacy",
+          tags$div(
+            style = "padding: 12px;",
+            if (file.exists("pos_spacy.md")) {
+              includeMarkdown("pos_spacy.md")
+            } else {
+              tags$p("Le fichier pos_spacy.md est introuvable à la racine du projet.")
+            }
+          )
+        ),
+
+        tabPanel(
+          "Aide NER",
+          tags$div(
+            style = "padding: 12px;",
+            if (file.exists("spacy_ner/ner.md")) {
+              includeMarkdown("spacy_ner/ner.md")
+            } else {
+              tags$p("Le fichier spacy_ner/ner.md est introuvable.")
+            }
+          )
+        )
+      )
+    )
+  )
+)