Rysunki DWG

Eksportowanie rysunków DWG do PDF

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i konwertować je na PDF. Niniejszy temat wyjaśnia użycie API Aspose.CAD, aby osiągnąć konwersję DWG na PDF poprzez proste kroki, jak określono poniżej.

API obsługuje następujące wersje DWG AutoCAD:

• Wersja 16.0 wydanie 18 DWG 2004
• Wersja 16.1 DWG 2005
• Wersja 18.0 DWG 2010
• Wersja 19.0 DWG 2013

Format pliku DWG

DWG to plik binarny, który zawiera dane wektorowego obrazu oraz metadane. Dane obrazu wektorowego dostarczają aplikacji CAD instrukcje, jak wyświetlać DWG; metadane mogą zawierać różnorodne informacje o pliku, w tym dane specyficzne dla lokalizacji, a także dane klientów. Otwarte specyfikacje formatu pliku DWG można znaleźć w tym pliku PDF

Konwersja plików DWG do PDF

Aby skonwertować DWG na PDF, wymagane są następujące proste kroki:

1. Załaduj plik DWG do instancji Image.
2. Utwórz obiekt klasy CadRasterizationOptions i ustaw właściwości PageHeight & PageWidth.
3. Utwórz obiekt klasy PdfOptions i ustaw właściwość VectorRasterizationOptions.
4. Wywołaj Image.Save, przekazując obiekt PdfOptions jako drugi parametr.

Przykład kodu poniżej pokazuje, jak eksportować rysunki DWG do 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);                
}

Tworzenie pojedynczego PDF z różnymi rozmiarami układów

Aspose.CAD dla .NET pozwala na konwersję pliku DWG do pojedynczego PDF z różnymi rozmiarami układów. Ten proces działa w następujący sposób:

1. Załaduj plik DWG za pomocą fabrycznej metody Aspose.CAD.Image.Load.
2. Utwórz instancję klasy CadRasterizationOptions i ustaw wysokość i szerokość wynikowej strony.
3. Dodaj wymagane LayoutPageSizes dla obiektu CadRasterizationOptions.
4. Utwórz instancję klasy PdfOptions i ustaw jej właściwość VectorRasterizationOptions.
5. Eksportuj obraz do PDF używając metody Image.Save().

Przykład kodu poniżej pokazuje, jak utworzyć pojedyncze PDF z różnymi układami.

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

            }

Obsługiwane prymitywy AutoCAD

Poniższe prymitywy AutoCAD są obsługiwane.

• TEXT
• MTEXT
• ATTDEF
• ATTRIB
• ARC
• ELLIPSE
• HATCH
• LEADER
• POINT
• VERTEX 2D
• VERTEX 3D
• POLYLINE 2D
• LWPOLYLINE
• RAY
• CIRCLE
• DIMENSION ORDINATE
• DIMENSION LINEAR
• DIMENSION ALIGNED
• DIMENSION ANG 3Pt
• DIMENSION ANG 2Ln
• DIMENSION RADIUS
• DIMENSION DIAMETER
• SHAPE
• SOLID
• SPLINE
• MLINE
• LINE
• XLINE
• STYLE
• DIMSTYLE
• LTYPE
• MLINESTYLE
• LAYER
• VIEWPORT
• LAYOUT

Eksportowanie konkretnego układu DWG do PDF

Ten proces działa w następujący sposób:

1. Załaduj plik DWG za pomocą fabrycznej metody Aspose.CAD.Image.Load.
2. Utwórz instancję klasy CadRasterizationOptions i ustaw wysokość i szerokość wynikowej strony.
3. Ustaw właściwość Layouts dla obiektu CadRasterizationOptions.
4. Utwórz instancję klasy PdfOptions i ustaw jej właściwość VectorRasterizationOptions.
5. Eksportuj obraz do PDF używając metody Image.Save().

Przykład kodu poniżej pokazuje, jak skonwertować konkretny układ DWG do 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);                
}

Renderowanie dokumentu DWG przez określenie współrzędnych

Aspose.CAD dla .NET API teraz oferuje funkcję renderowania dokumentów DWG poprzez podanie współrzędnych szerokości i wysokości dokumentu.

Przykład kodu poniżej pokazuje, jak renderować dokument 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);                
}

Eksportowanie DWG do Raster lub PDF przy użyciu stałego rozmiaru

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i konwertować je na PDF lub Raster przy użyciu stałego rozmiaru.

Przykład kodu poniżej pokazuje, jak wdrożyć tę funkcję.

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

Eksportowanie DWG do PDF/A i PDF/E

Ten proces działa w następujący sposób:

1. Załaduj plik DWG za pomocą fabrycznej metody Aspose.CAD.Image.Load.
2. Utwórz instancję klasy CadRasterizationOptions.
3. Utwórz instancję klasy PdfOptions i ustaw jej właściwość VectorRasterizationOptions.
4. Ustaw właściwość zgodności PDF i zapisz ją.
5. Eksportuj obraz do PDF używając metody Image.Save().

Przykład kodu poniżej pokazuje, jak skonwertować plik DWG do PDF/A i 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);

Wsparcie dla zaokrąglonych linii ukrytych podczas eksportowania DWG/DXF do BMP i PDF

