Disegni DWG

Esportazione di Disegni DWG in PDF

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e convertirli in PDF. Questo argomento spiega l’uso dell’API Aspose.CAD per ottenere la conversione da DWG a PDF attraverso semplici passaggi definiti di seguito.

L’API supporta le seguenti revisioni DWG di AutoCAD:

• Versione 16.0 rilascio 18 DWG 2004
• Versione 16.1 DWG 2005
• Versione 18.0 DWG 2010
• Versione 19.0 DWG 2013

Formato File DWG

Un DWG è un file binario che contiene dati di immagine vettoriale e metadati. I dati dell’immagine vettoriale forniscono istruzioni all’applicazione CAD su come visualizzare il DWG; i metadati possono contenere una varietà di informazioni sul file, inclusi dati specifici della posizione e anche dati dei clienti. Le specifiche aperte per il formato file DWG possono essere trovate in questo PDF

Convertire File DWG in PDF

I seguenti semplici passaggi sono necessari per convertire DWG in PDF.

1. Carica il file DWG in un’istanza di Image.
2. Crea un oggetto della classe CadRasterizationOptions e imposta le proprietà PageHeight e PageWidth.
3. Crea un oggetto della classe PdfOptions e imposta la proprietà VectorRasterizationOptions.
4. Chiama Image.Save passando un oggetto di PdfOptions come secondo parametro.

Il campione di codice qui sotto mostra come esportare Disegni DWG in PDF.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "Bottom_plate.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.BackgroundColor = Aspose.CAD.Color.White;
    rasterizationOptions.PageWidth = 1600;
    rasterizationOptions.PageHeight = 1600;

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

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

Crea un PDF Unico con Dimensioni di Layout Diverse

Aspose.CAD per .NET consente di convertire un file DWG in un singolo PDF con dimensioni di layout diverse. Questo approccio funziona come segue:

1. Carica un file DWG utilizzando il metodo factory Aspose.CAD.Image.Load.
2. Crea un’istanza della classe CadRasterizationOptions e imposta l’altezza e la larghezza della pagina risultante.
3. Aggiungi le LayoutPageSizes richieste per l’oggetto CadRasterizationOptions.
4. Crea un’istanza della classe PdfOptions e imposta la sua proprietà VectorRasterizationOptions.
5. Esporta l’immagine in PDF utilizzando il metodo Image.Save().

Il campione di codice qui sotto mostra come creare un unico PDF con layout diversi.

            // The path to the documents directory.
            string MyDir = RunExamples.GetDataDir_DWGDrawings();


            using (CadImage cadImage = (CadImage)Image.Load(MyDir + "City skyway map.dwg"))
            {
                CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
                rasterizationOptions.PageWidth = 1000;
                rasterizationOptions.PageHeight = 1000;

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

                PdfOptions pdfOptions = new PdfOptions() { VectorRasterizationOptions = rasterizationOptions };

                cadImage.Save(MyDir + "singlePDF_out.pdf", pdfOptions);

            }

Primitive AutoCAD Supportate

Le seguenti primitive AutoCAD sono supportate.

• TESTO
• MTEXT
• ATTDEF
• ATTRIB
• ARC
• ELLISSE
• RIFORO
• GUIDA
• PUNTO
• VERTICE 2D
• VERTICE 3D
• POLILINEA 2D
• LWPOLYLINE
• RAY
• CERCHIO
• DIMENSIONE ORDINATA
• DIMENSIONE LINEARE
• DIMENSIONE ALLINEATA
• DIMENSIONE ANG 3Pt
• DIMENSIONE ANG 2Ln
• DIMENSIONE RAGGIO
• DIMENSIONE DIAMETRO
• FORMA
• SOLIDO
• SPLINE
• MLINE
• LINEA
• XLINE
• STILE
• DIMSTYLE
• LTYPE
• MLINESTYLE
• LAYER
• VIEWPORT
• LAYOUT

Esportazione di un Layout Specifico DWG in PDF

Questo approccio funziona come segue:

1. Carica un file DWG utilizzando il metodo factory Aspose.CAD.Image.Load.
2. Crea un’istanza della classe CadRasterizationOptions e imposta l’altezza e la larghezza della pagina risultante.
3. Imposta la proprietà Layouts per l’oggetto CadRasterizationOptions.
4. Crea un’istanza della classe PdfOptions e imposta la sua proprietà VectorRasterizationOptions.
5. Esporta l’immagine in PDF utilizzando il metodo Image.Save().

