Dessins DWG

Exportation des dessins DWG vers PDF

L’API Aspose.CAD pour Java peut charger des dessins AutoCAD au format DWG et les convertir en PDF. Ce sujet explique l’utilisation de l’API Aspose.CAD pour réaliser la conversion de DWG en format PDF à travers des étapes simples comme défini ci-après.

L’API prend en charge les révisions DWG AutoCAD suivantes :

• Version DWG 2004 version 16.0 publication 18
• Version DWG 2005 version 16.1
• Version DWG 2010 version 18.0
• Version DWG 2013 version 19.0

Format de fichier DWG

Un DWG est un fichier binaire qui contient des données d’image vectorielle et des métadonnées. Les données d’image vectorielle fournissent des instructions à l’application CAD sur la façon d’afficher le DWG ; les métadonnées peuvent contenir une variété d’informations sur le fichier, y compris des données spécifiques à l’emplacement et également des données client. Les spécifications ouvertes pour le format de fichier DWG peuvent être trouvées dans ce PDF

Convertir des fichiers DWG en PDF

Les étapes simples suivantes sont nécessaires pour convertir DWG en PDF.

1. Chargez le fichier DWG dans une instance de Image.
2. Créez un objet de la classe CadRasterizationOptions et définissez les propriétés PageHeight & PageWidth.
3. Créez un objet de la classe PdfOptions et définissez la propriété VectorRasterizationOptions.
4. Appelez la méthode Image.save et passez l’objet de PdfOptions comme deuxième paramètre.

Le code ci-dessous montre comment exporter des dessins DWG vers PDF.

String srcFile = dataDir + "Bottom_plate.dwg";
		
		 com.aspose.cad.Image objImage = com.aspose.cad.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 DWG to PDF
objImage.save(dataDir + "Bottom_plate_out_.pdf", pdfOptions);

Créer un PDF unique avec différentes tailles de mise en page

Aspose.CAD pour Java vous permet de convertir le fichier DWG en un seul PDF avec différentes tailles de mise en page. Cette approche fonctionne comme suit :

1. Chargez un fichier DWG en utilisant la méthode de fabrique Aspose.CAD.Image.load.
2. Créez une instance de la classe CadRasterizationOptions et définissez la hauteur et la largeur de la page résultantes.
3. Ajoutez les tailles de mise en page requises LayoutPageSizes pour l’objet CadRasterizationOptions.
4. Créez une instance de la classe PdfOptions et définissez sa propriété VectorRasterizationOptions.
5. Exportez l’image au format PDF en utilisant la méthode Image.save .

Le code ci-dessous montre comment créer un PDF unique avec différentes mises en page.

String dataDir = Utils.getDataDir(SinglePDFWithDifferentLayouts.class) + "DWGDrawings/"; 
    
CadImage cadImage = (CadImage)Image.load(dataDir + "City skyway map.dwg");
    
    CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
    rasterizationOptions.setPageWidth(1000);
    rasterizationOptions.setPageHeight(1000);

    //custom sizes for several layouts
    rasterizationOptions.getLayoutPageSizes().addItem("ANSI C Plot", new SizeF(500, 1000));
    rasterizationOptions.getLayoutPageSizes().addItem("8.5 x 11 Plot", new SizeF(1000, 100));

    PdfOptions pdfOptions = new PdfOptions();
    pdfOptions.setVectorRasterizationOptions(rasterizationOptions);

    cadImage.save(dataDir + "singlePDF_out.pdf", pdfOptions);

    
    

Exportation de DWG vers PDF/A et PDF/E

Les étapes simples suivantes sont nécessaires pour convertir DWG en PDF.

1. Chargez le fichier DWG dans une instance de Image.
2. Créez un objet de la CadRasterizationOptions classe et définissez les propriétés PageHeight & PageWidth.
3. Créez un objet de la PdfOptions classe et définissez la propriété VectorRasterizationOptions.
4. Appelez la Image.save méthode et passez l’objet de PdfOptions comme deuxième paramètre.

