LaTeX a la imagen | Aspose.TeX para Python

Aspose.TeX para Python nos proporciona la capacidad de convertir archivos LaTeX en varios formatos de imágenes rasterizadas.

Conversión de LaTeX a PNG

Ahora, examinemos en profundidad el código Python que ofrece el enfoque más sencillo para convertir LaTeX a formato PNG.

Establezca ASPOSE_TEX_INPUT_FILE en su archivo LaTeX y ASPOSE_TEX_OUTPUT_DIR en el directorio de salida, o edite las rutas del ejemplo. Los valores predeterminados son hello-world.ltx y output. Aplique primero una licencia. Los archivos de entrada adicionales se buscan junto al documento principal y el procesamiento no es interactivo. Licencias

# Convert LaTeX to PNG.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, PngSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
options.save_options = PngSaveOptions()
device = ImageDevice(True)
job_result = TeXJob(str(input_file), device, options).run()

Para empezar, necesitamos crear una instancia de la clase TeXOptions usando el método console_app_options() . No te preocupes por el nombre, es sólo el método estático que crea la instancia. Este método toma la instancia object_latex de la clase TeXConfig, que es perfecta para convertir un archivo LaTeX. Esta configuración configura el motor Object TeX para cargar el formato Object LaTeX y estar listo para procesar el archivo LaTeX. El formato Object LaTeX es esencialmente el mismo que el formato LaTeX, pero utiliza primitivas específicas de Object TeX para definir las métricas de la página.

La primera de las opciones necesarias es output_working_directory, que especifica la ubicación donde se guardará la salida TeX. Si está interesado, puede obtener más información sobre el concepto de directorio de salida en Aspose.TeX para Python. En este ejemplo particular, utilizamos la clase OutputFileSystemDirectory para escribir la salida en un directorio o carpeta específica.

La segunda opción es una instancia de la clase SaveOptions, que se encarga de gestionar la conversión del modelo de objeto al formato deseado. En este caso, dado que estamos convirtiendo LaTeX a PNG, usamos la instancia de clase PngSaveOptions, que nos permite especificar la resolución de las imágenes de salida.

A continuación, creamos una instancia de la clase TeXJob. En este caso, como queremos convertir un archivo LaTeX almacenado en el sistema de archivos, usamos esta versión del constructor . Necesitamos proporcionar la ruta completa al archivo; de lo contrario, el motor lo buscará en el directorio actual (que es el directorio de trabajo del script) y es posible que no lo encuentre. Sin embargo, la extensión .tex se puede omitir ya que el motor la agregará automáticamente. El segundo argumento del constructor es una instancia de la clase Dispositivo. Dado que estamos convirtiendo LaTeX a PNG, es una instancia de clase ImageDevice, que es común a todos los formatos de imagen admitidos. Finalmente, pasamos las opciones de conversión preparadas como último argumento.

Ahora, todo lo que queda es ejecutar el trabajo.

El ejemplo captura la salida del terminal en OutputMemoryTerminal. El directorio de salida también contiene un registro .log. Una conversión correcta genera un registro similar al siguiente; los datos de versión pueden variar:

This is ObjectTeX, Version 3.1415926-1.0 (Aspose.TeX 21.8)
entering extended mode

(<input_directory>\hello-world.ltx
LaTeX2e <2011/06/27>
(article.cls
Document Class: article 2007/10/19 v1.4h Standard LaTeX document class
(size10.clo))
No file hello-world.aux.
[1]
(<output_directory>\hello-world.aux) )
Output written on hello-world.png (1 page).
Transcript written on hello-world.log.

Los resultados del trabajo del motor se pueden encontrar en el directorio de salida que especificamos. Esto incluirá el archivo de transcripción y, lo más importante, los archivos de imagen PNG de salida principales.

Una forma alternativa de escribir los archivos PNG de salida principales

Existe un método alternativo para obtener datos de imagen como una matriz de matrices de bytes, donde cada matriz en la segunda dimensión representa los datos de imagen para una página separada.

# Convert LaTeX to PNG and save each page from the returned byte arrays.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, PngSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
save_options = PngSaveOptions()
save_options.device_writes_images = False
options.save_options = save_options
device = ImageDevice(True)
job_result = TeXJob(str(input_file), device, options).run()

