Desenhos DWG

Exportando Desenhos DWG para PDF

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e convertê-los para PDF. Este tópico explica o uso da API Aspose.CAD para alcançar a conversão de DWG para o formato PDF através de passos simples, conforme definido a seguir.

A API suporta as seguintes revisões do DWG do AutoCAD:

• versão 16.0, lançamento 18, DWG 2004
• versão 16.1, DWG 2005
• versão 18.0, DWG 2010
• versão 19.0, DWG 2013

Formato de Arquivo DWG

Um DWG é um arquivo binário que contém dados de imagem vetorial e metadados. Os dados de imagem vetorial fornecem instruções para a aplicação CAD sobre como exibir o DWG; os metadados podem conter uma variedade de informações sobre o arquivo, incluindo dados específicos de localização e também dados do cliente. Especificações Abertas para o formato de arquivo DWG podem ser encontradas neste PDF

Converter Arquivos DWG para PDF

Os seguintes passos simples são necessários para converter DWG para PDF.

1. Carregar o arquivo DWG em uma instância de Image.
2. Criar um objeto da classe CadRasterizationOptions e definir as propriedades PageHeight e PageWidth.
3. Criar um objeto da classe PdfOptions e definir a propriedade VectorRasterizationOptions.
4. Chamar Image.Save enquanto passa um objeto de PdfOptions como o segundo parâmetro.

O exemplo de código abaixo mostra como exportar desenhos DWG para 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);                
}

Criar um PDF Único com Tamanhos de Layout Diferentes

Aspose.CAD para .NET permite que você converta um arquivo DWG em um único PDF com tamanhos de layout diferentes. Esta abordagem funciona da seguinte forma:

1. Carregar um arquivo DWG usando o método de fábrica Aspose.CAD.Image.Load.
2. Criar uma instância da classe CadRasterizationOptions e definir a altura e largura da página resultante.
3. Adicionar os LayoutPageSizes necessários para o objeto CadRasterizationOptions.
4. Criar uma instância da classe PdfOptions e definir sua propriedade VectorRasterizationOptions.
5. Exportar a imagem para PDF usando o método Image.Save().

O exemplo de código abaixo mostra como criar um único PDF com layouts diferentes.

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

            }

Primitivas Suportadas do AutoCAD

As seguintes primitivas do AutoCAD são suportadas.

• TEXTO
• MTEXTO
• ATTDEF
• ATRIB
• ARCO
• ELLIPSE
• HATCH
• LIDER
• PONTO
• VÉRTICE 2D
• VÉRTICE 3D
• POLILINHA 2D
• LWPOLYLINE
• RAI
• CÍRCULO
• DIMENSÃO ORDINADA
• DIMENSÃO LINEAR
• DIMENSÃO ALINHADA
• DIMENSÃO ÂNGULO 3Pt
• DIMENSÃO ÂNGULO 2Ln
• DIMENSÃO RAIO
• DIMENSÃO DIÂMETRO
• FORMA
• SÓLIDO
• SPLINE
• MLINE
• LINHA
• XLINE
• ESTILO
• DIMSTYLE
• LTYPE
• MLINESTYLE
• CAMADA
• VIEWPORT
• LAYOUT

Exportando Layout Específico DWG para PDF

Esta abordagem funciona da seguinte forma:

1. Carregar um arquivo DWG usando o método de fábrica Aspose.CAD.Image.Load.
2. Criar uma instância da classe CadRasterizationOptions e definir a altura e largura da página resultante.
3. Definir a propriedade Layouts para o objeto CadRasterizationOptions.
4. Criar uma instância da classe PdfOptions e definir sua propriedade VectorRasterizationOptions.
5. Exportar a imagem para PDF usando o método Image.Save().

O exemplo de código abaixo mostra como converter um layout específico de DWG para 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);                
}

Renderizar Documento DWG Especificando Coordenadas

Aspose.CAD para .NET API agora fornece um recurso para renderizar documentos DWG fornecendo coordenadas da largura e altura do documento.

O exemplo de código abaixo mostra como renderizar um 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);                
}

Exportando DWG para Raster ou PDF usando Tamanho Fixo

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e convertê-los em PDF ou Raster usando tamanho fixo.

O exemplo de código abaixo mostra como implementar esse recurso.

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

Exportando DWG para PDF/A e PDF/E

Esta abordagem funciona da seguinte forma:

1. Carregar um arquivo DWG usando o método de fábrica Aspose.CAD.Image.Load.
2. Criar uma instância da classe CadRasterizationOptions.
3. Criar uma instância da classe PdfOptions e definir sua propriedade VectorRasterizationOptions.
4. Definir a propriedade de conformidade PDF e salvá-la.
5. Exportar a imagem para PDF usando o método Image.Save().

O exemplo de código abaixo mostra como converter um arquivo DWG para 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);