Le code ci-dessous montre comment exporter des dessins DWG vers PDF.

String srcFile = dataDir + "Bottom_plate.dwg";
       		
	
      com.aspose.cad.Image objImage = com.aspose.cad.Image.load(srcFile);
     // Create an instance of PdfOptions
      PdfOptions pdfOptions = new PdfOptions();
      pdfOptions.setVectorRasterizationOptions(new CadRasterizationOptions());

      pdfOptions.setCorePdfOptions(new PdfDocumentOptions());

      pdfOptions.getCorePdfOptions().setCompliance(PdfCompliance.PdfA1a);
      objImage.save(dataDir+"Saved1.pdf", pdfOptions);

      pdfOptions.getCorePdfOptions().setCompliance(PdfCompliance.PdfA1b);
      objImage.save(dataDir+"Saved.pdf", pdfOptions);

Primitives AutoCAD prises en charge

Les primitives AutoCAD suivantes sont prises en charge.

• TEXTE
• MTEXTE
• ATTDEF
• ATTRIB
• ARC
• ÉLLIPSE
• HACHURE
• LEADER
• POINT
• VERTEX 2D
• VERTEX 3D
• POLYLINE 2D
• LWPOLYLINE
• RAY
• CERCLE
• DIMENSION ORDONNÉE
• DIMENSION LINÉAIRE
• DIMENSION ALIGNÉE
• DIMENSION ANG 3Pt
• DIMENSION ANG 2Ln
• DIMENSION RAYON
• DIMENSION DIAMÈTRE
• FORME
• SOLIDE
• SPLINE
• MLINE
• LIGNE
• XLINE
• STYLE
• DIMSTYLE
• LTYPE
• MLINESTYLE
• CALQUE
• VUEPORT
• MISE EN PAGE

Exportation d’une mise en page DWG spécifique vers PDF

Cette approche fonctionne comme suit :

1. Chargez un fichier DWG en utilisant la méthode de fabrique Image.load.
2. Créez une instance de la classe CadRasterizationOptions et définissez la hauteur et la largeur de la page résultantes.
3. Définissez la propriété Layouts pour l’objet CadRasterizationOptions.
4. Créez une instance de la classe PdfOptions et définissez sa propriété VectorRasterizationOptions.
5. Exportez l’image au format PDF en utilisant la méthode Image.save() .

Le code ci-dessous montre comment convertir une mise en page spécifique de DWG en PDF.

String srcFile = dataDir + "visualization_-_conference_room.dwg";

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[] {"Layout1"});

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

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

Exportation de DWG vers Raster ou PDF en utilisant une taille fixe

L’API Aspose.CAD pour Java peut charger des dessins AutoCAD au format DWG et les convertir en PDF ou Raster en utilisant une taille fixe.

Le code ci-dessous montre comment implémenter cette fonctionnalité.

	public static void main(String[] args) 
        {
		
            // The path to the resource directory.
	
            String dataDir = Utils.getDataDir(ExportDWGToPDFOrRaster.class) + "DWGDrawings/";
         	
            String srcFile = dataDir + "Bottom_plate.dwg";
       
            com.aspose.cad.Image objImage = com.aspose.cad.Image.load(srcFile);
            Boolean currentUnitIsMetric = IsMetric(objImage.getUnitType());
            int currentUnitCoefficient = objImage.getUnitType();
            
            if (currentUnitIsMetric)
            {
                double metersCoeff = 1 / 1000.0;
                double scaleFactor = metersCoeff / currentUnitCoefficient;
                CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
                rasterizationOptions.setPageWidth((float)(210 * scaleFactor));
                rasterizationOptions.setPageHeight((float)(297 * scaleFactor));
                rasterizationOptions.setUnitType(UnitType.Millimeter);
            }
            else
            {

                CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
                rasterizationOptions.setPageWidth((float)(8.27f / currentUnitCoefficient));
                rasterizationOptions.setPageHeight((float)(11.69f / currentUnitCoefficient));
                rasterizationOptions.setUnitType(UnitType.Inch);
            }
            
            PdfOptions pdfOptions = new PdfOptions();
            pdfOptions.setVectorRasterizationOptions(new CadRasterizationOptions());
            objImage.save(dataDir+"Saved.pdf", pdfOptions);

        }


         public static Boolean IsMetric(int initial)
         {
         
            Boolean isMetric = true;
		 
            switch (initial)
{
          case UnitType.Inch:
          case UnitType.MicroInch:
          case UnitType.Mil:
          case UnitType.Foot:
          case UnitType.Yard:
          case UnitType.Mile:
          case UnitType.Unitless:
          isMetric = false;
}
         	 
return isMetric;
}
	 
