DWG Zeichnungen

Exportieren von DWG Zeichnungen nach PDF

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG Format laden und in PDF konvertieren. Dieses Thema erklärt die Verwendung der Aspose.CAD API, um die Konvertierung von DWG in PDF-Format durch einfache Schritte zu erreichen, wie im Folgenden definiert.

DWG-Dateiformat

Eine DWG ist eine Binärdatei, die Vektorbilder und Metadaten enthält. Die Vektorbilder geben der CAD-Anwendung Anweisungen, wie die DWG angezeigt werden soll; die Metadaten können verschiedene Informationen über die Datei enthalten, einschließlich standortspezifischer Daten und auch Kundendaten. Offene Spezifikationen für das DWG-Dateiformat können in diesem PDF gefunden werden.

DWG-Dateien in PDF konvertieren

Die folgenden einfachen Schritte sind erforderlich, um DWG in PDF zu konvertieren.

  1. Laden Sie die DWG-Datei in eine Instanz von Image.
  2. Erstellen Sie ein Objekt der CadRasterizationOptions Klasse und setzen Sie die Eigenschaften PageHeight & PageWidth.
  3. Erstellen Sie ein Objekt der PdfOptions Klasse und setzen Sie die Eigenschaft VectorRasterizationOptions.
  4. Rufen Sie Image.Save auf, während Sie ein Objekt von PdfOptions als zweiten Parameter übergeben.

Das folgende Codebeispiel zeigt, wie man DWG Zeichnungen in PDF exportiert.

// 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);
}
view raw Examples-CSharp-DWG-Drawings-ExportToPDF-ExportToPDF.cs hosted with ❤ by GitHub

Einzelnes PDF mit unterschiedlichen Layoutgrößen erstellen

Aspose.CAD für .NET ermöglicht es, eine DWG-Datei in ein einzelnes PDF mit unterschiedlichen Layoutgrößen zu konvertieren. Dieser Ansatz funktioniert wie folgt:

  1. Laden Sie eine DWG-Datei mit der Aspose.CAD.Image.Load Fabrikmethode.
  2. Erstellen Sie eine Instanz der CadRasterizationOptions Klasse und setzen Sie die resultierende Seitenhöhe und -breite.
  3. Fügen Sie erforderliche LayoutPageSizes für das CadRasterizationOptions Objekt hinzu.
  4. Erstellen Sie eine Instanz der PdfOptions Klasse und setzen Sie ihre VectorRasterizationOptions Eigenschaft.
  5. Exportieren Sie das Bild in PDF mit der Image.Save() Methode.

Das Codebeispiel zeigt, wie man ein einzelnes PDF mit unterschiedlichen Layouts erstellt.

// 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);
}
view raw Src-Features-SinglePDFWithDifferentLayouts-SinglePDFWithDifferentLayouts.cs hosted with ❤ by GitHub

Unterstützte AutoCAD-Primitiven

Die folgenden AutoCAD-Primitiven werden unterstützt.

  • 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

Exportieren eines spezifischen DWG-Layouts nach PDF

Dieser Ansatz funktioniert wie folgt:

  1. Laden Sie eine DWG-Datei mit der Aspose.CAD.Image.Load Fabrikmethode.
  2. Erstellen Sie eine Instanz der CadRasterizationOptions Klasse und setzen Sie die resultierende Seitenhöhe und -breite.
  3. Setzen Sie die Layouts Eigenschaft für das CadRasterizationOptions Objekt.
  4. Erstellen Sie eine Instanz der PdfOptions Klasse und setzen Sie ihre VectorRasterizationOptions Eigenschaft.
  5. Exportieren Sie das Bild in PDF mit der Image.Save() Methode.

Das folgende Codebeispiel zeigt, wie man ein spezifisches Layout von DWG in PDF konvertiert.

// 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);
}
view raw Examples-CSharp-DWG-Drawings-ExportSpecificLayoutToPDF-ExportSpecificLayoutToPDF.cs hosted with ❤ by GitHub

Rendern von DWG-Dokumenten durch Angabe von Koordinaten

Aspose.CAD für .NET API bietet jetzt die Möglichkeit, DWG-Dokumente zu rendern, indem die Breite und Höhe des Dokuments angegeben wird.

Das folgende Codebeispiel zeigt, wie man ein DWG-Dokument rendert.

// 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);
}
view raw Src-DWG-Drawings-RenderDWGDocument-RenderDWGDocument.cs hosted with ❤ by GitHub

Exportieren von DWG nach Raster oder PDF mit fester Größe

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG-Format laden und in PDF oder Raster mit fester Größe konvertieren.

Das folgende Codebeispiel zeigt, wie man diese Funktion implementiert.

