Dibujos DXF

Exportando Dibujos DXF a PDF

Aspose.CAD proporciona la función de cargar entidades de dibujo DXF de AutoCAD y renderizarlas como un dibujo completo en formato PDF. El enfoque de conversión de DXF a PDF funciona de la siguiente manera:

1. Carga el archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea un objeto de la clase CadRasterizationOptions y establece las propiedades PageHeight y PageWidth.
3. Crea un objeto de la clase PdfOptions y establece la propiedad VectorRasterizationOptions.
4. Llama a Image.Save pasando un objeto de PdfOptions como segundo parámetro.

El siguiente ejemplo de código muestra cómo convertir un archivo utilizando la configuración predeterminada.

// For complete examples and data files, please go to https://github.com/aspose-cad/Aspose.CAD-for-Java
// The path to the resource directory.
String dataDir = Utils.getDataDir(ExportDXFDrawingToPDF.class) + "DXFDrawings/";
String srcFile = dataDir + "conic_pyramid.dxf";

Image image = Image.load(srcFile);
	
// Create an instance of CadRasterizationOptions and set its various properties
CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
rasterizationOptions.setBackgroundColor(Color.getWhite());
rasterizationOptions.setPageWidth(1600);
rasterizationOptions.setPageHeight(1600);

// Create an instance of PdfOptions
PdfOptions pdfOptions = new PdfOptions();
// Set the VectorRasterizationOptions property
pdfOptions.setVectorRasterizationOptions(rasterizationOptions);

// Export the DXF to PDF
image.save(dataDir + "conic_pyramid_out_.pdf", pdfOptions);

Formatos Soportados

En este momento, soportamos completamente los formatos de archivo DXF de AutoCAD 2010. Las versiones anteriores de DXF no están garantizadas para ser 100% válidas. Estamos planeando incluir más formatos y características en futuras versiones de Aspose.CAD.

Entidades Soportadas

En este momento, soportamos todas las entidades 2D ampliamente utilizadas y sus parámetros básicos predeterminados como sigue:

1. Dimensión Alineada
2. Dimensión Angular
3. Arco
4. Atributo
5. Referencia de Bloque
6. Círculo
7. Dimensión de Diámetro
8. Elipse
9. Sombreado
10. Línea
11. Texto Multilínea
12. Dimensión Ordinada
13. Punto
14. Polilínea
15. Dimensión Radial
16. Rayo
17. Dimensión Rotada
18. Tabla
19. Texto
20. Xline

Si durante el análisis encontramos alguna entidad o propiedad que no soportamos, la entidad o propiedad será ignorada silenciosamente.

Gestión de Memoria

La propiedad ExactReallocateOnly se puede utilizar para controlar la realocación de memoria. La realocación es más probable que ocurra para cachés prealocados. Puede ocurrir cuando el sistema determina que el espacio asignado no será suficiente.

• Si se establece ExactReallocateOnly en el valor predeterminado, False, el espacio se vuelve a asignar al mismo medio.
• Cuando se establece en True, la realocación no puede exceder el espacio máximo especificado. En este caso, el caché en memoria existente (que requiere realocación) se libera y se asigna espacio extendido en el disco.

Exportando Capa Específica de Dibujos DXF a PDF

Este enfoque funciona de la siguiente manera:

1. Abre un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea una instancia de CadRasterizationOptions y especifica las propiedades PageWidth y PageHeight.
3. Agrega capas al objeto de CadRasterizationOptions.
4. Crea una instancia de PdfOptions y establece su propiedad VectorRasterizationOptions.
5. Exporta el dibujo a PDF utilizando el método Image.save.

El siguiente ejemplo de código muestra cómo convertir una capa específica de DXF a PDF.

// For complete examples and data files, please go to https://github.com/aspose-cad/Aspose.CAD-for-Java
// The path to the resource directory.
String dataDir = Utils.getDataDir(ExportSpecificLayerOfDXFDrawingToPDF.class) + "DXFDrawings/";
String srcFile = dataDir + "conic_pyramid.dxf";
		
Image image = Image.load(srcFile);

//  Create an instance of CadRasterizationOptions and set its various properties
CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
rasterizationOptions.setPageWidth(1600);
rasterizationOptions.setPageHeight(1600);
// Add desired layers
rasterizationOptions.getLayers().add("0");

// Create an instance of PdfOptions
PdfOptions pdfOptions = new PdfOptions();
// Set the VectorRasterizationOptions property
pdfOptions.setVectorRasterizationOptions(rasterizationOptions);

// Export the DXF to PDF
image.save(dataDir + "conic_pyramid_layer_out_.pdf", pdfOptions);