private Double Coefficient(int unitType)
{
         Double coefficient = 1.0;

         switch (unitType)
         {
             case UnitType.Parsec:
                 coefficient = 3.0857 * 10000000000000000.0;
                 break;
            case UnitType.LightYear:
                 coefficient = 9.4607 * 1000000000000000.0;
                 break;
             case UnitType.AstronomicalUnit:
                 coefficient = 1.4960 * 100000000000.0;
                 break;
             case UnitType.Gigameter:
                 coefficient = 1000000000.0;
                 break;
             case UnitType.Kilometer:
                 coefficient = 1000.0;
                 break;
             case UnitType.Decameter:
                 coefficient = 10.0;
                 break;
             case UnitType.Hectometer:
                 coefficient = 100.0;
                 break;
             case UnitType.Meter:
                 coefficient = 1.0;
                 break;
             case UnitType.Centimenter:
                 coefficient = 0.01;
                 break;
             case UnitType.Decimeter:
                 coefficient = 0.1;
                 break;
             case UnitType.Millimeter:
                 coefficient = 0.001;
                 break;
             case UnitType.Micrometer:
                 coefficient = 0.000001;
                 break;
             case UnitType.Nanometer:
                 coefficient = 0.000000001;
                 break;
             case UnitType.Angstrom:
                 coefficient = 0.0000000001;
                 break;
             case UnitType.Inch:
                 coefficient = 1.0;
                 break;
             case UnitType.MicroInch:
                 coefficient = 0.000001;
                 break;
             case UnitType.Mil:
                 coefficient = 0.001;
                 break;
             case UnitType.Foot:
                 coefficient = 12.0;
                 break;
             case UnitType.Yard:
                 coefficient = 36.0;
                 break;
             case UnitType.Mile:
                 coefficient = 63360.0;
                 break;
         }
         
         return coefficient;
        }

Support des lignes cachées arrondies lors de l’exportation de DWG/DXF vers BMP et PDF

Cette approche fonctionne comme suit :

1. Chargez un fichier DWG en utilisant la méthode Aspose.CAD.Image.load méthode de fabrique.
2. Créez une instance de la classe CadRasterizationOptions.
3. Créez une instance de la classe CadRasterizationOptions et définissez la hauteur et la largeur de la page résultantes.
4. Créez une instance de la classe PdfOptions et définissez sa propriété VectorRasterizationOptions.
5. Exportez l’image au format PDF en utilisant la méthode Image.save() .

Le code ci-dessous montre comment implémenter cette fonctionnalité.

// The path to the resource directory.
       String dataDir = Utils.getDataDir(SupportForHiddenLines.class) + "DWGDrawings/";
    
       String sourceFilePath = dataDir + "Bottom_plate.dwg";
       String outPath = dataDir + "Bottom_plate.pdf";
       CadImage cadImage = (CadImage)Image.load(sourceFilePath);
              
       
       List<String> list = Arrays.asList("Print","L1_RegMark","L2_RegMark");
       CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
       rasterizationOptions.setPageHeight(cadImage.getHeight());
       rasterizationOptions.setPageWidth(cadImage.getWidth()) ;
       rasterizationOptions.setLayers(list);
      


       PdfOptions pdfOptions = new PdfOptions();
       rasterizationOptions.setLayouts(new String[] { "Model" });
       pdfOptions.setVectorRasterizationOptions(rasterizationOptions);

       cadImage.save(outPath, pdfOptions);
       
       System.out.println("\nThe DWG file exported successfully to PDF.\nFile saved at " + dataDir);