Il campione di codice qui sotto mostra come convertire un layout specifico di DWG in PDF.

// 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);                
}

Renderizza il documento DWG specificando le coordinate

Aspose.CAD per .NET API ora fornisce una funzionalità per rendere i documenti DWG fornendo le coordinate della larghezza e dell’altezza del documento.

Il campione di codice qui sotto mostra come rendere un documento DWG.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "Bottom_plate.dwg";
using (CadImage cadImage = (CadImage)Image.Load(sourceFilePath))
{
    CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
    rasterizationOptions.Layouts = new string[] { "Model" };
    rasterizationOptions.NoScaling = true;

    // note: preserving some empty borders around part of image is the responsibility of customer
    // top left point of region to draw
    Point topLeft = new Point(6156, 7053);
    double width = 3108;
    double height = 2489;

    CadVportTableObject newView = new CadVportTableObject();

    // note: exactly such table name is required for active view
    newView.Name.Value = "*Active";
    newView.CenterPoint.X = topLeft.X + width / 2f;
    newView.CenterPoint.Y = topLeft.Y - height / 2f;
    newView.ViewHeight.Value = height;
    newView.ViewAspectRatio.Value = width / height;

    // search for active viewport and replace it
    for (int i = 0; i < cadImage.ViewPorts.Count; i++)
    {
        CadVportTableObject currentView = (CadVportTableObject)(cadImage.ViewPorts[i]);
        if ((currentView.Name.Value == null && cadImage.ViewPorts.Count == 1) ||
        string.Equals(currentView.Name.Value.ToLowerInvariant(), "*active"))
        {
            cadImage.ViewPorts[i] = newView;
            break;
        }
    }
    PdfOptions pdfOptions = new PdfOptions();
    rasterizationOptions.Layouts = new string[] { "Model" };
    pdfOptions.VectorRasterizationOptions = rasterizationOptions;

    cadImage.Save(MyDir, pdfOptions);                
}

Esportazione di DWG in Raster o PDF utilizzando Dimensione Fissa

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e convertirli in PDF o Raster utilizzando dimensioni fisse.

Il campione di codice qui sotto mostra come implementare questa funzionalità.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "Bottom_plate.dwg";
string outPath = MyDir + "Bottom_plate.pdf";

using (CadImage cadImage = (CadImage)Image.Load(sourceFilePath))
{

    // export to pdf
    CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
    rasterizationOptions.Layouts = new string[] { "Model" };

    bool currentUnitIsMetric = false;
    double currentUnitCoefficient = 1.0;
    DefineUnitSystem(cadImage.UnitType, out currentUnitIsMetric, out currentUnitCoefficient);

    if (currentUnitIsMetric)
    {
        double metersCoeff = 1 / 1000.0;

        double scaleFactor = metersCoeff / currentUnitCoefficient;

        rasterizationOptions.PageWidth = (float)(210 * scaleFactor);
        rasterizationOptions.PageHeight = (float)(297 * scaleFactor);
        rasterizationOptions.UnitType = UnitType.Millimeter;
    }
    else
    {
        rasterizationOptions.PageWidth = (float)(8.27f / currentUnitCoefficient);
        rasterizationOptions.PageHeight = (float)(11.69f / currentUnitCoefficient);
        rasterizationOptions.UnitType = UnitType.Inch;
    }

    rasterizationOptions.AutomaticLayoutsScaling = true;

    PdfOptions pdfOptions = new PdfOptions
    {
        VectorRasterizationOptions = rasterizationOptions
    };

    cadImage.Save(outPath, pdfOptions);

    // export to raster
    //A4 size at 300 DPI - 2480 x 3508   
    rasterizationOptions.PageHeight = 3508;
    rasterizationOptions.PageWidth = 2480;

    PngOptions pngOptions = new PngOptions
    {
        VectorRasterizationOptions = rasterizationOptions
    };
    cadImage.Save(outPath.Replace("pdf", "png"), pngOptions);

}
        }