Exportando Capa Específica de Dibujos DXF a Imagen

Este enfoque funciona de la siguiente manera:

1. Abre un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea una instancia de CadRasterizationOptions y especifica las propiedades PageWidth y PageHeight.
3. Agrega capas al objeto de CadRasterizationOptions.
4. Crea una instancia de JpegOptions y establece su propiedad VectorRasterizationOptions.
5. Exporta el dibujo a PDF utilizando el método Image.save.

El siguiente ejemplo de código muestra cómo convertir una capa específica de DXF a Imagen.

// The path to the resource directory.
          String dataDir = Utils.getDataDir(ExportSpecificDXFLayoutToPDF.class) + "DXFDrawings\\";
          
          String srcFile = dataDir + "for_layers_test.dwf";
	
          DwfImage image =(DwfImage)Image.load(srcFile); 
   
          List<String> layersNames=image.getLayers().getLayersNames();
          
          DwfWhipLayer layer = image.getLayers().getLayerByName("0");
          for (DwfWhipLayer lr : image.getLayers())
          {
              //...
          }
          
// Create an instance of CadRasterizationOptions and set its various properties
   CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
   rasterizationOptions.setPageWidth(1600);
   rasterizationOptions.setPageHeight(1600);  
 
        
          String[] stringArray = Arrays.copyOf(layersNames.toArray(), layersNames.toArray().length, String[].class);
          
          List<String> stringList = Arrays.asList(stringArray);
           // Add desired layers
          rasterizationOptions.setLayers(stringList);

          JpegOptions jpegOptions = new JpegOptions();
          jpegOptions.setVectorRasterizationOptions(rasterizationOptions);
          String output = dataDir+"for_layers_test.jpg";
   // Export the DXF to Image
          image.save(output, jpegOptions);
  

Renderizar Archivos PDF como Parte de Dibujos DXF

Este enfoque funciona de la siguiente manera:

1. Carga un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea un objeto de la clase CadRasterizationOptions y carga archivos PDF.
3. Establece las propiedades PageHeight y PageWidth.
4. Llama a Image.save y guarda el archivo.

El siguiente ejemplo de código muestra cómo renderizar archivos PDF como parte de dibujos DXF.

String srcFile = dataDir + "conic_pyramid.dxf";
		
Image image = Image.load(srcFile);
		
   // Create an instance of CadRasterizationOptions and set its various properties
   CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
   rasterizationOptions.setBackgroundColor(Color.getWhite());
   rasterizationOptions.setPageWidth(1600);
   rasterizationOptions.setPageHeight(1600);

   // Create an instance of PdfOptions
   PdfOptions pdfOptions = new PdfOptions();
   // Set the VectorRasterizationOptions property
   pdfOptions.setVectorRasterizationOptions(rasterizationOptions);

   // Export the DXF to PDF
   image.save(dataDir + "conic_pyramid_out_.pdf", pdfOptions);                	

Exportar DXF a WMF

Este enfoque funciona de la siguiente manera:

1. Carga un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea un objeto de la clase CadRasterizationOptions y carga archivos PDF.
3. Establece las propiedades PageHeight y PageWidth.
4. Llama a Image.save y guarda el archivo.

El siguiente ejemplo de código muestra cómo exportar DXF a WMF.

String srcFile = dataDir + "conic_pyramid.dxf";
		
		Image image = Image.load(srcFile);
		
	        IfcImage cadImage = (IfcImage)Image.load((dataDir +"example.ifc"));
            try
            {
              {
 CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
 
 rasterizationOptions.setPageWidth(100);
 rasterizationOptions.setPageHeight(100);
 WmfOptions wmfOptions = new WmfOptions();
              
 cadImage.save(dataDir+" example.ifc.wmf", wmfOptions);
            }
          }
finally
          {
cadImage.dispose();
          
          }

	    // Export the DXF to PDF
	    image.save(dataDir + "conic_pyramid_out_.pdf");                	
	}

Soporte para Guardar Archivos DXF

Aspose.CAD proporciona la función de cargar archivos DXF de AutoCAD, realizar cambios en ellos y guardarlos nuevamente como un archivo DXF. El siguiente ejemplo de código muestra cómo lograr los requisitos especificados.

        String dataDir = Utils.getDataDir(SaveDXFFiles.class) + "CADConversion/";
        String srcFile = dataDir + "conic_pyramid.dxf";    
        
        CadImage cadImage = (CadImage)Image.load(srcFile);
        cadImage.save(dataDir+"conic.dxf");

Exportar Subyacente DGN Embebido para el Formato DXF