Support pour définir la zone d’impression pour l’image DWG dans le PDF exporté

L’API Aspose.CAD pour Java peut charger des dessins AutoCAD au format DWG et les convertir en PDF. Ce sujet explique l’utilisation de l’API Aspose.CAD pour obtenir le support nécessaire pour définir une zone d’impression pour l’image DWG dans le PDF exporté.

Le code ci-dessous montre comment implémenter cette fonctionnalité.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "visualization_-_conference_room.dwg";
using (Aspose.CAD.Image image = Aspose.CAD.Image.Load(sourceFilePath))
{
    // Create an instance of CadRasterizationOptions and set its various properties
    Aspose.CAD.ImageOptions.CadRasterizationOptions rasterizationOptions = new Aspose.CAD.ImageOptions.CadRasterizationOptions();
    rasterizationOptions.PageWidth = 1600;
    rasterizationOptions.PageHeight = 1600;
    // Specify desired layout name
    rasterizationOptions.Layouts = new string[] { "Layout1" };

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

    MyDir = MyDir + "ExportSpecificLayoutToPDF_out.pdf";
    //Export the DWG to PDF
    image.Save(MyDir, pdfOptions);                
}

Support pour la lecture des métadonnées XREF pour le fichier DWG

1. Chargez un fichier DWG en utilisant la méthode Aspose.CAD.Image.load méthode de fabrique.
2. Parcourez chaque entité image.
3. Si l’entité est CadUnderlay alors entité XREF avec des métadonnées.

Le code ci-dessous montre comment réaliser cette fonctionnalité.

CadImage image = (CadImage)Image.load(dataDir+"Bottom_plate.dwg");
{
    for (CadBaseEntity entity : image.getEntities())
    {
        if (entity instanceof CadUnderlay)
        {
            //XREF entity with metadata
            Cad3DPoint insertionPoint = ((CadUnderlay) entity).getInsertionPoint();
            String path = ((CadUnderlay) entity).getUnderlayPath();
        }
    }
}	

Document DWG en spécifiant des coordonnées

L’API Aspose.CAD pour Java fournit maintenant une fonctionnalité pour rendre des documents DWG en fournissant les coordonnées de la largeur et de la hauteur du document.

Le code ci-dessous montre comment rendre un document DWG.

String srcFile = dataDir + "visualization_-_conference_room.dwg";
       		
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[] {"Layout1"});

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

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

La propriété CadRasterizationOptions.Layouts est de type tableau de chaînes, vous pouvez donc spécifier plus d’une mise en page à la fois pour une conversion possible au format PDF. En spécifiant plusieurs mises en page pour la propriété CadRasterizationOptions.Layouts, le PDF résultant aurait plusieurs pages, où chaque page représente une mise en page AutoCAD individuelle.

Lister toutes les mises en page

Vous pouvez lister toutes les mises en page présentes dans un dessin AutoCAD en utilisant le code ci-dessous.

String srcFile = dataDir + "conic_pyramid.dxf";

Image image = Image.load(srcFile);
		
	    CadImage cadImage = (CadImage)image;

	    CadLayoutDictionary layouts = cadImage.getLayouts();
	    for (CadLayout layout : layouts.getValues())
{
	        System.out.println("Layout " + layout.getLayoutName());
	    }
            

Obtenir la valeur d’attribut de bloc de référence externe

L’API Aspose.CAD pour Java vous permet d’obtenir une référence externe d’un attribut de bloc. L’API Aspose.CAD expose la propriété getXRefPathName() pour obtenir la référence externe d’un attribut de bloc dans une collection CadBlockDictionary.

Le code suivant démontre comment obtenir une référence externe d’un attribut de bloc.

// Load an existing DWG file as CadImage.
CadImage cadImage = (CadImage) Image.load(dataDir + "sample.dwg");
		