private static void DefineUnitSystem(UnitType unitType, out bool isMetric, out double coefficient)
        {
isMetric = false;
coefficient = 1.0;

switch (unitType)
{
    case UnitType.Parsec:
        coefficient = 3.0857 * 10000000000000000.0;
        isMetric = true;
        break;
    case UnitType.LightYear:
        coefficient = 9.4607 * 1000000000000000.0;
        isMetric = true;
        break;
    case UnitType.AstronomicalUnit:
        coefficient = 1.4960 * 100000000000.0;
        isMetric = true;
        break;
    case UnitType.Gigameter:
        coefficient = 1000000000.0;
        isMetric = true;
        break;
    case UnitType.Kilometer:
        coefficient = 1000.0;
        isMetric = true;
        break;
    case UnitType.Decameter:
        isMetric = true;
        coefficient = 10.0;
        break;
    case UnitType.Hectometer:
        isMetric = true;
        coefficient = 100.0;
        break;
    case UnitType.Meter:
        isMetric = true;
        coefficient = 1.0;
        break;
    case UnitType.Centimenter:
        isMetric = true;
        coefficient = 0.01;
        break;
    case UnitType.Decimeter:
        isMetric = true;
        coefficient = 0.1;
        break;
    case UnitType.Millimeter:
        isMetric = true;
        coefficient = 0.001;
        break;
    case UnitType.Micrometer:
        isMetric = true;
        coefficient = 0.000001;
        break;
    case UnitType.Nanometer:
        isMetric = true;
        coefficient = 0.000000001;
        break;
    case UnitType.Angstrom:
        isMetric = true;
        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;
}
        }

Esportazione di DWG in PDF/A e PDF/E

Questo approccio funziona come segue:

1. Carica un file DWG utilizzando il metodo factory Aspose.CAD.Image.Load.
2. Crea un’istanza della classe CadRasterizationOptions.
3. Crea un’istanza della classe PdfOptions e imposta la sua proprietà VectorRasterizationOptions.
4. Imposta la proprietà di conformità PDF e salvala.
5. Esporta l’immagine in PDF utilizzando il metodo Image.Save().

Il campione di codice qui sotto mostra come convertire un file DWG in PDF/A e PDF/E.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "Bottom_plate.dwg";

Aspose.CAD.Image cadImage = 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.BackgroundColor = Aspose.CAD.Color.White;
rasterizationOptions.PageWidth = 1600;
rasterizationOptions.PageHeight = 1600;


// Create an instance of PdfOptions
PdfOptions pdfOptions = new Aspose.CAD.ImageOptions.PdfOptions
{
VectorRasterizationOptions = rasterizationOptions
};

 pdfOptions.CorePdfOptions = new PdfDocumentOptions();

 pdfOptions.CorePdfOptions.Compliance = PdfCompliance.PdfA1a;
 cadImage.Save(MyDir + "PDFA1_A.pdf", pdfOptions);

 pdfOptions.CorePdfOptions.Compliance = PdfCompliance.PdfA1b;
 cadImage.Save(MyDir + "PDFA1_B.pdf", pdfOptions);

Supporto per linee nascoste arrotondate durante l’esportazione di DWG/DXF in BMP e PDF

Questo approccio funziona come segue:

1. Carica un file DWG utilizzando il metodo factory Aspose.CAD.Image.Load.
2. Crea un’istanza della classe CadRasterizationOptions e imposta l’altezza e la larghezza della pagina risultante.
3. Crea un’istanza della classe PdfOptions e imposta la sua proprietà VectorRasterizationOptions.
4. Esporta l’immagine in PDF utilizzando il metodo Image.Save().

Il campione di codice qui sotto mostra come implementare questa funzionalità.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "Bottom_plate.dwg";
string outPath = MyDir + "Bottom_plate.pdf";
using (CadImage cadImage = (CadImage)Image.Load(sourceFilePath))
        {
CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
rasterizationOptions.PageHeight = cadImage.Height;
rasterizationOptions.PageWidth = cadImage.Width;
rasterizationOptions.Layers = new string[] { "Print", "L1_RegMark", "L2_RegMark" };
           


PdfOptions pdfOptions = new PdfOptions();
rasterizationOptions.Layouts = new string[] { "Model" };
pdfOptions.VectorRasterizationOptions = rasterizationOptions;

cadImage.Save(outPath, pdfOptions);
}

Console.WriteLine("\nThe DWG file exported successfully to PDF.\nFile saved at " + MyDir);
        }

Supporto per impostare l’area di stampa per l’immagine DWG nel PDF esportato

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e convertirli in PDF. Questo argomento spiega l’uso dell’API Aspose.CAD per ottenere il supporto per impostare un’area di stampa per l’immagine DWG nel PDF esportato.

