שרטוטי DWG

ייצוא שרטוטי DWG ל-PDF

Aspose.CAD עבור .NET API יכול לטעון שרטוטי AutoCAD בפורמט DWG ולהמיר אותו ל-PDF. נושא זה מסביר את השימוש ב-Aspose.CAD API כדי להשיג את ההמרה מ-DWG לפורמט PDF באמצעות צעדים פשוטים המוגדרים למעלה.

ה-API תומך בהתפתחויות הבאות של DWG של AutoCAD:

• גרסה 16.0 של DWG 2004 שחרור 18
• גרסה 16.1 של DWG 2005
• גרסה 18.0 של DWG 2010
• גרסה 19.0 של DWG 2013

פורמט קובץ DWG

פורמט DWG הוא קובץ בינארי המכיל נתוני תמונה וקטוריים ומטא-דאטה. נתוני התמונה הווקטוריים מספקים הנחיות ליישום ה-CAD כיצד להציג את ה-DWG; המטא-דאטה יכולה להכיל מגוון של מידע על הקובץ כולל נתוני מיקום ומידע של לקוחות. מפרטים פתוחים עבור פורמט הקובץ DWG יכולים להתמצא ב-PDF הזה

להמיר קובצי DWG ל-PDF

הצעדים הפשוטים הבאים נדרשים כדי להמיר DWG ל-PDF.

1. טען את קובץ ה-DWG לדוגמת של Image.
2. צור אובייקט של הקלאס CadRasterizationOptions ובצע הגדרות עבור תכונות PageHeight ו-PageWidth.
3. צור אובייקט של הקלאס PdfOptions והגדר את תכונת VectorRasterizationOptions.
4. קרא ל-Image.Save כאשר אתה מעביר אובייקט של PdfOptions כפרמטר השני.

דוגמת הקוד למטה מציגה כיצד לייצא שרטוטי DWG ל-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);                
}

יצירת PDF אחד עם גדלים שונים של פריסות

Aspose.CAD עבור .NET מאפשר לך להמיר קובץ DWG ל-PDF אחד עם גדלים שונים של פריסות. גישה זו פועלת כך:

1. טען קובץ DWG באמצעות השיטה הפקטוריאלית Aspose.CAD.Image.Load.
2. צור דוגמת של הקלאס CadRasterizationOptions והגדר את גובה ועובי הדף התוצאיים.
3. הוסף את LayoutPageSizes הנדרשות עבור האובייקט CadRasterizationOptions.
4. צור דוגמת של הקלאס PdfOptions והגדר את תכונת VectorRasterizationOptions.
5. ייצא את התמונה ל-PDF באמצעות השיטה Image.Save().

דוגמת הקוד למטה מציגה כיצד ליצור PDF אחד עם פריסות שונות.

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

            }

פרימיטיבים נתמכים של AutoCAD

הפרימיטיבים הבאים של AutoCAD נתמכים.

• 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

ייצוא פריסת DWG ספציפית ל-PDF

גישה זו פועלת כך:

1. טען קובץ DWG באמצעות השיטה הפקטוריאלית Aspose.CAD.Image.Load.
2. צור דוגמת של הקלאס CadRasterizationOptions והגדר את גובה ועובי הדף התוצאיים.
3. הגדר את תכונת Layouts עבור האובייקט CadRasterizationOptions.
4. צור דוגמת של הקלאס PdfOptions והגדר את תכונת VectorRasterizationOptions.
5. ייצא את התמונה ל-PDF באמצעות השיטה Image.Save().

דוגמת הקוד למטה מציגה כיצד להמיר פריסה ספציפית של DWG ל-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);                
}

להציג מסמך DWG על ידי ציון קואורדינטות

Aspose.CAD עבור .NET API עכשיו מספקת תכונה להציג מסמכי DWG על ידי ספק קואורדינטות של רוחב וגובה המסמך.

דוגמת הקוד למטה מציגה כיצד להציג מסמך 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);                
}

ייצוא DWG לרסטר או PDF בגודל קבוע

Aspose.CAD עבור .NET API יכול לטעון שרטוטי AutoCAD בפורמט DWG, ולהמיר אותו ל-PDF או לרסטר בגודל קבוע.

דוגמת הקוד למטה מציגה כיצד ליישם תכונה זו.

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

ייצוא DWG ל-PDF/A ו-PDF/E

גישה זו פועלת כך:

1. טען קובץ DWG באמצעות השיטה הפקטוריאלית Aspose.CAD.Image.Load.
2. צור דוגמת של הקלאס CadRasterizationOptions.
3. צור דוגמת של הקלאס PdfOptions והגדר את תכונת VectorRasterizationOptions.
4. הגדר את תכונת התאמה של PDF ושמור אותו.
5. ייצא את התמונה ל-PDF באמצעות השיטה Image.Save().

דוגמת הקוד למטה מציגה כיצד להמיר קובץ DWG ל-PDF/A ו-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);

תמיכה בקווים מוסתרים מעוגלים בעת ייצוא DWG/DXF ל-BMP ו-PDF

גישה זו פועלת כך:

1. טען קובץ DWG באמצעות השיטה הפקטוריאלית Aspose.CAD.Image.Load.
2. צור דוגמת של הקלאס CadRasterizationOptions והגדר את גובה ועובי הדף התוצאיים.
3. צור דוגמת של הקלאס PdfOptions והגדר את תכונת VectorRasterizationOptions.
4. ייצא את התמונה ל-PDF באמצעות השיטה Image.Save().