// Access the external path name property
CadStringParameter sXternalRef = cadImage.getBlockEntities().get_Item("*MODEL_SPACE").getXRefPathName();
System.out.println(sXternalRef);

Rechercher du texte dans un fichier AutoCAD DWG

L’API Aspose.CAD pour Java vous permet de rechercher du texte dans un fichier DWG AutoCAD. L’API Aspose.CAD expose la classe CadText qui représente des entités de texte dans le fichier AutoCAD DWG. La classe CadMText est également incluse dans l’API Aspose.CAD car certaines autres entités peuvent également contenir du texte.

Le code ci-dessous démontre comment rechercher du texte dans le fichier AutoCAD DWG.

private static final String dataDir = Utils.getDataDir(SearchTextInDWGAutoCADFile.class) + "DWGDrawings/";

public static void main(String[] args) {
	// Search Text In DWG AutoCAD File
	searchTextInDWGAutoCADFile();
	
	// Search For Text In Specific Layout
	
}

public static void searchTextInDWGAutoCADFile() 
      { 
   //String  dataDir="Test_Apsose.CAD\\";
    // Load an existing DWG file as CadImage.
    CadImage cadImage = (CadImage) CadImage.load(dataDir + "sample_file.dwg");
    for (CadBaseEntity entity : cadImage.getEntities()) 
    {
      IterateCADNodeEntities(entity); 
    } 

   // Search for text in the block section 
   for (CadBlockEntity blockEntity : cadImage.getBlockEntities().getValues())
   { 
       for (CadBaseEntity entity : blockEntity.getEntities())
       { 
           IterateCADNodeEntities(entity); 
       } 
   } 
} 
//Recursive function to iterate nodes inside nodes
private static void IterateCADNodeEntities(CadBaseEntity obj) 
{ 
   switch (obj.getTypeName())
   { 
       case CadEntityTypeName.TEXT: 
           CadText childObjectText = (CadText) obj; 

           System.out.println(childObjectText.getDefaultValue()); 

           break; 

       case CadEntityTypeName.MTEXT: 
           CadMText childObjectMText = (CadMText) obj; 

           System.out.println(childObjectMText.getText()); 

           break; 

       case CadEntityTypeName.INSERT: 
           CadInsertObject childInsertObject = (CadInsertObject) obj; 

           for (CadBaseEntity tempobj : childInsertObject.getChildObjects())
           { 
               IterateCADNodeEntities(tempobj); 
           } 
           break; 

       case CadEntityTypeName.ATTDEF: 
           CadAttDef attDef = (CadAttDef) obj; 

           System.out.println(attDef.getDefaultString()); 
           break; 

       case CadEntityTypeName.ATTRIB: 
           CadAttrib attAttrib = (CadAttrib) obj; 

           System.out.println(attAttrib.getDefaultText()); 
           break; 
   } 
}

  

Rechercher du texte dans une mise en page spécifique

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// Load an existing DWG file as CadImage.
CadImage cadImage = (CadImage) CadImage.load(dataDir + "sample_file.dwg");

// get all layout names and link each layout with corresponding block with entities
CadLayoutDictionary layouts = cadImage.getLayouts();
String[] layoutNames = new String[layouts.size()];
int i = 0;

for (com.aspose.cad.fileformats.cad.cadobjects.CadLayout layout : layouts.getValues()) {
    layoutNames[i++] = layout.getLayoutName();
    System.out.println("Layout " + layout.getLayoutName() + " is found");

    // find block, applicable for DWG only
    CadBlockTableObject blockTableObjectReference = null;
    for (CadBlockTableObject tableObject : cadImage.getBlocksTables()) {
        if (String.CASE_INSENSITIVE_ORDER.compare(tableObject.getHardPointerToLayout(), layout.getObjectHandle()) == 0) {
            blockTableObjectReference = tableObject;
            break;
        }
    }

    // Collection cadBlockEntity.Entities contains information about all entities on specific layout
    // if this collection has no elements it means layout is a copy of Model layout and contains the same entities
    // Below line of code is for reference
    CadBlockEntity cadBlockEntity = cadImage.getBlockEntities().get_Item(blockTableObjectReference.getBlockName());
}

