Agregar texto a un dibujo DWG a menudo es parte de un trabajo de ingeniería más amplio. En ciertos casos, puede que necesites etiquetar equipos, identificar habitaciones, agregar referencias de revisión o colocar notas en coordenadas predefinidas. Cuando esos detalles provienen de una base de datos o una hoja de cálculo, agregar cada etiqueta manualmente en un editor CAD es un trabajo innecesario.
Aspose.CAD for Python via .NET le permite cargar un dibujo DWG, agregar una entidad de texto a su espacio modelo y exportar el contenido anotado. En este tutorial, usted agregará texto a un dibujo DWG usando Python, establecerá su posición y apariencia, y guardará el resultado como DXF y PDF.
Instalar Aspose.CAD for Python via .NET
Necesita un entorno Python funcional, Aspose.CAD package, y un archivo DWG para anotar. AutoCAD no es necesario para ejecutar este ejemplo.
Instala el paquete con pip:
pip install aspose-cad
Para obtener más detalles de configuración, consulte la guía de instalación de Aspose.CAD.
Coloque un archivo DWG llamado sample.dwg en la misma carpeta que su script de Python. El ejemplo usa coordenadas del espacio modelo (100, 100, 0) y una altura de texto de 5.0 unidades de dibujo. Es posible que necesite ajustar estos valores para que se adapten a su dibujo.
Agregar texto a un dibujo DWG en Python
Los dibujos CAD almacenan texto como entidades en lugar de píxeles. La clase CadText representa una entidad TEXT de una sola línea, con propiedades para su contenido, ubicación, altura, estilo y capa. Añadir dicha entidad mantiene la parte de anotación del modelo CAD en lugar de simplemente dibujar palabras sobre una imagen exportada.
El flujo de trabajo consiste en cargar el archivo DWG, localizar su bloque de espacio modelo, crear una entidad CadText, añadirla a ese bloque, actualizar los límites del dibujo y exportar el resultado.
Código Python completo para insertar texto en un dibujo DWG
El siguiente ejemplo ha sido probado con Aspose.CAD for Python via .NET. Añade la etiqueta Hello from Aspose.CAD Python al dibujo y produce dos archivos de salida.
import aspose.cad as cad
from aspose.pycore import cast
from aspose.cad.fileformats.cad import CadImage
from aspose.cad.fileformats.cad.cadobjects import (
CadText,
Cad3DPoint,
)
from aspose.cad.imageoptions import (
DxfOptions,
PdfOptions,
CadRasterizationOptions,
)
# Input and output files
input_file = "sample.dwg"
output_dxf = "drawing_with_text.dxf"
output_pdf = "drawing_with_text.pdf"
# Text properties
text_value = "Hello from Aspose.CAD Python"
text_x = 100.0
text_y = 100.0
text_height = 5.0
# Load the DWG drawing
with cad.Image.load(str(input_file)) as image:
# IMPORTANT: Cast Image to CadImage
cad_image = cast(CadImage, image)
# Find model space
model_space = None
for block in cad_image.block_entities.values_typed:
block_name = block.name or ""
original_name = block.original_block_name or ""
if (
block_name.lower() == "*model_space"
or original_name.lower() == "*model_space"
):
model_space = block
break
if model_space is None:
raise RuntimeError(
"Model space block was not found."
)
# Create a new TEXT entity
text_entity = CadText()
text_entity.default_value = text_value
text_entity.style_type = "Standard"
text_entity.layer_name = "0"
text_entity.color_id = 256
text_entity.text_height = text_height
text_entity.scale_x = 1.0
# Set text position
text_entity.first_alignment = Cad3DPoint(
text_x,
text_y,
0.0
)
# Add the text to model space
model_space.add_entity(text_entity)
# Update drawing bounds
cad_image.update_size(True)
# Save as editable DXF
dxf_options = DxfOptions()
cad_image.save(str(output_dxf), dxf_options)
print(f"DXF created: {output_dxf}")
# Save as PDF for viewing
raster_options = CadRasterizationOptions()
raster_options.page_width = 1600.0
raster_options.page_height = 1200.0
pdf_options = PdfOptions()
pdf_options.vector_rasterization_options = raster_options
cad_image.save(str(output_pdf), pdf_options)
print(f"PDF created: {output_pdf}")
print("Text added successfully.")
Salida esperada
Cuando el script se completa con éxito, crea los siguientes archivos junto a sample.dwg:
drawing_with_text.dxf— el dibujo CAD exportado con la nueva entidad de texto, donde sea compatible con el escritor DXF.drawing_with_text.pdf— una copia renderizada del dibujo anotado para revisión o compartir.
La salida de la consola es:
DXF created: drawing_with_text.dxf
PDF created: drawing_with_text.pdf
Text added successfully.
Abra ambos archivos de salida para confirmar que la etiqueta sea visible y esté correctamente posicionada. El archivo original sample.dwg no se modifica.
Cómo funciona el código Python
Algunos detalles en el ejemplo son importantes cuando pasas de un dibujo de prueba simple a un archivo de producción.
1. Cargar y convertir el dibujo DWG
El método cad.Image.load() abre el archivo de origen. Luego, el ejemplo usa cast(CadImage, image) para que el dibujo cargado pueda accederse a través de propiedades específicas de CAD, incluyendo block_entities.
La sentencia with mantiene la imagen abierta mientras sus entidades se modifican y exportan, y luego libera el recurso cuando finaliza el procesamiento.
2. Encontrar el bloque del espacio modelo
Un dibujo DWG puede contener varios bloques. El nuevo texto debe añadirse al bloque que representa el espacio de dibujo previsto.
El ejemplo itera a través de cad_image.block_entities.values_typed y verifica tanto block.name como block.original_block_name en busca de *Model_Space, sin distinguir entre mayúsculas y minúsculas. Esto evita asumir que el espacio modelo siempre puede ser accedido mediante una clave de diccionario directa.
Si no se puede encontrar el espacio del modelo, el script genera un RuntimeError. Esto es preferible a exportar silenciosamente un archivo sin la nueva anotación.
3. Crear y posicionar la entidad de texto
CadText() crea la nueva anotación de una sola línea. Su propiedad default_value almacena el texto visible. La posición proviene de Cad3DPoint(text_x, text_y, 0.0), asignada a first_alignment.
En este ejemplo, text_height = 5.0 define la altura en unidades de dibujo, y scale_x = 1.0 establece el factor de escala horizontal. La entidad usa el estilo de texto Standard y la capa 0. Su ID de color 256 significa ByLayer, por lo que la capa controla su color.
Después de establecer estas propiedades, model_space.add_entity(text_entity) inserta la anotación en el espacio modelo.
4. Recalcular los límites del dibujo
Agregar texto puede cambiar el área ocupada por el contenido del dibujo. La llamada a continuación actualiza los límites del dibujo antes de la exportación:
cad_image.update_size(True)
El argumento booleano es requerido por la API de Python utilizada en este ejemplo probado. Llamar a update_size() sin él puede producir un error de argumento faltante.
5. Exportar el dibujo anotado
DxfOptions se usa para guardar el dibujo como DXF. CadRasterizationOptions controla las dimensiones de la página para la renderización, y PdfOptions produce el archivo PDF.
Observe que las dimensiones del PDF se escriben como 1600.0 y 1200.0, no como enteros. Los enlaces de Python probados esperan valores numéricos en este formato para estos setters.
Las dimensiones de la página controlan el diseño de la exportación; no son la altura del texto ni las dimensiones reales del dibujo.
Cambiar la posición del texto, la altura, el color y el estilo
Puede personalizar una entidad CadText cambiando sus propiedades antes de llamar a add_entity().
| Propiedad | Qué controla | Ejemplo |
|---|---|---|
default_value | Texto mostrado en el dibujo | "VALVE V-101" |
first_alignment | Posición del texto en coordenadas CAD | Cad3DPoint(150.0, 80.0, 0.0) |
text_height | Altura del texto en unidades del dibujo | 3.0 |
scale_x | Factor de escala horizontal del texto | 1.0 |
style_type | Nombre del estilo de texto | "Standard" |
layer_name | Capa asociada al texto | "0" |
color_id | Valor del índice de color de AutoCAD | 1 para rojo; 256 para ByLayer |
Por ejemplo, cambie las propiedades de texto en el script principal para etiquetar una válvula:
text_entity.default_value = "VALVE V-101"
text_entity.first_alignment = Cad3DPoint(
150.0, 80.0, 0.0
)
text_entity.text_height = 3.0
text_entity.scale_x = 1.0
text_entity.style_type = "Standard"
text_entity.layer_name = "0"
text_entity.color_id = 1
Ejecute este fragmento de configuración de propiedades antes model_space.add_entity(text_entity) en el ejemplo principal.
Utilice coordenadas que coincidan con el dibujo real. Los dibujos CAD a menudo usan unidades o sistemas de coordenadas específicos del proyecto, por lo que (150, 80) puede estar dentro de un dibujo y estar lejos de la geometría en otro. Del mismo modo, una altura de 3.0 no es un tamaño de fuente de tres puntos; se mide en unidades del dibujo.
También debe usar un estilo de texto y una capa que existan en el dibujo de origen. El ejemplo utiliza valores predeterminados comunes, pero los dibujos con estándares personalizados pueden requerir nombres diferentes.
Agregar varias etiquetas de texto a un dibujo DWG
Una vez que una sola etiqueta funciona, puedes extender el mismo enfoque a varias anotaciones. Esto es útil cuando los identificadores de equipos, los nombres de salas o las referencias de inspección ya están almacenados como datos estructurados.
Por ejemplo, defina las etiquetas y sus coordenadas de inserción:
labels = [
("VALVE V-101", 40.0, 80.0),
("VALVE V-102", 70.0, 80.0),
("PUMP P-201", 100.0, 80.0),
("CONTROL PANEL", 130.0, 80.0),
]
for label, x, y in labels:
text = CadText()
text.default_value = label
text.first_alignment = Cad3DPoint(x, y, 0.0)
text.text_height = 2.5
text.scale_x = 1.0
text.style_type = "Standard"
text.layer_name = "0"
text.color_id = 256
model_space.add_entity(text)
cad_image.update_size(True)
Coloque este fragmento dentro del bloque with, después de que se encuentre el espacio del modelo y antes de las exportaciones DXF/PDF. Utiliza el mismo patrón de creación de entidades que el ejemplo funcional de texto único; la variación de múltiples etiquetas no ha sido probada por separado aquí.
En una aplicación real, labels podría poblarse a partir de un archivo CSV, un registro de equipos o una base de datos. La responsabilidad principal de su aplicación es proporcionar coordenadas válidas y propiedades de texto apropiadas. La biblioteca inserta las entidades en las posiciones que usted especifica; no evita automáticamente la superposición de etiquetas.
Guardar el dibujo con texto como DXF o PDF
El formato que elijas depende de lo que suceda después de la anotación.
Guardar como DXF para edición CAD
El ejemplo principal usa DxfOptions para exportar el dibujo:
dxf_options = DxfOptions()
cad_image.save("drawing_with_text.dxf", dxf_options)
DXF es útil cuando el siguiente paso implica una aplicación CAD u otro sistema que consume entidades de dibujo. Sin embargo, tabla de formatos compatibles de Aspose.CAD describe la escritura de DXF como parcialmente soportada. Valide anotaciones importantes, capas y geometría en el archivo exportado antes de usarlo en un flujo de trabajo de ingeniería.
Guardar como PDF para visualizar y compartir
Para revisiones de diseño, informes o distribución de documentos, el ejemplo también exporta un PDF:
raster_options = CadRasterizationOptions()
raster_options.page_width = 1600.0
raster_options.page_height = 1200.0
pdf_options = PdfOptions()
pdf_options.vector_rasterization_options = raster_options
cad_image.save("drawing_with_text.pdf", pdf_options)
PDF está destinado a la visualización del dibujo resultante más que a la edición de sus entidades CAD. Si necesita un archivo DWG actualizado, utilice un flujo de trabajo CAD compatible separado para generarlo a partir de un formato intermedio apropiado; el guardado directo de DWG no está listado para la API de Python.
Solución de problemas de inserción de texto en archivos DWG
El texto insertado no es visible. Verifique primero las coordenadas del texto. Es posible que la etiqueta se haya colocado fuera de la geometría visible. También inspeccione la visibilidad de la capa, la altura del texto y el estilo de texto seleccionado. Compare las salidas DXF y PDF para identificar si el problema ocurre durante la inserción de la entidad o el renderizado.
El script no puede encontrar el espacio modelo. El ejemplo genera Model space block was not found. si ningún nombre de bloque coincide con *Model_Space. Inspeccione los bloques en el archivo fuente y confirme que contiene datos de espacio modelo en la estructura esperada. No continúe con una referencia de bloque faltante.
update_size() informa de un argumento faltante. Use cad_image.update_size(True) como se muestra en el ejemplo funcional. Esta firma es importante para el binding de Python utilizado aquí.
Las dimensiones de la página PDF provocan un error de tipo. Pase valores de punto flotante como 1600.0 y 1200.0 a page_width y page_height, respectivamente.
El texto se ve diferente al editor CAD. Verifique el estilo de texto del dibujo y si las fuentes correspondientes están disponibles en el entorno de procesamiento. La renderización puede diferir si la fuente esperada falta o es sustituida.
El DXF contiene diferencias inesperadas. La escritura de DXF solo es compatible parcialmente. Pruebe con dibujos representativos y revise las entidades resultantes en un visor CAD antes de integrar la salida en un proceso automatizado.
Preguntas frecuentes
¿Puedo agregar texto a un archivo DWG con Python sin AutoCAD?
Sí. Aspose.CAD for Python via .NET puede cargar un dibujo DWG y agregar una entidad CadText sin AutoCAD. El ejemplo luego exporta el dibujo modificado a DXF y PDF.
¿Cómo especifico la posición del texto en un dibujo DWG?
Establezca first_alignment en el objeto CadText usando Cad3DPoint(x, y, z). Elija valores que correspondan a una ubicación adecuada en el dibujo original.
¿Puedo agregar texto a una capa específica?
Sí. Establezca layer_name al nombre de la capa deseada. En el ejemplo principal, la anotación usa la capa 0 y el ID de color 256 (ByLayer).
¿Puedo agregar varias etiquetas de texto automáticamente?
Sí. Crea una nueva entidad CadText para cada etiqueta, establece su contenido y coordenadas, y añádela al espacio del modelo. Este patrón puede ser impulsado por una lista de registros u otra fuente de datos estructurada.
¿Puedo guardar el dibujo modificado de nuevo en DWG?
El guardado directo de DWG no está listado en los formatos compatibles de Aspose.CAD for Python. El flujo de trabajo probado exporta el dibujo modificado a DXF y PDF, dejando el DWG original sin cambios.
Obtén una licencia temporal gratuita
Puede solicitar una licencia temporal gratuita de 30 días para evaluar Aspose.CAD for Python via .NET sin restricciones de evaluación. Para aplicar la licencia en su aplicación Python, siga la guía de licenciamiento de Aspose.CAD.
Recursos de aprendizaje gratuitos
Explore estos recursos para obtener más información sobre el procesamiento de dibujos CAD en Python:
- Aspose.CAD for Python Developer Guide – Aprenda cómo cargar y procesar archivos CAD.
- Aspose.CAD Python API Reference – Revise las clases, propiedades y métodos utilizados en los ejemplos.
- Work with Text in CAD Drawings – Aprenda sobre los tipos de entidades que contienen texto en CAD.
- Supported CAD File Formats – Confirme los formatos de entrada y salida disponibles.
- Free Online CAD Applications – Vea o convierta archivos CAD usando herramientas basadas en el navegador.
- Aspose.CAD Support Forum – Haga preguntas sobre dibujos específicos o el comportamiento de la API.
Conclusión
Agregar texto a un dibujo DWG usando Python es una forma práctica de generar etiquetas de equipos, identificadores de salas y otras anotaciones a partir de los datos de la aplicación. Los pasos esenciales son localizar el espacio modelo, crear una entidad CadText con coordenadas y estilo apropiados, y actualizar los límites del dibujo antes de la exportación.
El siguiente paso es reemplazar la etiqueta de ejemplo con coordenadas e identificadores de sus propios datos de dibujo. Verifique la salida DXF en un editor CAD y utilice el PDF como una copia de revisión, especialmente al implementar el flujo de trabajo en dibujos con diferentes unidades, capas o fuentes.