Aspose.CAD proporciona la función de cargar archivos DXF de AutoCAD y exportar la subyacente DGN embebida para el formato DXF.

El siguiente ejemplo de código muestra cómo lograr los requisitos especificados.

        
String dataDir = Utils.getDataDir(ExportEmbeddedDGN.class) + "ExportingDGN/";
		String fileName = dataDir + "BlockRefDgn.dwg";
com.aspose.cad.Image objImage = com.aspose.cad.Image.load(fileName);
 {
   CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
   rasterizationOptions.setLayouts(new String[] {"Model"});
   PdfOptions pdfOptions = new PdfOptions();
   pdfOptions.setVectorRasterizationOptions(rasterizationOptions);
  objImage.save(dataDir + "BlockRefDgn.pdf", pdfOptions);
  }

Exportando Diseño DXF Específico a PDF

Este enfoque funciona de la siguiente manera:

1. Abre un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea una instancia de CadRasterizationOptions y especifica las propiedades PageWidth y PageHeight.
3. Especifica el(los) nombre(s) de diseño deseado(s) utilizando la propiedad CadRasterizationOptions.Layouts.
4. Crea una instancia de PdfOptions y establece su propiedad VectorRasterizationOptions.
5. Exporta el dibujo a PDF utilizando el método Image.save.

El siguiente ejemplo de código muestra cómo convertir un diseño específico de DXF a PDF.

// For complete examples and data files, please go to https://github.com/aspose-cad/Aspose.CAD-for-Java
// The path to the resource directory.
String dataDir = Utils.getDataDir(ExportSpecificDXFLayoutToPDF.class) + "DXFDrawings/";
String srcFile = dataDir + "conic_pyramid.dxf";
	
Image image = Image.load(srcFile); 

// Create an instance of CadRasterizationOptions and set its various properties
CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
rasterizationOptions.setPageWidth(1600);
rasterizationOptions.setPageHeight(1600);   
// Specify desired layout name
rasterizationOptions.setLayouts(new String[] {"Model"});

// Create an instance of PdfOptions
PdfOptions pdfOptions = new PdfOptions();
// Set the VectorRasterizationOptions property
pdfOptions.setVectorRasterizationOptions(rasterizationOptions);

// Export the DXF to PDF
image.save(dataDir + "conic_pyramid_layout_out_.pdf", pdfOptions);

La propiedad CadRasterizationOptions.Layouts es de tipo matriz de cadenas, por lo que puedes especificar más de un diseño a la vez para posible conversión a formato PDF. Al especificar múltiples diseños para la propiedad CadRasterizationOptions.Layouts, el PDF resultante tendría múltiples páginas, donde cada página representa un diseño individual de AutoCAD.

Acceder a Objetos ATTRIB y MTEXT

Este enfoque funciona de la siguiente manera:

1. Abre un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Accede a las entidades dentro del archivo CAD.
3. Comprueba las entidades CadEntityTypeName.MTEXT y CadEntityTypeName.INSERT.
4. Añade a la lista temporal para su posterior procesamiento.

String srcFile = dataDir + "conic_pyramid.dxf";

CadImage cadImage =(CadImage) Image.load(srcFile);
            
List<CadBaseEntity>  mtextList = new ArrayList<CadBaseEntity>();
List<CadBaseEntity> attribList = new ArrayList<CadBaseEntity>();
try
{
    for (CadBaseEntity entity : cadImage.getEntities())
    {
        if (entity.getTypeName() == CadEntityTypeName.MTEXT)
        {
            mtextList.add(entity);
        }

        if (entity.getTypeName() == CadEntityTypeName.INSERT)
        {
            for (CadBaseEntity childObject : entity.getChildObjects())
            {
                if (childObject.getTypeName() == CadEntityTypeName.ATTRIB)
                {
                    attribList.add(childObject);
                }
            }
        }
    }

    System.out.println("MText Size: "+ mtextList.size());
    System.out.println("Attribute Size: "+ attribList.size());
}
finally
{
    cadImage.dispose();
}
      

Descomponer Objetos de Inserción CAD

Este enfoque funciona de la siguiente manera:

1. Abre un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Accede a las entidades dentro del archivo CAD.
3. Comprueba las entidades CadEntityTypeName.INSERT.
4. Comprueba la lista de tipos CadBlockEntity.
5. Procesa las entidades.

            String srcFile = dataDir + "conic_pyramid.dxf";

            CadImage cadImage =(CadImage) Image.load(srcFile);
            
            try
            {
                for (int i=0; i<cadImage.getEntities().length;i++)
                {
                    if (cadImage.getEntities()[i].getTypeName() == CadEntityTypeName.INSERT)
                    {
                        CadBlockEntity block =
                            (CadBlockEntity)cadImage.getBlockEntities().get_Item(((CadInsertObject)cadImage.getEntities()[i]).getName());
                        for (CadBaseEntity blockChild : block.getEntities())
                        {
                            // process entities
                        }
                    }

                }
            }
            finally
            {
                cadImage.dispose();
            }

Soporte de Recorte de Bloques

Aspose.CAD proporciona la función de Recorte de Bloques. El enfoque de Recorte de Bloques funciona de la siguiente manera:

1. Carga un archivo de dibujo DXF utilizando el método de fábrica Image.load.
2. Crea un objeto de la clase CadRasterizationOptions y carga archivos PDF.
3. Establece las propiedades deseadas de CadRasterizationOptions.
4. Llama a Image.save pasando un objeto de PdfOptions como segundo parámetro y guarda el archivo.

El siguiente ejemplo de código muestra cómo funciona el Recorte de Bloques.

// For complete examples and data files, please go to https://github.com/aspose-cad/Aspose.CAD-for-Java
        
// The path to the resource directory.
	    String dataDir = Utils.getDataDir(RenderDXFAsPDF.class) + "DXFDrawings/";
String inputFile = dataDir + "SLS-CW-CD-CE001-R01_blockClip.dxf";
String outputFile = dataDir + "SLS-CW-CD-CE001-R01_blockClip.pdf";
        
CadImage cadImage = (CadImage)Image.load(inputFile);

Margins margins = new Margins();
margins.setTop(5);
margins.setRight(30);
margins.setBottom(5);
margins.setLeft(30);

CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
rasterizationOptions.setBackgroundColor(Color.getWhite());
rasterizationOptions.setDrawType(CadDrawTypeMode.UseObjectColor);
rasterizationOptions.setPageWidth(1200);
rasterizationOptions.setPageHeight(1600);
rasterizationOptions.setMargins(margins);

rasterizationOptions.setLayouts( new String[] { "Model" } );

PdfOptions pdfOptions = new PdfOptions();
pdfOptions.setVectorRasterizationOptions(rasterizationOptions);
        
cadImage.save(outputFile, pdfOptions);
        

Exportar Imágenes a DXF

Usando Aspose.CAD, puedes exportar imágenes al formato DXF. Usando este enfoque, puedes realizar las siguientes acciones:

1. Establecer nueva fuente
2. Ocultar entidades
3. Actualizar texto

El siguiente fragmento de código muestra cómo realizar las acciones mencionadas anteriormente.

// The path to the resource directory.
	String dataDir = Utils.getDataDir(RenderDXFAsPDF.class) + "DXFDrawings/";
        
File[] files = new File(dataDir).listFiles();
for (File file : files) {
    
    String extension = GetFileExtension(file);
    if(extension == ".dxf"){
    
        // ****************************
        //  Set new font per document
        // ****************************
        CadImage cadImage = (CadImage)Image.load(file.getName());
         for (Object style : cadImage.getStyles()) {                     
            //  Set font name
            ((com.aspose.cad.fileformats.cad.cadtables.CadStyleTableObject)style).setPrimaryFontName("Broadway");
        }
         cadImage.save(file.getName() + "_font.dxf");
         
        // ****************************
        //  Hide all "straight" lines
        // ****************************
         CadImage cadImageEntity = (CadImage)Image.load(file.getName());
         for (CadBaseEntity entity : cadImageEntity.getEntities()) {
            //  Make lines invisible
            if ((entity.getTypeName() == CadEntityTypeName.LINE)) {
                entity.setVisible((short)0);
            }
         }
         cadImageEntity.save(file.getName() + "_lines.dxf");
         
        // ****************************
        //  Manipulations with text
        // ****************************
         
        CadImage cadImageText = (CadImage)Image.load(file.getName());
        for (CadBaseEntity entity : cadImageText.getEntities()) {
            //  Make lines invisible
            if ((entity.getTypeName() == CadEntityTypeName.TEXT)) {
                ((CadText)entity).setDefaultValue("New text here!!! :)");
                    break;
            }
         }
        cadImageText.save(file.getName() + "_text.dxf");
        
    }//If extension = .dxf            
}        
        

private static String GetFileExtension(File file) {
    String extension = "";
 
    try {
        if (file != null && file.exists()) {
            String name = file.getName();
            extension = name.substring(name.lastIndexOf("."));
        }
    } catch (Exception e) {
        extension = "";
    }
 
    return extension;
 
}