Accéder aux indicateurs de sous-couche pour le format DWG

Aspose.CAD pour Java a implémenté les indicateurs de sous-couche pour le format DWG et permet aux développeurs d’y accéder. Voici la simple démonstration de code.

String dataDir = Utils.getDataDir(AccessingUnderlayFlagsofDWG.class) + "DWGDrawings/";
  String fileName = dataDir + "BlockRefDgn.dwg";

  // Load an existing DWG file and convert it into CadImage 
  com.aspose.cad.fileformats.cad.CadImage image = (com.aspose.cad.fileformats.cad.CadImage) com.aspose.cad.Image.load(fileName);

  // Go through each entity inside the DWG file
  for (com.aspose.cad.fileformats.cad.cadobjects.CadBaseEntity entity : image.getEntities())
  {

     // Check if entity is of CadDgnUnderlay type
      if (entity instanceof com.aspose.cad.fileformats.cad.cadobjects.CadDgnUnderlay)
      {
          // Access different underlay flags
          com.aspose.cad.fileformats.cad.cadobjects.CadUnderlay underlay = (com.aspose.cad.fileformats.cad.cadobjects.CadUnderlay) entity;
          System.out.println(underlay.getUnderlayPath());
          System.out.println(underlay.getUnderlayName());
          System.out.println(underlay.getInsertionPoint().getX());
          System.out.println(underlay.getInsertionPoint().getY());
          System.out.println(underlay.getRotationAngle());
          System.out.println(underlay.getScaleX());
          System.out.println(underlay.getScaleY());
          System.out.println(underlay.getScaleZ());
          System.out.println((underlay.getFlags() & com.aspose.cad.fileformats.cad.cadobjects.UnderlayFlags.UnderlayIsOn) == com.aspose.cad.fileformats.cad.cadobjects.UnderlayFlags.UnderlayIsOn);
          System.out.println((underlay.getFlags() & com.aspose.cad.fileformats.cad.cadobjects.UnderlayFlags.ClippingIsOn) == com.aspose.cad.fileformats.cad.cadobjects.UnderlayFlags.ClippingIsOn);
          System.out.println((underlay.getFlags() & com.aspose.cad.fileformats.cad.cadobjects.UnderlayFlags.Monochrome) != com.aspose.cad.fileformats.cad.cadobjects.UnderlayFlags.Monochrome);
          break;
      }
  }

Support des entités DWG

L’API Aspose.CAD pour Java peut charger des dessins AutoCAD au format DWG et prendre en charge différentes entités avec lesquelles travailler.

Support pour l’entité MLeader