Il campione di codice qui sotto mostra come implementare questa funzionalità.

// 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);                
}

Supporto per la lettura dei metadati XREF per il file DWG

1. Carica un file DWG utilizzando il metodo factory Aspose.CAD.Image.Load.
2. Traversare ogni entità immagine.
3. Se un’entità è CadUnderlay, quindi entità XREF con metadati.

Il campione di codice qui sotto mostra come ottenere questa funzionalità.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "Bottom_plate.dwg";
using (CadImage image = (CadImage)Image.Load(sourceFilePath))
{
    foreach (CadBaseEntity entity in image.Entities)
    {
        if (entity is CadUnderlay)
        {
            //XREF entity with metadata
            Cad3DPoint insertionPoint = ((CadUnderlay)entity).InsertionPoint;
            string path = ((CadUnderlay)entity).UnderlayPath;
        }
    }
}

La proprietà CadRasterizationOptions.Layouts è di tipo array di stringhe, quindi puoi specificare più layout contemporaneamente per la possibile conversione in formato PDF. Quando specifichi più layout per la proprietà CadRasterizationOptions.Layouts, il PDF risultante avrà più pagine, dove ogni pagina rappresenta un layout AutoCAD individuale.

Elenca tutti i Layout

Puoi elencare tutti i layout presenti in un disegno AutoCAD utilizzando il seguente frammento di codice.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_ConvertingCAD();
string sourceFilePath = MyDir + "conic_pyramid.dxf";
using (Aspose.CAD.Image image = Aspose.CAD.Image.Load(sourceFilePath))
{
    Aspose.CAD.FileFormats.Cad.CadImage cadImage = (Aspose.CAD.FileFormats.Cad.CadImage)image;

    Aspose.CAD.FileFormats.Cad.CadLayoutDictionary layouts = cadImage.Layouts;
    foreach (Aspose.CAD.FileFormats.Cad.CadObjects.CadLayout layout in layouts.Values)
    {
        Console.WriteLine("Layout " + layout.LayoutName);
    }
}

Accesso ai Flag di sottostrato per il formato DWG

Aspose.CAD per .NET ha implementato i flag di sottostrato per il formato DWG e consente agli sviluppatori di accedervi. Di seguito è riportata la semplice dimostrazione del codice.

            // Input file name and path
            string fileName = "BlockRefDgn.dwg";

            // Load an existing DWG file and convert it into CadImage 
            using (Aspose.CAD.FileFormats.Cad.CadImage image = (Aspose.CAD.FileFormats.Cad.CadImage)Image.Load(fileName))
            {
                // Go through each entity inside the DWG file
                foreach (Aspose.CAD.FileFormats.Cad.CadObjects.CadBaseEntity entity in image.Entities)
                {
                    // Check if entity is of CadDgnUnderlay type
                    if (entity is Aspose.CAD.FileFormats.Cad.CadObjects.CadDgnUnderlay)
                    {
                        // Access different underlay flags 
                        Aspose.CAD.FileFormats.Cad.CadObjects.CadUnderlay underlay = entity as Aspose.CAD.FileFormats.Cad.CadObjects.CadUnderlay;
                        Console.WriteLine(underlay.UnderlayPath);
                        Console.WriteLine(underlay.UnderlayName);
                        Console.WriteLine(underlay.InsertionPoint.X);
                        Console.WriteLine(underlay.InsertionPoint.Y);
                        Console.WriteLine(underlay.RotationAngle);
                        Console.WriteLine(underlay.ScaleX);
                        Console.WriteLine(underlay.ScaleY);
                        Console.WriteLine(underlay.ScaleZ);
                        Console.WriteLine((underlay.Flags & Aspose.CAD.FileFormats.Cad.CadObjects.UnderlayFlags.UnderlayIsOn) == Aspose.CAD.FileFormats.Cad.CadObjects.UnderlayFlags.UnderlayIsOn);
                        Console.WriteLine((underlay.Flags & Aspose.CAD.FileFormats.Cad.CadObjects.UnderlayFlags.ClippingIsOn) == Aspose.CAD.FileFormats.Cad.CadObjects.UnderlayFlags.ClippingIsOn);
                        Console.WriteLine((underlay.Flags & Aspose.CAD.FileFormats.Cad.CadObjects.UnderlayFlags.Monochrome) != Aspose.CAD.FileFormats.Cad.CadObjects.UnderlayFlags.Monochrome);
                        break;
                    }
                }
            }

