Extraire le texte d’un PowerPoint en Java

Préparer le projet Java

Les exemples ci-dessous utilisent Spire.Presentation, une bibliothèque Java qui permet de charger et de parcourir des présentations PowerPoint. La version indiquée est 11.9.10. Avant de l'adopter, vérifiez les versions disponibles et les conditions de licence : une dépendance « OK en prototype » peut devenir plus contraignante une fois intégrée à un service en production.

Avec Maven, ajoutez le dépôt et la dépendance suivants dans votre fichier pom.xml :

<repositories>
<repository>
<id>com.e-iceblue</id>
<name>e-iceblue</name>
<url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>e-iceblue</groupId>
<artifactId>spire.presentation</artifactId>
<version>11.9.10</version>
</dependency>
</dependencies>

Les exemples supposent qu'un fichier report.pptx se trouve dans le répertoire de travail. En pratique, évitez de le coder en dur : passez-le en paramètre, ou adaptez-le selon votre environnement. C'est plus simple à tester, et plus facile à déployer sur un serveur.

Pour l'écriture des résultats, on utilise StandardCharsets.UTF_8. Ça évite les surprises quand les diapositives contiennent des accents, des caractères non latins ou plusieurs langues. Le fichier .txt pourra aussi être relu sur d'autres systèmes sans dépendre de l'encodage « par défaut » de la machine.

Enfin, pensez à libérer la présentation après traitement avec dispose(). Ce n'est pas juste « pour faire propre » : si vous enchaînez les ouvertures sans libérer les ressources, vous pouvez finir par consommer inutilement de la mémoire (ou d'autres ressources) côté processus.

Extraire le texte de toutes les diapositives

Pour parcourir une présentation complète, récupérez les diapositives avec getSlides(), puis parcourez les formes de chaque diapositive. Les titres, zones de texte et formes contenant du texte passent par IAutoShape. Le texte est organisé en paragraphes, accessibles via ParagraphEx.getText().

Voici un programme autonome qui réunit le texte dans un fichier, avec un séparateur entre chaque diapositive :

import com.spire.presentation.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
public class ExtraireToutLeTexte {
public static void main(String[] args) throws Exception {
Presentation presentation = new Presentation();
try {
presentation.loadFromFile("report.pptx");
StringBuilder resultat = new StringBuilder();
for (int i = 0; i < presentation.getSlides().getCount(); i++) {
ISlide diapositive = presentation.getSlides().get(i);
resultat.append("Diapositive ")
.append(i + 1)
.append(System.lineSeparator());
for (Object forme : diapositive.getShapes()) {
if (forme instanceof IAutoShape) {
IAutoShape formeTexte = (IAutoShape) forme;
for (Object element : formeTexte.getTextFrame().getParagraphs()) {
ParagraphEx paragraphe = (ParagraphEx) element;
String texte = paragraphe.getText();
if (texte != null && !texte.trim().isEmpty()) {
resultat.append(texte)
.append(System.lineSeparator());
}
}
}
}
resultat.append(System.lineSeparator());
}
Files.write(Paths.get("texte-toutes-diapos.txt"),
resultat.toString().getBytes(StandardCharsets.UTF_8));
System.out.println("Extraction terminée.");
} finally {
presentation.dispose();
}
}
}

Le fichier texte-toutes-diapos.txt regroupe le contenu par numéro de diapositive. Les paragraphes vides sont ignorés, ce qui évite d'empiler des lignes inutiles.

Les appels principaux sont simples :

• getSlides() donne accès à la collection de diapositives ;
• getShapes() fournit les formes de la diapositive ;
• getTextFrame().getParagraphs() récupère les paragraphes d'une forme textuelle ;
• getText() renvoie le texte d'un paragraphe.

Mais il faut garder une idée claire : ce que vous obtenez vient des objets que la boucle reconnaît. Les tableaux, les notes du présentateur, les graphiques et le texte « dans » une image ne sont pas forcément pris en charge ici. Et l'ordre de lecture correspond à l'ordre des formes dans la collection, qui ne colle pas toujours à l'ordre visuel attendu par un lecteur.

Dans un outil de production, ajoutez des infos de diagnostic : nom du fichier traité, nombre de diapositives, durée, et détails en cas d'erreur. Une extraction partielle qui finit sans avertir est souvent plus embêtante qu'un échec explicite.

Lire une diapositive précise

Vous n'avez pas toujours besoin de traiter toute la présentation. Pour récupérer un texte de la troisième diapositive, par exemple, vous sélectionnez la diapositive avant de parcourir ses formes.

Dans l'API, l'index commence à zéro : get(0) correspond à la première diapositive. Si vous partez du numéro « habituel » (qui commence à un), vous devez faire numero - 1.