Un DWG est un fichier binaire qui contient des données d’image vectorielle et des métadonnées. Il existe différentes entités dans un fichier DWG. La section suivante décrit un exemple de travail avec l’entité MLeader à l’intérieur du fichier DWG.

       
     String file = dataDir + "Multileaders.dwg";
     Image image = Image.load(file);
     
         // Test
         CadImage cadImage = (CadImage)image;

  
        Assert.areNotEqual(cadImage.getEntities().length, 0);
         CadMLeader cadMLeader = (CadMLeader)cadImage.getEntities()[2];

         Assert.areEqual(cadMLeader.getStyleDescription(), "Standard");
         Assert.areEqual(cadMLeader.getLeaderStyleId(), "12E");
         Assert.areEqual(cadMLeader.getArrowHeadId1(), "639");
         Assert.areEqual(cadMLeader.getLeaderLineTypeID(), "14");

         CadMLeaderContextData context = cadMLeader.getContextData();

         Assert.areEqual(context.getArrowHeadSize(), 30.0, 0.1);
         Assert.areEqual(context.getBasePoint().getX(), 481, 1);
         Assert.areEqual(context.getContentScale(), 1.0, 0.01);
         Assert.areEqual(context.getDefaultText().getValue(), "This is multileader with huge text\\P{\\H1.5x;6666666666666666666666666666\\P}bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
         Assert.areEqual(context.hasMText(), true);

         CadMLeaderNode mleaderNode = context.getLeaderNode();

         Assert.areEqual(mleaderNode.getLastLeaderLinePoint().getX(), 473, 1);
         CadMLeaderLine leaderLine = mleaderNode.getLeaderLine();

         Assert.areEqual(leaderLine.getBreakEndPoint().toString(), null);
         Assert.areEqual(Integer.toString(leaderLine.getBreakPointIndex().getValue()), Integer.toString(0));
         Assert.areEqual(leaderLine.getBreakStartPoint().toString(), null);
         Assert.areEqual(Integer.toString(leaderLine.getLeaderLineIndex().getValue()), Integer.toString(0));
         Assert.areEqual(Integer.toString(leaderLine.getLeaderPoints().size()), Integer.toString(4));

         Assert.areEqual(Integer.toString(mleaderNode.getBranchIndex()), Integer.toString(0));


         Assert.areEqual(mleaderNode.getDogLegLength(), 8.0, 0.1);

         Assert.areEqual(context.hasMText(), true);
         
       //  Assert.IsTrue((context.hasMText()==true , "Invalid Z value");
         Assert.areEqual(context.getTextAttachmentType().getValue(), (short)1);
         Assert.areEqual(context.getTextBackgroundColor().getValue(), 18);
         Assert.areEqual(context.getTextHeight(), 20.0, 0.1);
         Assert.areEqual(context.getTextStyleID().getValue(), "11");
         Assert.areEqual(context.getTextRotation().getValue(), 0.0, 0.01);

         Assert.areEqual(cadMLeader.getArrowHeadId1(), "639");
         Assert.areEqual(cadMLeader.getLeaderType(), 1);
         Assert.areEqual(cadMLeader.getBlockContentColor(), 0);
         Assert.areEqual(cadMLeader.getLeaderLineColor(), 0);
         Assert.areEqual(cadMLeader.getTextHeight(), 1.0, 0.01);

Support pour l’exportation de l’entité DWG vers l’image

Un DWG est un fichier binaire qui contient des données d’image vectorielle et des métadonnées. Il existe différentes entités dans un fichier DWG. La section suivante décrit un exemple d’exportation d’une entité DWG particulière vers l’image.

// The path to the resource directory.
    String dataDir = Utils.getDataDir(ParticularDWGToImage.class) + "DWGDrawings/";
    String sourceFilePath = dataDir + "visualization_-_conference_room.dwg";

    CadImage cadImage = ((CadImage)(Image.load(sourceFilePath)));

    CadBaseEntity[] entities = cadImage.getEntities();
    
    List<CadBaseEntity> filteredEntities = new ArrayList<CadBaseEntity>();
    for (CadBaseEntity baseEntity : entities) {
    // selection or filtration of entities
    if ((baseEntity.getTypeName() == CadEntityTypeName.TEXT)) {
    filteredEntities.add(baseEntity);
    }

    }
 
CadBaseEntity[] arr = new CadBaseEntity[filteredEntities.size()];
cadImage.setEntities(filteredEntities.toArray(arr));
// Create an instance of CadRasterizationOptions and set its various properties
CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
rasterizationOptions.setPageWidth(1600);
rasterizationOptions.setPageHeight(1600);
// Set Auto Layout Scaling
rasterizationOptions.setAutomaticLayoutsScaling(true);
// Create an instance of PdfOptions
PdfOptions pdfOptions = new PdfOptions();
// Set the VectorRasterizationOptions property
pdfOptions.setVectorRasterizationOptions(rasterizationOptions);
String outFile = dataDir + "result_out_generated.pdf";
// Export the CAD to PDF
cadImage.save(outFile, pdfOptions);

Support pour importer une image dans un fichier DWG

L’API Aspose.CAD pour Java peut charger des dessins AutoCAD au format DWG et prendre en charge différentes entités avec lesquelles travailler. Un DWG est un fichier binaire qui contient des données d’image vectorielle et des métadonnées. Il existe différentes entités dans un fichier DWG. La section suivante décrit comment nous pouvons importer des images à l’intérieur du fichier DWG.

Support pour ajouter du texte dans DWG

L’API Aspose.CAD pour Java peut charger des dessins AutoCAD au format DWG et prendre en charge différentes entités avec lesquelles travailler. Un DWG est un fichier binaire qui contient des données d’image vectorielle et des métadonnées. Il existe différentes entités dans un fichier DWG. La section suivante décrit comment nous pouvons ajouter du texte à l’intérieur du fichier DWG.

String dataDir = Utils.getDataDir(AddTextInDWG.class) + "DWGDrawings/";
String dwgPathToFile = dataDir + "SimpleEntites.dwg";
    
    
Image image = Image.load(dwgPathToFile);
    
CadText cadText = new CadText();
cadText.setStyleType("Standard");
cadText.setDefaultValue("Some custom text");
cadText.setColorId(256);
cadText.setLayerName("0");
cadText.getFirstAlignment().setX(47.9);
cadText.getFirstAlignment().setY(5.56);
cadText.setTextHeight(0.8);
cadText.setScaleX(0);
    
CadImage cadImage = ((CadImage)(image));
cadImage.getBlockEntities().get_Item("*Model_Space").addEntity(cadText);
    
PdfOptions pdfOptions = new PdfOptions();
    
CadRasterizationOptions cadRasterizationOptions = new CadRasterizationOptions();
    
pdfOptions.setVectorRasterizationOptions(cadRasterizationOptions);
    
cadRasterizationOptions.setDrawType(CadDrawTypeMode.UseObjectColor);
 
cadRasterizationOptions.setPageHeight(1600);
cadRasterizationOptions.setPageWidth(1600);
cadRasterizationOptions.setLayouts(new String[] {"Model"});
image.save(dataDir+"SimpleEntites_generated.dwg.pdf", pdfOptions);

Support pour les maillages dans DWG

L’API Aspose.CAD pour Java peut désormais accéder aux entités prenant en charge les maillages, qui incluent les types CadPolyFaceMesh et CadPolygonMesh. L’exemple suivant décrit comment nous pouvons accéder aux types de maillage.

Convertir des dessins DWG en DXF

Aspose.CAD offre la fonctionnalité de charger un fichier DWG AutoCAD et de l’exporter au format DXF. L’approche de conversion de DWG à DXF fonctionne comme suit :

1. Chargez le fichier de dessin DWG en utilisant la méthode de fabrique Image.load .
2. Exportez le dessin DWG en DXF en utilisant la méthode Image.save() .

Le code ci-dessous montre comment convertir un fichier DWG en format DXF.

// The path to the resource directory.
String dataDir = Utils.getDataDir(DWGToDXF.class) + "DWGDrawings/";
String inputFile = dataDir+ "Line.dwg";
String outFile = dataDir+ "Line.dxf";
CadImage cadImage = (CadImage)Image.load(inputFile);
    
cadImage.save(outFile);

Convertir des dessins DWG en SVG

L’API Aspose.CAD peut charger des dessins AutoCAD au format DWG et les convertir en SVG. Ce sujet explique l’utilisation de l’API Aspose.CAD pour réaliser la conversion de DWG en format SVG à travers des étapes simples comme défini ci-dessous.

1. Chargez le fichier DWG dans une instance de Image.
2. Créez un objet de la classe SvgOptions et définissez les propriétés requises.
3. Exportez le dessin DWG en SVG en utilisant la méthode Image.save() .

Le code ci-dessous montre comment convertir un fichier DWG en format SVG.

// The path to the resource directory.
String dataDir = Utils.getDataDir(ExportToSVG.class) + "DWGDrawings/";
Image image = Image.load(dataDir + "meshes.dwg");
{
    SvgOptions options = new SvgOptions();
    options.setColorType(SvgColorMode.Grayscale);
    options.setTextAsShapes(true);
    image.save(dataDir + "meshes.svg");
}