Ten proces działa w następujący sposób:

1. Załaduj plik DWG za pomocą fabrycznej metody Aspose.CAD.Image.Load.
2. Utwórz instancję klasy CadRasterizationOptions i ustaw wysokość i szerokość wynikowej strony.
3. Utwórz instancję klasy PdfOptions i ustaw jej właściwość VectorRasterizationOptions.
4. Eksportuj obraz do PDF używając metody Image.Save().

Przykład kodu poniżej pokazuje, jak wdrożyć tę funkcję.

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

Wsparcie dla ustawienia obszaru drukowania dla obrazu DWG w wyeksportowanym PDF

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i konwertować je na PDF. Niniejszy temat wyjaśnia użycie API Aspose.CAD, aby osiągnąć wsparcie dla ustawienia obszaru drukowania dla obrazu DWG w wyeksportowanym PDF.

Przykład kodu poniżej pokazuje, jak wdrożyć tę funkcję.

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

Wsparcie dla odczytu metadanych XREF dla pliku DWG

1. Załaduj plik DWG za pomocą fabrycznej metody Aspose.CAD.Image.Load.
2. Przeszukaj każdy obiekt obrazu.
3. Jeśli obiekt to CadUnderlay, wtedy XREF obiekt z metadanymi.

Przykład kodu poniżej pokazuje, jak osiągnąć tę funkcję.

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

Właściwość CadRasterizationOptions.Layouts jest typu tablica ciągów, więc możesz określić więcej niż jeden układ jednocześnie do możliwej konwersji do formatu PDF. Podczas określania wielu układów dla właściwości CadRasterizationOptions.Layouts, uzyskany PDF będzie miał wiele stron, gdzie każda strona reprezentuje indywidualny układ AutoCAD.

Wyświetl wszystkie układy

Możesz wyświetlić wszystkie układy obecne w rysunku AutoCAD używając poniższego fragmentu kodu.

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

Dostęp do flag podkładu dla formatu DWG

Aspose.CAD dla .NET wdrożyło flagi podkładu dla formatu DWG i pozwala programistom na dostęp do nich. Poniżej znajduje się prosta demonstracja kodu.

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

Wsparcie dla jednostek DWG

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i wspierać różne jednostki do pracy.

Wsparcie dla jednostki MLeader

DWG to plik binarny, który zawiera dane wektorowego obrazu i metadane. W pliku DWG znajdują się różne jednostki. Poniższa sekcja opisuje przykład pracy z jednostką MLeader wewnątrz pliku 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);
}

Wsparcie dla eksportowania jednostki DWG do obrazu

DWG to plik binarny, który zawiera dane wektorowego obrazu i metadane. W pliku DWG znajdują się różne jednostki. Poniższa sekcja opisuje przykład eksportowania konkretnej jednostki DWG do obrazu.

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

Wsparcie dla dodawania tekstu w DWG

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i wspierać różne jednostki do pracy. DWG to plik binarny, który zawiera dane wektorowego obrazu i metadane. W pliku DWG znajdują się różne jednostki. Poniższa sekcja opisuje, jak możemy dodać tekst wewnątrz pliku 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);
}
        

Wsparcie dla importowania obrazu do pliku DWG

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i wspierać różne jednostki do pracy. DWG to plik binarny, który zawiera dane wektorowego obrazu i metadane. W pliku DWG znajdują się różne jednostki. Poniższa sekcja opisuje, jak możemy importować obrazy wewnątrz pliku 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);

Wsparcie dla siatki w DWG

Aspose.CAD dla .NET API ma teraz dostęp do jednostek obsługujących siatkę, w tym typy CadPolyFaceMesh i CadPolygonMesh. Poniższy przykład opisuje, jak możemy uzyskać dostęp do typów siatki.

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

Konwersja rysunków DWG do DXF

Aspose.CAD oferuje funkcję załadowania pliku DWG AutoCAD i eksportowania go do formatu DXF. Proces konwersji DWG do DXF działa w następujący sposób:

1. Załaduj plik rysunku DWG za pomocą fabrycznej metody Image.Load.
2. Eksportuj rysunek DWG do DXF używając metody Image.Save().

Przykład kodu poniżej pokazuje, jak skonwertować plik DWG do formatu 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);
}

Konwersja rysunków DWG do SVG

Aspose.CAD dla .NET API może ładować rysunki AutoCAD w formacie DWG i konwertować je na SVG. Ten temat wyjaśnia użycie API Aspose.CAD do osiągnięcia konwersji DWG do formatu SVG poprzez proste kroki, jak określono poniżej.

1. Załaduj plik DWG do instancji Image.
2. Utwórz obiekt klasy SvgOptions i ustaw wymagane właściwości.
3. Eksportuj rysunek DWG do SVG używając metody Image.Save().

Przykład kodu poniżej pokazuje, jak skonwertować plik DWG do formatu 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");
}

Ładowanie dużego pliku DWG

Aspose.CAD dla .NET zapewnia możliwość otwierania bardzo dużych plików DWG przy użyciu klasy Image. Teraz możesz łatwo otworzyć duże pliki za pomocą poniższego przykładu kodu.

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