Supporto per Entità DWG

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e supportare diverse entità da utilizzare.

Supporto per l’Entità MLeader

Un DWG è un file binario che contiene dati di immagine vettoriale e metadati. Ci sono diverse entità in un file DWG. La seguente sezione descrive un esempio di utilizzo dell’entità MLeader all’interno del file DWG.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string file = MyDir + "sample.dwg";
using (Image image = Image.Load(file))
{
    // Test
    FileFormats.Cad.CadImage cadImage = (FileFormats.Cad.CadImage)image;

    Assert.AreNotEqual(cadImage.Entities.Length, 0);
    CadMLeader cadMLeader = (CadMLeader)cadImage.Entities[0];

    Assert.AreEqual(cadMLeader.StyleDescription, "Standard");
    Assert.AreEqual(cadMLeader.LeaderStyleId, "12E");
    Assert.AreEqual(cadMLeader.ArrowHeadId1, "639");
    Assert.AreEqual(cadMLeader.LeaderLineTypeID, "14");

    CadMLeaderContextData context = cadMLeader.ContextData;

    Assert.AreEqual(context.ArrowHeadSize, 30.0, 0.1);
    Assert.AreEqual(context.BasePoint.X, 481, 1);
    Assert.AreEqual(context.ContentScale, 1.0, 0.01);
    Assert.AreEqual(context.DefaultText.Value, "This is multileader with huge text\\P{\\H1.5x;6666666666666666666666666666\\P}bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
    Assert.AreEqual(context.HasMText, true);

    CadMLeaderNode mleaderNode = context.LeaderNode;

    Assert.AreEqual(mleaderNode.LastLeaderLinePoint.X, 473, 1);
    CadMLeaderLine leaderLine = mleaderNode.LeaderLine;

    Assert.AreEqual(leaderLine.BreakEndPoint, null);
    Assert.AreEqual(leaderLine.BreakPointIndex.Value, 0);
    Assert.AreEqual(leaderLine.BreakStartPoint, null);
    Assert.AreEqual(leaderLine.LeaderLineIndex.Value, 0);
    Assert.AreEqual(leaderLine.LeaderPoints.Count, 4);

    Assert.AreEqual(mleaderNode.BranchIndex, 0);
    Assert.AreEqual(mleaderNode.DogLegLength, 8.0, 0.1);

    Assert.AreEqual(context.HasMText, true);
    Assert.AreEqual(context.TextAttachmentType.Value, 1);
    Assert.AreEqual(context.TextBackgroundColor.Value, 18);
    Assert.AreEqual(context.TextHeight, 20.0, 0.1);
    Assert.AreEqual(context.TextStyleID.Value, "11");
    Assert.AreEqual(context.TextRotation.Value, 0.0, 0.01);

    Assert.AreEqual(cadMLeader.ArrowHeadId1, "639");
    Assert.AreEqual(cadMLeader.LeaderType, 1);
    Assert.AreEqual(cadMLeader.BlockContentColor, 0);
    Assert.AreEqual(cadMLeader.LeaderLineColor, 0);
    Assert.AreEqual(cadMLeader.TextHeight, 1.0, 0.01);
}

Supporto per l’Esportazione di un’Entità DWG in Immagine

Un DWG è un file binario che contiene dati di immagine vettoriale e metadati. Ci sono diverse entità in un file DWG. La seguente sezione descrive un esempio di esportazione di una particolare entità DWG in un’immagine.

string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "visualization_-_conference_room.dwg";
var cadImage = (CadImage)Aspose.CAD.Image.Load(sourceFilePath);

CadBaseEntity[] entities = cadImage.Entities;
List<CadBaseEntity> filteredEntities = new List<CadBaseEntity>();

foreach (CadBaseEntity baseEntity in entities)
{
    // selection or filtration of entities
    if (baseEntity.TypeName == CadEntityTypeName.TEXT)
    {
        filteredEntities.Add(baseEntity);
    }
    }

cadImage.Entities = filteredEntities.ToArray();

// 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;

// Set Auto Layout Scaling
rasterizationOptions.AutomaticLayoutsScaling = true;

// Create an instance of PdfOptions
Aspose.CAD.ImageOptions.PdfOptions pdfOptions = new Aspose.CAD.ImageOptions.PdfOptions();

// Set the VectorRasterizationOptions property
pdfOptions.VectorRasterizationOptions = rasterizationOptions;

string outFile = MyDir + "result_out_generated.pdf";

// Export the CAD to PDF
cadImage.Save(outFile, pdfOptions);

Supporto per Aggiungere Testo in DWG

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e supportare diverse entità da utilizzare. Un DWG è un file binario che contiene dati di immagine vettoriale e metadati. Ci sono diverse entità in un file DWG. La seguente sezione descrive come possiamo aggiungere testo all’interno del file DWG.

string MyDir = RunExamples.GetDataDir_DWGDrawings();
string dwgPathToFile = MyDir + "SimpleEntites.dwg";
using (Image image = Image.Load(dwgPathToFile))
{
    CadText cadText = new CadText();
    cadText.StyleType = "Standard";
    cadText.DefaultValue = "Some custom text";
    cadText.ColorId = 256;
    cadText.LayerName = "0";
    cadText.FirstAlignment.X = 47.90;
    cadText.FirstAlignment.Y = 5.56;
    cadText.TextHeight = 0.8;
    cadText.ScaleX = 0.0;
    CadImage cadImage = (CadImage)image;
    cadImage.BlockEntities["*Model_Space"].AddEntity(cadText);

    PdfOptions pdfOptions = new PdfOptions();
    CadRasterizationOptions cadRasterizationOptions = new CadRasterizationOptions();
    pdfOptions.VectorRasterizationOptions = cadRasterizationOptions;
    cadRasterizationOptions.DrawType = CadDrawTypeMode.UseObjectColor;
    
    cadRasterizationOptions.PageHeight = 1600;
    cadRasterizationOptions.PageWidth = 1600;
    cadRasterizationOptions.Layouts = new string[] { "Model" };
    image.Save(MyDir+"SimpleEntites_generated.pdf", pdfOptions);
}
        

Supporto per Importare Immagini nel File DWG

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e supportare diverse entità da utilizzare. Un DWG è un file binario che contiene dati di immagine vettoriale e metadati. Ci sono diverse entità in un file DWG. La seguente sezione descrive come possiamo importare immagini all’interno del file DWG.

// For complete examples and data files, please go to https://github.com/aspose-cad/Aspose.CAD-for-.NET
string dwgPathToFile = MyDir + "Drawing11.dwg";

CadImage cadImage1 = (CadImage)Image.Load(dwgPathToFile);

CadRasterImageDef cadRasterImageDef = new CadRasterImageDef("road-sign-custom.png", 640, 562);
cadRasterImageDef.ObjectHandle = "A3B4";

Cad3DPoint insertionPoint = new Cad3DPoint(26.77, 22.35);
Cad3DPoint uVector = new Cad3DPoint(0.0061565450840500831, 0);
Cad3DPoint vVector = new Cad3DPoint(0, 0.0061565450840500822);

CadRasterImage cadRasterImage = new CadRasterImage(cadRasterImageDef, insertionPoint, uVector, vVector);
cadRasterImage.ImageDefReference = "A3B4";
cadRasterImage.DisplayFlags = 7;
cadRasterImage.ClippingState = 0;
cadRasterImage.ClipBoundaryVertexList.Add(new Cad2DPoint(-0.5, 0.5));
cadRasterImage.ClipBoundaryVertexList.Add(new Cad2DPoint(639.5, 561.5));

CadImage cadImage = (CadImage)cadImage1;
cadImage.BlockEntities["*Model_Space"].AddEntity(cadRasterImage);

List<CadBaseObject> list = new List<CadBaseObject>(cadImage.Objects);
list.Add(cadRasterImageDef);
cadImage.Objects = list.ToArray();


PdfOptions pdfOptions = new PdfOptions();
CadRasterizationOptions cadRasterizationOptions = new CadRasterizationOptions();
pdfOptions.VectorRasterizationOptions = cadRasterizationOptions;
cadRasterizationOptions.DrawType = CadDrawTypeMode.UseObjectColor;

cadRasterizationOptions.PageHeight = 1600;
cadRasterizationOptions.PageWidth = 1600;
cadRasterizationOptions.Layouts = new string[] { "Model" };
cadImage1.Save(MyDir + "export2.pdf", pdfOptions);

Supporto per Mesh in DWG

Aspose.CAD per .NET API può ora accedere alle entità che supportano mesh, che includono i tipi CadPolyFaceMesh e CadPolygonMesh. Il seguente esempio descrive come possiamo accedere ai tipi di mesh.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();
string sourceFilePath = MyDir + "meshes.dwg";

// Load an existing DWG file as CadImage.
using (CadImage cadImage = (CadImage)Image.Load(sourceFilePath))
{
    foreach (var entity in cadImage.Entities)
    {
        if (entity is CadPolyFaceMesh)
        {
            CadPolyFaceMesh asFaceMesh = (CadPolyFaceMesh)entity;

            if (asFaceMesh != null)
            {
                Console.WriteLine("Vetexes count: " + asFaceMesh.MeshMVertexCount);
            }
        }

        else if (entity is CadPolygonMesh)
        {
            CadPolygonMesh asPolygonMesh = (CadPolygonMesh)entity;

            if (asPolygonMesh != null)
            {
                Console.WriteLine("Vetexes count: " + asPolygonMesh.MeshMVertexCount);
            }
        }
    }
}

Convertire Disegni DWG in DXF

Aspose.CAD fornisce la funzionalità per caricare file DWG di AutoCAD ed esportarli in formato DXF. L’approccio da DWG a DXF funziona come segue:

1. Carica il file del disegno DWG utilizzando il metodo factory Image.Load.
2. Esporta il disegno DWG in DXF utilizzando il metodo Image.Save().

Il campione di codice qui sotto mostra come convertire un file DWG in un formato DXF.

string MyDir = RunExamples.GetDataDir_DWGDrawings();
string inputFile = MyDir + "Line.dwg";
string outFile = MyDir + "Line_19.2.dxf"; 
using (var cadImage = (CadImage)Image.Load(inputFile))
{
    cadImage.Save(outFile);
}

Convertire Disegni DWG in SVG

Aspose.CAD per .NET API può caricare disegni AutoCAD in formato DWG e convertirli in SVG. Questo argomento spiega l’uso dell’API Aspose.CAD per ottenere la conversione da DWG a formato SVG attraverso semplici passaggi definiti di seguito.

1. Carica il file DWG in un’istanza di Image.
2. Crea un oggetto della classe SvgOptions e imposta le proprietà richieste.
3. Esporta il disegno DWG in SVG utilizzando il metodo Image.Save().

Il campione di codice qui sotto mostra come convertire un file DWG in formato SVG.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();

using (Image image = Image.Load(MyDir + "sample.dwg"))
{
    var options = new SvgOptions();
    options.ColorType = Aspose.CAD.ImageOptions.SvgOptionsParameters.SvgColorMode.Grayscale;
    options.TextAsShapes = true;
    image.Save(MyDir + "sample.svg");
}

Caricare File DWG di Grandi Dimensioni

Aspose.CAD per .NET fornisce la possibilità di aprire file DWG molto grandi utilizzando la classe Image. Ora puoi aprire facilmente file di grandi dimensioni con l’aiuto del codice di esempio fornito di seguito.

// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_DWGDrawings();

string filePathDWG = MyDir + "TestBigFile.dwg";
string filePathFinish = MyDir+ "TestBigFile.dwg.pdf";
Stopwatch stopWatch = new Stopwatch();


try
{
    stopWatch.Start();
    using (CadImage cadImage = (CadImage)Image.Load(filePathDWG))
    {
        stopWatch.Stop();


        // Get the elapsed time as a TimeSpan value. 
        TimeSpan ts = stopWatch.Elapsed;

        // Format and display the TimeSpan value. 
        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
            ts.Hours, ts.Minutes, ts.Seconds,
            ts.Milliseconds / 10);
        Console.WriteLine("RunTime for loading " + elapsedTime);

        CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
        rasterizationOptions.PageWidth = 1600;
        rasterizationOptions.PageHeight = 1600;
        PdfOptions pdfOptions = new PdfOptions();
        pdfOptions.VectorRasterizationOptions = rasterizationOptions;

        stopWatch = new Stopwatch();
        stopWatch.Start();
        cadImage.Save(filePathFinish, pdfOptions);
        stopWatch.Stop();

        // Get the elapsed time as a TimeSpan value. 
        ts = stopWatch.Elapsed;

        // Format and display the TimeSpan value. 
        elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
           ts.Hours, ts.Minutes, ts.Seconds,
           ts.Milliseconds / 10);
        Console.WriteLine("RunTime for converting " + elapsedTime);
    }
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
    
}