// 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;
}
}
view raw Src-DWG-Drawings-ExportDWGToPDFOrRaster-ExportDWGToPDFOrRaster.cs hosted with ❤ by GitHub

Exportieren von DWG nach PDF/A und PDF/E

Dieser Ansatz funktioniert wie folgt:

  1. Laden Sie eine DWG-Datei mit der Aspose.CAD.Image.Load Fabrikmethode.
  2. Erstellen Sie eine Instanz der CadRasterizationOptions Klasse.
  3. Erstellen Sie eine Instanz der PdfOptions Klasse und setzen Sie ihre VectorRasterizationOptions Eigenschaft.
  4. Setzen Sie die PDF-Konformitätseigenschaft und speichern Sie sie.
  5. Exportieren Sie das Bild in PDF mit der Image.Save() Methode.

Das folgende Codebeispiel zeigt, wie man eine DWG-Datei in PDF/A und PDF/E konvertiert.

// 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);
view raw Src-DWG-Drawings-DWGToCompliancePDF-DWGToCompliancePDF.cs hosted with ❤ by GitHub

Unterstützung runder, verborgener Linien beim Exportieren von DWG/DXF nach BMP und PDF

Dieser Ansatz funktioniert wie folgt:

  1. Laden Sie eine DWG-Datei mit der Aspose.CAD.Image.Load Fabrikmethode.
  2. Erstellen Sie eine Instanz der CadRasterizationOptions Klasse und setzen Sie die resultierende Seitenhöhe und -breite.
  3. Erstellen Sie eine Instanz der PdfOptions Klasse und setzen Sie ihre VectorRasterizationOptions Eigenschaft.
  4. Exportieren Sie das Bild in PDF mit der Image.Save() Methode.

Das folgende Codebeispiel zeigt, wie man diese Funktion implementiert.

// 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);
}
view raw Src-DWG-Drawings-SupportForHiddenLines-SupportForHiddenLines.cs hosted with ❤ by GitHub

Unterstützung für das Festlegen des Druckbereichs für DWG-Bilder im exportierten PDF

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG-Format laden und in PDF konvertieren. Dieses Thema erklärt die Verwendung der Aspose.CAD API, um die Unterstützung für das Festlegen eines Druckbereichs für das DWG-Bild im exportierten PDF zu erreichen.

Das folgende Codebeispiel zeigt, wie man diese Funktion implementiert.

// 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);
}
view raw Examples-CSharp-DWG-Drawings-ExportSpecificLayoutToPDF-ExportSpecificLayoutToPDF.cs hosted with ❤ by GitHub

Unterstützung für das Lesen von XREF-Metadaten für DWG-Dateien

  1. Laden Sie eine DWG-Datei mit der Aspose.CAD.Image.Load Fabrikmethode.
  2. Durchlaufen Sie jedes Bildelement.
  3. Wenn ein Element ein CadUnderlay ist, dann XREF-Element mit Metadaten.

Das folgende Codebeispiel zeigt, wie man diese Funktion erreicht.

// 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;
}
}
}
view raw Src-DWG-Drawings-ReadXREEFMetaData-ReadXREEFMetaData.cs hosted with ❤ by GitHub

Die Eigenschaft CadRasterizationOptions.Layouts ist vom Typ String-Array, sodass Sie mehrere Layouts gleichzeitig für eine mögliche Konvertierung in PDF-Format angeben können. Wenn mehrere Layouts für die CadRasterizationOptions.Layouts Eigenschaft angegeben werden, hat das resultierende PDF mehrere Seiten, wobei jede Seite ein individuelles AutoCAD-Layout darstellt.

Alle Layouts auflisten

Sie können alle in einer AutoCAD-Zeichnung vorhandenen Layouts mit dem folgenden Code-Snippet auflisten.

// 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);
}
}
view raw Examples-CSharp-ConvertingCAD-ListLayouts-ListLayouts.cs hosted with ❤ by GitHub

Zugriff auf Unterlagenflags für das DWG-Format

Aspose.CAD für .NET hat die Unterlagenflags für das DWG-Format implementiert und ermöglicht es Entwicklern, auf sie zuzugreifen. Folgendes ist die einfache Code-Demonstration.

// 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;
}
}
}
view raw Examples-CSharp-DWG-Drawings-AccessingUnderlayFlagsofDWG-AccessingUnderlayFlagsofDWG.cs hosted with ❤ by GitHub

Unterstützung für DWG-Elemente

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG-Format laden und unterstützt verschiedene Elemente, mit denen gearbeitet werden kann.

Unterstützung für die MLeader-Entität