דוגמת הקוד למטה מציגה כיצד ליישם תכונה זו.

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

תמיכה בהגדרת אזור הדפסה עבור תמונת DWG ב-PDF המיוצא

Aspose.CAD עבור .NET API יכול לטעון שרטוטי AutoCAD בפורמט DWG ולהמיר אותם ל-PDF. נושא זה מסביר את השימוש ב-Aspose.CAD API כדי להשיג את התמיכה בהגדרת אזור הדפסה עבור תמונת DWG ב-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);                
}

תמיכה בקריאת מטא-דאטה XREF עבור קובץ DWG

1. טען קובץ DWG באמצעות השיטה הפקטוריאלית Aspose.CAD.Image.Load.
2. עבור דרך כל ישות תמונה.
3. אם ישות היא CadUnderlay אז ישות XREF עם מטא-דאטה.

דוגמת הקוד למטה מציגה כיצד להשיג תכונה זו.

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

התכונה CadRasterizationOptions.Layouts היא מסוג מערך מחרוזות כך שתוכל לציין יותר מפריסה אחת בו זמנית להמרה אפשרית לפורמט PDF. בזמן שאתה מציין מספר פריסות עבור תכונת CadRasterizationOptions.Layouts, ה-PDF התוצאתי יכיל מספר עמודים, כאשר כל עמוד מייצג פריסת AutoCAD בודדת.

רשימת כל הפריסות

תוכל לרשום את כל הפריסות הקיימות בשרטוט AutoCAD באמצעות הקוד הבא.

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

גישה לדגלי ה-underlay עבור פורמט DWG

Aspose.CAD עבור .NET הטמיעה את הדגלים וה-underlay של פורמט DWG ומאפשרת למפתחים לגשת אליהם. להלן הדגמה פשוטה של הקוד.

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

תמיכה בישויות DWG

Aspose.CAD עבור .NET API יכול לטעון שרטוטי AutoCAD בפורמט DWG ותומך בישויות שונות לעבודה עם.

תמיכה בישות MLeader

DWG הוא קובץ בינארי המכיל נתוני תמונה וקטוריים ומטא-דאטה. ישנן ישויות שונות בקובץ DWG. הסעיף הבא מתאר דוגמה לעבודה עם ישות MLeader בתוך קובץ ה-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);
}

תמיכה בייצוא ישות DWG לתמונה

DWG הוא קובץ בינארי המכיל נתוני תמונה וקטוריים ומטא-דאטה. ישנן ישויות שונות בקובץ DWG. הסעיף הבא מתאר דוגמה לייצוא ישות DWG מסוימת לתמונה.

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

תמיכה בהוספת טקסט ב-DWG

Aspose.CAD עבור .NET API יכול לטעון שרטוטי AutoCAD בפורמט DWG ותומך בישויות שונות לעבודה עם. DWG הוא קובץ בינארי המכיל נתוני תמונה וקטוריים ומטא-דאטה. ישנן ישויות שונות בקובץ DWG. הסעיף הבא מתאר כיצד ניתן להוסיף טקסט בתוך קובץ ה-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);
}
        

תמיכה בייבוא תמונה לקובץ DWG

Aspose.CAD עבור .NET API יכול לטעון שרטוטי AutoCAD בפורמט DWG ותומך בישויות שונות לעבודה עם. DWG הוא קובץ בינארי המכיל נתוני תמונה וקטוריים ומטא-דאטה. ישנן ישויות שונות בקובץ DWG. הסעיף הבא מתאר כיצד ניתן לייבא תמונות בתוך קובץ ה-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);

תמיכה ברשת ב-DWG

Aspose.CAD עבור .NET API יכולה עכשיו לגשת לישויות השייכות לרשת אשר כוללות את סוגי CadPolyFaceMesh ו-CadPolygonMesh. הדוגמה הבאה מתארת איך ניתן לגשת לסוגי הרשת.

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

להמיר שרטוטי DWG ל-DXF

Aspose.CAD מספקת את הפיצ’ר לטעון קובץ DWG של AutoCAD ולייצא אותו לפורמט DXF. גישת ההמרה מ-DWG ל-DXF פועלת כך:

1. טען את קובץ שרטוט DWG באמצעות השיטה הפקטוריאלית Image.Load.
2. ייצא את שרטוט ה-DWG ל-DXF באמצעות השיטה Image.Save().

דוגמת הקוד למטה מציגה כיצד להמיר קובץ DWG לפורמט 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);
}

להמיר שרטוטי DWG ל-SVG

Aspose.CAD עבור .NET API יכולה לטעון שרטוטי AutoCAD בפורמט DWG, ולהמיר אותו ל-SVG. נושא זה מסביר את השימוש ב-Aspose.CAD API כדי להשיג את ההמרה מ-DWG לפורמט SVG באמצעות צעדים פשוטים המוגדרים למטה.

1. טען את קובץ ה-DWG לדוגמת של Image.
2. צור אובייקט של הקלאס SvgOptions והגדר את התכונות הנדרשות.
3. ייצא את שרטוט ה-DWG ל-SVG באמצעות השיטה Image.Save().

דוגמת הקוד למטה מציגה כיצד להמיר קובץ DWG לפורמט 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");
}

לטעון קובץ DWG גדול

Aspose.CAD עבור .NET מספקת את האפשרות לפתוח קובצי DWG מאוד גדולים בעזרת הקלאס Image. עכשיו אתה יכול לפתוח קבצים גדולים בקלות עם העזרה של קוד דוגמה המוצג למטה.

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