Convertir des présentations PowerPoint en HTML avec Python via Java
Aperçu
Aspose.Slides for Python via Java peut enregistrer les présentations PowerPoint au format HTML sans Microsoft PowerPoint. La conversion de base consiste en un unique chargement de Presentation et un appel save avec SaveFormat. Utilisez HtmlOptions lorsque vous devez contrôler la mise en page exportée, les polices, les images, les notes, les commentaires, la sortie SVG ou les ressources liées.
Ce guide se concentre sur des scénarios pratiques d’exportation HTML :
- Exporter une présentation complète ou des diapositives sélectionnées.
- Générer du HTML à mise en page fixe, réactif ou basé sur SVG.
- Inclure les notes du présentateur et les commentaires.
- Contrôler la qualité des images et les données d’images recadrées.
- Incorporer les polices ou enregistrer les fichiers de polices séparément.
- Choisir comment les ressources externes et les fichiers multimédias sont écrits et référencés.
Par défaut, l’exportation HTML produit un document HTML autonome où la plupart des ressources sont intégrées. Cela est pratique pour partager un seul fichier, mais cela peut augmenter la taille du résultat. Pour la publication sur le web, envisagez des ressources externes, une résolution DPI d’image plus basse et n’incorporez que les polices qui ne sont pas disponibles de façon fiable dans l’environnement cible.
Convertir une présentation en HTML
Pour exporter une présentation en HTML, chargez‑la avec Presentation et enregistrez‑la avec SaveFormat.Html.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
presentation.save("presentation.html", SaveFormat.Html)
finally:
presentation.dispose()
Chaque exemple charge presentation.pptx depuis le répertoire de travail actuel. Installez Aspose.Slides for Python via Java et un runtime Java compatible avant de l’exécuter. La JVM est démarrée une fois par processus Python.
Cet exemple écrit un seul fichier HTML. L’objet présentation est libéré dans le bloc finally, ce qui libère les poignées de fichier et les ressources de rendu après l’exportation.
Configurer l’exportation HTML
HtmlOptions est la classe de configuration principale pour l’exportation HTML. Les paramètres courants incluent :
- setSlidesLayoutOptions : ajoute des notes, des commentaires, des documents de distribution ou d’autres informations de mise en page.
- setHtmlFormatter : modifie la structure du document HTML ou délègue le formatage à un contrôleur.
- setSlideImageFormat : change la représentation des diapositives, par exemple en SVG.
- setPicturesCompression : contrôle le DPI des images et la taille du résultat.
- setDeletePicturesCroppedAreas : conserve ou supprime les données d’images recadrées.
- setSvgResponsiveLayout : rend le contenu SVG exporté adaptable à son conteneur.
- setShowHiddenSlides : inclut les diapositives masquées lorsque cela est requis.
Les sections suivantes présentent les options les plus courantes séparément afin que vous ne combiniez que celles dont votre flux de travail a besoin.
Convertir des diapositives sélectionnées en HTML
La surcharge Presentation.save qui accepte des numéros de diapositives utilise des positions de diapositives basées sur 1. La boucle ci‑dessous enregistre chaque diapositive dans un fichier HTML séparé.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
slide_count = presentation.getSlides().size()
for slide_index in range(slide_count):
slide_number = slide_index + 1
slide_numbers = jpype.JArray(jpype.JInt)([slide_number])
html_file_name = f"slide-{slide_number}.html"
presentation.save(html_file_name, slide_numbers, SaveFormat.Html)
finally:
presentation.dispose()
Utilisez ce modèle lorsqu’un site Web ou une application nécessite une page HTML par diapositive. Si chaque diapositive doit avoir la même mise en page, créez une instance HtmlOptions et transmettez‑la à chaque appel Presentation.save.
Créer du HTML réactif
ResponsiveHtmlController fournit une sortie HTML réactive via HtmlFormatter. Utilisez‑le lorsque la page exportée doit mieux s’adapter à la largeur du navigateur.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlFormatter, HtmlOptions, Presentation, ResponsiveHtmlController, SaveFormat
presentation = Presentation("presentation.pptx")
try:
controller = ResponsiveHtmlController()
formatter = HtmlFormatter.createCustomFormatter(controller)
html_options = HtmlOptions()
html_options.setHtmlFormatter(formatter)
presentation.save("presentation-responsive.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Pour une mise en page réactive basée sur SVG, appelez HtmlOptions.setSvgResponsiveLayout avec True. Ceci est utile lorsque le contenu des diapositives est exporté sous forme de balisage SVG scalable.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlOptions, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
html_options = HtmlOptions()
html_options.setSvgResponsiveLayout(True)
presentation.save("presentation-svg-responsive.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Inclure les notes du présentateur et les commentaires
Utilisez NotesCommentsLayoutingOptions via HtmlOptions.setSlidesLayoutOptions pour inclure les notes du présentateur ou les commentaires. Les notes et les commentaires sont masqués par défaut, sauf si vous choisissez leurs positions.
Supposons que la présentation source contienne des notes du présentateur :
Le code suivant exporte le contenu de la diapositive avec les notes du présentateur sous la diapositive.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlOptions, NotesCommentsLayoutingOptions, NotesPositions, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
layout_options = NotesCommentsLayoutingOptions()
layout_options.setNotesPosition(NotesPositions.BottomFull)
html_options = HtmlOptions()
html_options.setSlidesLayoutOptions(layout_options)
presentation.save("presentation-with-notes.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Le HTML exporté comprend la zone des notes :
Pour exporter les commentaires, appelez NotesCommentsLayoutingOptions.setCommentsPosition, par exemple avec CommentsPositions.Right ou CommentsPositions.Bottom. Si vous avez uniquement besoin des commentaires, omettez NotesCommentsLayoutingOptions.setNotesPosition. Si vous avez besoin à la fois des notes et des commentaires, appelez les deux méthodes.
Contrôler la qualité des images et les zones recadrées
L’exportation HTML peut compresser les images des diapositives afin de réduire la taille du résultat. Transmettez une valeur à HtmlOptions.setPicturesCompression depuis PicturesCompression lorsque vous avez besoin d’une meilleure qualité d’image.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlOptions, PicturesCompression, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
html_options = HtmlOptions()
html_options.setPicturesCompression(PicturesCompression.Dpi150)
presentation.save("presentation-dpi-150.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Par défaut, les zones recadrées des images peuvent être supprimées du résultat exporté. Conservez les données recadrées uniquement lorsque les utilisateurs doivent pouvoir récupérer ou inspecter ces parties d’image cachées. Les conserver peut augmenter la taille du HTML.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlOptions, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
html_options = HtmlOptions()
html_options.setDeletePicturesCroppedAreas(False)
presentation.save("presentation-with-cropped-areas.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Ajouter du CSS
Pour un style simple, transmettez une chaîne CSS à HtmlFormatter.createDocumentFormatter. Cela modifie le document HTML environnant tandis qu’Aspose.Slides continue de rendre le contenu des diapositives.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlFormatter, HtmlOptions, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
css_rules = "body { margin: 0; background: #f7f7f7; } .slide { margin: 24px auto; }"
formatter = HtmlFormatter.createDocumentFormatter(css_rules, True)
html_options = HtmlOptions()
html_options.setHtmlFormatter(formatter)
presentation.save("presentation-styled.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Pour un en‑tête de document personnalisé, un fichier CSS lié ou un balisage personnalisé autour des diapositives et des formes, utilisez un contrôleur de formatage personnalisé via un proxy d’interface JPype et transmettez‑le à HtmlFormatter avec HtmlFormatter.createCustomFormatter.
Incorporer des polices
Si l’environnement cible peut ne pas avoir les polices de la présentation installées, intégrez les polices dans le HTML avec EmbedAllFontsHtmlController. L’incorporation améliore la fidélité visuelle mais augmente la taille du résultat.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import EmbedAllFontsHtmlController, HtmlFormatter, HtmlOptions, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
font_names_to_exclude = jpype.JArray(jpype.JString)(["Arial"])
font_controller = EmbedAllFontsHtmlController(font_names_to_exclude)
formatter = HtmlFormatter.createCustomFormatter(font_controller)
html_options = HtmlOptions()
html_options.setHtmlFormatter(formatter)
presentation.save("presentation-embedded-fonts.html", SaveFormat.Html, html_options)
finally:
presentation.dispose()
Excluez les polices uniquement lorsque vous êtes certain que les navigateurs ou systèmes cibles les fournissent déjà. Pour les polices de marque ou moins courantes, l’incorporation est généralement plus sûre.
Enregistrer les ressources en externe
Le HTML autonome est facile à déplacer, mais les ressources Base64 intégrées peuvent rendre le fichier volumineux. Si votre application a besoin de fichiers image externes, implémentez un contrôleur de liaison de ressources via un proxy d’interface JPype et transmettez‑le au constructeur HtmlOptions.
Lorsque vous externalisez les ressources, choisissez deux chemins de façon délibérée :
- Le chemin de sortie du système de fichiers, où votre application écrit les images, polices, audio ou vidéo générés.
- Le chemin URL, qui est celui utilisé par le navigateur depuis le document HTML pour charger ces fichiers.
Exporter des fichiers multimédias
VideoPlayerHtmlController exporte les fichiers vidéo et audio et écrit du HTML capable de les lire dans un navigateur. Son constructeur prend :
path: le répertoire où les fichiers multimédias générés seront écrits.fileName: le nom du fichier HTML en cours de génération.baseUri: le préfixe URI absolu utilisé dans les liens HTML vers les fichiers multimédias.
L’exemple suivant exporte les médias déjà incorporés dans presentation.pptx. Le HTML généré référence les fichiers multimédias uniquement par leur nom de fichier, relatif au document HTML, ainsi path doit être le même répertoire qui reçoit également le fichier HTML. baseUri doit être une URI absolue : pour un aperçu local, construisez une URI file:/// à partir du répertoire de sortie ; pour une application déployée, utilisez l’URL absolue du répertoire publié.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import HtmlFormatter, HtmlOptions, Presentation, SVGOptions, SaveFormat, SlideImageFormat, VideoPlayerHtmlController
from pathlib import Path
output_directory = Path("html-output").resolve()
output_directory.mkdir(parents=True, exist_ok=True)
html_file_name = "presentation.html"
media_base_uri = output_directory.as_uri() + "/"
presentation = Presentation("presentation.pptx")
try:
controller = VideoPlayerHtmlController(str(output_directory), html_file_name, media_base_uri)
formatter = HtmlFormatter.createCustomFormatter(controller)
svg_options = SVGOptions(controller)
slide_image_format = SlideImageFormat.svg(svg_options)
html_options = HtmlOptions(controller)
html_options.setHtmlFormatter(formatter)
html_options.setSlideImageFormat(slide_image_format)
html_file_path = output_directory / html_file_name
presentation.save(str(html_file_path), SaveFormat.Html, html_options)
finally:
presentation.dispose()
Utilisez des répertoires de sortie uniques par tâche d’exportation, en particulier dans les applications serveur. Des chemins de sortie partagés peuvent entraîner l’écrasement de fichiers provenant de conversions différentes.
Performances et gestion des ressources
La conversion HTML est une opération de rendu, donc le temps de traitement et la consommation mémoire dépendent du nombre de diapositives, de la résolution des images, des polices, des effets, des graphiques et des médias incorporés. Des valeurs DPI d’image plus élevées passées à HtmlOptions.setPicturesCompression, les polices incorporées, la sortie SVG et la conservation des zones d’image recadrées peuvent améliorer la fidélité mais augmentent généralement la taille du résultat.
Pour la conversion en lot :
- Libérez rapidement chaque instance Presentation.
- Utilisez des répertoires de sortie distincts pour des tâches distinctes.
- Évitez d’incorporer les polices courantes sauf si la fidélité l’exige.
- Réduisez le DPI des images lorsque le HTML est destiné à un aperçu ou à des vignettes.
- Conservez la présentation source, le HTML généré et les ressources externes ensemble jusqu’à ce que les chemins de déploiement soient définitifs.
FAQ
Les hyperliens sont‑ils conservés dans la sortie HTML ?
Oui. Les hyperliens de la présentation sont exportés vers le HTML et restent cliquables tant que l’URL cible est valide.
Puis‑je convertir des présentations en HTML en parallèle ?
Oui, mais ne partagez pas une même instance Presentation entre plusieurs threads. Traitez des fichiers différents avec des instances de présentation distinctes, des flux distincts et des répertoires de sortie séparés. Consultez les directives multithreading pour plus de détails.
Un objet présentation est‑il thread‑safe ?
Non. Une seule instance Presentation doit être chargée, modifiée, enregistrée et libérée sur un seul thread. Pour un travail parallèle, créez une instance indépendante par thread ou processus.
Pourquoi le fichier HTML généré est‑il volumineux ?
L’exportation par défaut peut incorporer les ressources directement dans le HTML. Les polices incorporées, les images haute DPI, les médias, le contenu SVG et la conservation des zones d’image recadrées augmentent également la taille. Utilisez des ressources externes, excluez les polices courantes de l’incorporation et transmettez une valeur DPI inférieure à HtmlOptions.setPicturesCompression lorsque la taille réduite prime sur la fidélité maximale.
Pourquoi les valeurs de font‑size dans le HTML diffèrent‑elles de celles de PowerPoint ?
La page exportée peut utiliser des systèmes de coordonnées SVG et des transformations d’échelle. Une valeur brute de CSS ou de SVG font‑size ne décrit pas la taille affichée finale. Comparez la diapositive rendue au niveau de zoom prévu et vérifiez la disponibilité des polices si le texte semble différent.
Comment choisir baseUri pour l’exportation des médias ?
Choisissez baseUri du point de vue du navigateur et transmettez‑le comme URI absolue. Pour un aperçu local, vous pouvez le dériver du répertoire de sortie avec output_directory.as_uri() + "/". Pour le déploiement, utilisez l’URL absolue du répertoire publié. Le path du système de fichiers et le baseUri du navigateur n’ont pas besoin d’être la même chaîne, mais ils doivent désigner le même emplacement, et cet emplacement doit être le répertoire contenant le fichier HTML généré car les liens médias sont écrits relatifs à celui‑ci.
Puis‑je inclure les diapositives masquées ?
Oui. Appelez HtmlOptions.setShowHiddenSlides avec True lorsque les diapositives masquées doivent être exportées.