Eine DWG ist eine Binärdatei, die Vektorbilder und Metadaten enthält. Es gibt verschiedene Elemente in einer DWG-Datei. Der folgende Abschnitt beschreibt ein Beispiel für die Arbeit mit der MLeader-Entität in der DWG-Datei.

// 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);
}
view raw Examples-CSharp-DWG-Drawings-SupportMLeaderEntityForDWGFormat-SupportMLeaderEntityForDWGFormat.cs hosted with ❤ by GitHub

Unterstützung für den Export von DWG-Elementen nach Bild

Eine DWG ist eine Binärdatei, die Vektorbilder und Metadaten enthält. Es gibt verschiedene Elemente in einer DWG-Datei. Der folgende Abschnitt beschreibt ein Beispiel für den Export eines bestimmten DWG-Elements in das Bild.

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);
view raw Examples-CSharp-DWG-Drawings-ParticularDWGToImage-ParticularDWGToImage.cs hosted with ❤ by GitHub

Unterstützung für das Hinzufügen von Text in DWG

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG-Format laden und unterstützt verschiedene Elemente, mit denen gearbeitet werden kann. Eine DWG ist eine Binärdatei, die Vektorbilder und Metadaten enthält. Es gibt verschiedene Elemente in einer DWG-Datei. Der folgende Abschnitt beschreibt, wie man Text in die DWG-Datei hinzufügen kann.

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);
}
view raw Src-DWG-Drawings-AddTextInDWG-AddTextInDWG.cs hosted with ❤ by GitHub

Unterstützung für das Importieren von Bildern in DWG-Dateien

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG-Format laden und unterstützt verschiedene Elemente, mit denen gearbeitet werden kann. Eine DWG ist eine Binärdatei, die Vektorbilder und Metadaten enthält. Es gibt verschiedene Elemente in einer DWG-Datei. Der folgende Abschnitt beschreibt, wie man Bilder in die DWG-Datei importieren kann.

// 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);
view raw Examples-Src-DWG-Drawings-ImportImageToDWG-ImportImageToDWG.cs hosted with ❤ by GitHub

Unterstützung für Mesh in DWG

Aspose.CAD für .NET API kann jetzt auf die Elemente zugreifen, die Mesh unterstützen, einschließlich CadPolyFaceMesh und CadPolygonMesh Typen. Das folgende Beispiel beschreibt, wie man auf die Mesh-Typen zugreifen kann.

// 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);
}
}
}
}
view raw Examples-CSharp-DWG-Drawings-MeshSupportForDWG-MeshSupportForDWG.cs hosted with ❤ by GitHub

DWG-Zeichnungen in DXF konvertieren

Aspose.CAD bietet die Funktion, eine AutoCAD DWG-Datei zu laden und sie in das DXF-Format zu exportieren. Der Ansatz für die DWG-zu-DXF-Konvertierung funktioniert wie folgt:

  1. Laden Sie die DWG-Zeichnungsdatei mit der Image.Load Fabrikmethode.
  2. Exportieren Sie die DWG-Zeichnung in DXF mit der Image.Save() Methode.

Das folgende Codebeispiel zeigt, wie man eine DWG-Datei in das DXF-Format konvertiert.

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);
}
view raw Examples-CSharp-DWG-Drawings-DWGToDXF-DWGToDXF.cs hosted with ❤ by GitHub

DWG-Zeichnungen in SVG konvertieren

Aspose.CAD für .NET API kann AutoCAD Zeichnungen im DWG-Format laden und in SVG konvertieren. Dieses Thema erklärt die Verwendung der Aspose.CAD API, um die Konvertierung von DWG in SVG-Format durch einfache Schritte zu erreichen, wie unten definiert.

  1. Laden Sie die DWG-Datei in eine Instanz von Image.
  2. Erstellen Sie ein Objekt der SvgOptions Klasse und setzen Sie die erforderlichen Eigenschaften.
  3. Exportieren Sie die DWG-Zeichnung in SVG mit der Image.Save() Methode.

Das folgende Codebeispiel zeigt, wie man eine DWG-Datei in das SVG-Format konvertiert.

// 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");
}
view raw Examples-CSharp-DWG-Drawings-ExportToSVG-ExportToSVG.cs hosted with ❤ by GitHub

Große DWG-Datei laden

Aspose.CAD für .NET bietet die Möglichkeit, sehr große DWG-Dateien mit der Image Klasse zu öffnen. Jetzt können Sie große Dateien ganz einfach mit Hilfe des folgenden Beispielcodes öffnen.

// 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);
}
view raw Src-DWG-Drawings-LargeDWGToPDF-LargeDWGToPDF.cs hosted with ❤ by GitHub
DWFx-Zeichnung DWT Zeichnungen