# Write the returned PNG page bytes yourself.
for index, page_bytes in enumerate(device.result, start=1):
    (output_dir / f"page-{index}.png").write_bytes(page_bytes)

El ejemplo establece device_writes_images = False en PngSaveOptions antes de asignarlo a options.save_options. Guarda los bytes de las páginas devueltas como page-1.png, page-2.png, etc. Por tanto, el dispositivo no crea archivos PNG duplicados.

En cuanto a las opciones de entrada

Si nuestro archivo de entrada principal requiere dependencias, como paquetes que no están incluidos en el sistema LaTeX básico o paquetes compatibles, debemos configurar la opción required_input_directory de manera similar a como configuramos la opción output_working_directory y coloque las dependencias en ese directorio. Las dependencias se pueden organizar en subdirectorios según sea necesario. Si tenemos nuestros archivos para incluir en el proceso de composición tipográfica, como archivos de gráficos externos, también debemos configurar el input_working_directory en la ubicación donde se almacenan esos archivos. También podemos colocar el archivo de entrada principal dentro del directorio de entrada y especificar la ruta relativa al constructor TeXJob, o no especificar ninguna ruta si el archivo de entrada principal está en el directorio raíz. También hay más detalles sobre el concepto de directorio de entrada en Aspose.TeX y las implementaciones proporcionadas descritas.

Conozca también otras opciones de trabajo TeX aquí.

También puede explorar la aplicación web gratuita para la conversión de LaTeX a PNG, que se desarrolla utilizando Aspose.TeX para .NET API.

A continuación, explicaremos brevemente la conversión de LaTeX a otros formatos de imágenes rasterizadas compatibles, sin entrar en demasiados detalles ya que no existen diferencias significativas. La única variación radica en el tipo de propiedad save_options en las opciones de conversión.

Conversión de LaTeX a JPG

# Convert LaTeX to JPEG.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, JpegSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
options.save_options = JpegSaveOptions()
device = ImageDevice(True)
job_result = TeXJob(str(input_file), device, options).run()

También puede explorar la aplicación web gratuita para la conversión de LaTeX a JPG, que se desarrolla utilizando Aspose.TeX para .NET API.

Conversión de LaTeX a TIFF

# Convert LaTeX to TIFF.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, TiffSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
options.save_options = TiffSaveOptions()
device = ImageDevice(True)
job_result = TeXJob(str(input_file), device, options).run()

También puede explorar la aplicación web gratuita para la conversión de LaTeX a TIFF, que se desarrolla utilizando Aspose.TeX para .NET API.

Conversión de LaTeX a BMP

# Convert LaTeX to BMP.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, BmpSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
options.save_options = BmpSaveOptions()
device = ImageDevice(True)
job_result = TeXJob(str(input_file), device, options).run()

También puede explorar la aplicación web gratuita para la conversión de LaTeX a BMP, que se desarrolla utilizando Aspose.TeX para .NET API.

Conversión de LaTeX a SVG

Otro formato de destino admitido es SVG. Gráficos vectoriales escalables (SVG) es un formato de imagen vectorial basado en XML que se utiliza para definir gráficos bidimensionales. Soporta interactividad y animación.

Las imágenes SVG se almacenan en archivos de texto XML y se definen en un formato de gráficos vectoriales. Esto significa que las imágenes SVG se pueden escalar en tamaño sin perder calidad, y los propios archivos SVG se pueden buscar, indexar, codificar y comprimir. Los archivos de texto XML se pueden crear y editar utilizando editores de texto o editores de gráficos vectoriales, y se pueden representar mediante los navegadores web más utilizados.

La API Aspose.SVG ofrece una variedad de funciones para trabajar con SVG, como crear, cargar, editar y convertir documentos SVG.

Convertir LaTeX a SVG es tan sencillo como convertir a formatos de imagen rasterizada, con la única diferencia de que save_options debe configurarse en una instancia de la clase SvgSaveOptions y el El dispositivo debe cambiarse a una instancia de la clase SvgDevice.

# Convert LaTeX to SVG.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.svg import SvgDevice, SvgSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
options.save_options = SvgSaveOptions()
device = SvgDevice()
job_result = TeXJob(str(input_file), device, options).run()

También puede explorar la aplicación web gratuita para la conversión de LaTeX a SVG, que se desarrolla utilizando Aspose.TeX para .NET API.