import com.spire.presentation.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
public class ExtraireUneDiapositive {
public static void main(String[] args) throws Exception {
Presentation presentation = new Presentation();
try {
presentation.loadFromFile("report.pptx");
int numeroDiapositive = 3;
int nombreDiapositives = presentation.getSlides().getCount();
if (numeroDiapositive < 1 || numeroDiapositive > nombreDiapositives) {
throw new IllegalArgumentException(
"Le numéro de diapositive demandé n'existe pas.");
}
ISlide diapositive = presentation.getSlides()
.get(numeroDiapositive - 1);
StringBuilder resultat = new StringBuilder();
for (Object forme : diapositive.getShapes()) {
if (forme instanceof IAutoShape) {
IAutoShape formeTexte = (IAutoShape) forme;
for (Object element : formeTexte.getTextFrame().getParagraphs()) {
ParagraphEx paragraphe = (ParagraphEx) element;
String texte = paragraphe.getText();
if (texte != null && !texte.trim().isEmpty()) {
resultat.append(texte)
.append(System.lineSeparator());
}
}
}
}
Files.write(Paths.get("texte-diapositive-3.txt"),
resultat.toString().getBytes(StandardCharsets.UTF_8));
System.out.println("Extraction de la diapositive terminée.");
} finally {
presentation.dispose();
}
}
}

Le contrôle des bornes évite un accès invalide quand le numéro demandé est en dehors de [1, nombre de diapositives]. C'est un petit test, mais dès que le numéro vient d'un formulaire ou d'un traitement automatisé, il devient indispensable.

Si vous avez plusieurs diapos à extraire, reprenez la même logique avec une liste de numéros : validez, convertissez en index avec numero - 1, puis traitez uniquement ce qui est demandé. Pour une présentation longue et quelques pages ciblées, ça réduit le travail. Pour des fichiers plus petits, parcourir tout le monde reste souvent plus simple.

Extraire le contenu des tableaux

Les cellules d'un tableau ne se récupèrent pas comme les paragraphes d'une zone de texte classique. Il faut repérer les objets ITable, parcourir leurs lignes et colonnes, puis lire le texte de chaque cellule.

L'exemple ci-dessous cherche les tableaux sur toutes les diapositives et enregistre les cellules sous forme de texte, avec des tabulations entre colonnes. Chaque ligne du tableau PowerPoint devient une ligne dans le fichier :

import com.spire.presentation.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
public class ExtraireTexteDesTableaux {
public static void main(String[] args) throws Exception {
Presentation presentation = new Presentation();
try {
presentation.loadFromFile("report.pptx");
StringBuilder resultat = new StringBuilder();
for (int i = 0; i < presentation.getSlides().getCount(); i++) {
ISlide diapositive = presentation.getSlides().get(i);
for (Object forme : diapositive.getShapes()) {
if (forme instanceof ITable) {
ITable tableau = (ITable) forme;
resultat.append("Tableau de la diapositive ")
.append(i + 1)
.append(System.lineSeparator());
int nombreLignes = tableau.getTableRows().getCount();
int nombreColonnes = tableau.getColumnsList().getCount();
for (int ligne = 0; ligne < nombreLignes; ligne++) {
for (int colonne = 0; colonne < nombreColonnes; colonne++) {
String texte = tableau.get(colonne, ligne)
.getTextFrame().getText();
if (texte != null) {
texte = texte.replace("\\r", " ")
.replace("\\n", " ")
.replace("\\t", " ");
resultat.append(texte);
}
if (colonne < nombreColonnes - 1) {
resultat.append("\\t");
}
}
resultat.append(System.lineSeparator());
}
resultat.append(System.lineSeparator());
}
}
}
Files.write(Paths.get("texte-tableaux.txt"),
resultat.toString().getBytes(StandardCharsets.UTF_8));
System.out.println("Extraction des tableaux terminée.");
} finally {
presentation.dispose();
}
}
}

Attention à l'ordre des index : tableau.get(colonne, ligne) attend d'abord l'index de colonne, puis celui de ligne. Les deux commencent à zéro. Si vous inversez, vous risquez soit un contenu incohérent, soit carrément un comportement inattendu selon la forme du tableau.

Ici, les tabulations séparent les colonnes, et les retours à la ligne séparent les lignes. Si une cellule contient des tabulations ou des retours, on les remplace par des espaces pour garder une ligne de sortie par ligne du tableau. Si vous avez besoin de préserver des tabulations « significatives », ou si un programme doit consommer le fichier, mieux vaut définir une vraie règle d'échappement, ou choisir un format plus robuste comme CSV correctement géré ou JSON.

Les cellules fusionnées ajoutent un vrai sujet : selon les présentations, une boucle « ligne × colonne » peut tomber sur des zones vides ou répétées. Testez avec des fichiers représentatifs : selon les modèles et versions de PowerPoint, les conventions de mise en page ne sont pas toujours identiques.

Gérer les limites et choisir le bon format

Avant de considérer l'extraction comme « terminée », il faut regarder où le texte vit vraiment. Dans PowerPoint, ce qu'on voit à l'écran ne dit pas forcément quel type d'objet porte le contenu. Une phrase peut être une forme, une cellule de tableau, un libellé de graphique... ou du texte qui n'existe que comme pixels dans une image.