Suporte para Linhas Ocultas Arredondadas ao Exportar DWG/DXF para BMP e PDF

Esta abordagem funciona da seguinte forma:

1. Carregar um arquivo DWG usando o método de fábrica Aspose.CAD.Image.Load.
2. Criar uma instância da classe CadRasterizationOptions e definir a altura e largura da página resultante.
3. Criar uma instância da classe PdfOptions e definir sua propriedade VectorRasterizationOptions.
4. Exportar a imagem para PDF usando o método Image.Save().

O exemplo de código abaixo mostra como implementar esse recurso.

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

Suporte para Definir Área de Impressão para Imagem DWG no PDF Exportado

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e convertê-los em PDF. Este tópico explica o uso da API Aspose.CAD para alcançar o suporte para definir uma área de impressão para a imagem DWG no PDF exportado.

O exemplo de código abaixo mostra como implementar esse recurso.

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

Suporte para Ler Metadados XREF para Arquivo DWG

1. Carregar um arquivo DWG usando o método de fábrica Aspose.CAD.Image.Load.
2. Percorrer cada entidade de imagem.
3. Se uma entidade for CadUnderlay, então a entidade XREF com metadados.

O exemplo de código abaixo mostra como alcançar esse recurso.

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

A propriedade CadRasterizationOptions.Layouts é do tipo array de string, para que você possa especificar mais de um layout ao mesmo tempo para possível conversão ao formato PDF. Ao especificar múltiplos layouts para a propriedade CadRasterizationOptions.Layouts, o PDF resultante terá várias páginas, onde cada página representa um layout individual do AutoCAD.

Listar Todos os Layouts

Você pode listar todos os layouts presentes em um desenho AutoCAD usando o seguinte trecho de código.

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

Acessando Sinalizadores de Subcamada para Formato DWG

Aspose.CAD para .NET implementou os sinalizadores de subcamada para o formato DWG e permite que os desenvolvedores os acessem. A seguir está a demonstração simples do código.

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

Suporte para Entidades DWG

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e suportar diferentes entidades para trabalhar.

Suporte para Entidade MLeader

Um DWG é um arquivo binário que contém dados de imagem vetorial e metadados. Existem diferentes entidades em um arquivo DWG. A seção a seguir descreve um exemplo de trabalho com a entidade MLeader dentro do arquivo 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);
}

Suporte para Exportar Entidade DWG para Imagem

Um DWG é um arquivo binário que contém dados de imagem vetorial e metadados. Existem diferentes entidades em um arquivo DWG. A seção a seguir descreve um exemplo de exportação de uma entidade DWG particular para a imagem.

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

Suporte para Adicionar Texto em DWG

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e suportar diferentes entidades para trabalhar. Um DWG é um arquivo binário que contém dados de imagem vetorial e metadados. Existem diferentes entidades em um arquivo DWG. A seção a seguir descreve como podemos adicionar texto dentro do arquivo 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);
}
        

Suporte para Importar Imagem para Arquivo DWG

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e suportar diferentes entidades para trabalhar. Um DWG é um arquivo binário que contém dados de imagem vetorial e metadados. Existem diferentes entidades em um arquivo DWG. A seção a seguir descreve como podemos importar imagens dentro do arquivo 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);

Suporte para Malha em DWG

Aspose.CAD para .NET API agora pode acessar as entidades que suportam malha, que incluem os tipos CadPolyFaceMesh e CadPolygonMesh. O seguinte exemplo descreve como podemos acessar os tipos de malha.

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

Converter Desenhos DWG para DXF

Aspose.CAD fornece o recurso de carregar um arquivo DWG do AutoCAD e exportá-lo para o formato DXF. A abordagem de conversão de DWG para DXF funciona da seguinte forma:

1. Carregar o arquivo de desenho DWG usando o método de fábrica Image.Load.
2. Exportar o desenho DWG para DXF usando o método Image.Save().

O exemplo de código abaixo mostra como converter um arquivo DWG para o 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);
}

Converter Desenhos DWG para SVG

Aspose.CAD para .NET API pode carregar desenhos do AutoCAD no formato DWG e convertê-los para SVG. Este tópico explica o uso da API Aspose.CAD para alcançar a conversão de DWG para o formato SVG através de passos simples, conforme definido abaixo.

1. Carregar o arquivo DWG em uma instância de Image.
2. Criar um objeto da classe SvgOptions e definir as propriedades requeridas.
3. Exportar o desenho DWG para SVG usando o método Image.Save().

O exemplo de código abaixo mostra como converter um arquivo DWG para o 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");
}

Carregar Arquivo DWG Grande

Aspose.CAD para .NET fornece a facilidade de abrir arquivos DWG muito grandes usando a classe Image. Agora você pode abrir arquivos grandes facilmente com a ajuda do código de amostra abaixo.

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