public void WriteDxfDocument()
{
string file = "bin3.dxf";
// by default it will create an AutoCad2000 DXF version
DxfDocument dxf = new DxfDocument();
// a rectangular wipeout defined by its bottom-left corner and its width and height
Wipeout wipeout = new Wipeout(0, 0, Bin.Width, Bin.Height);
dxf.AddEntity(wipeout);
if (Bin.NestedItems.Count >= 1)
{
foreach (Item nestedItem in Bin.NestedItems)
{
wipeout = new Wipeout(nestedItem.BLpPosition, nestedItem.BLqPosition, nestedItem.Width, nestedItem.Height);
dxf.AddEntity(wipeout);
}
// save to file
dxf.Save(file);
}
// this check is optional but recommended before loading a DXF file
DxfVersion dxfVersion = DxfDocument.CheckDxfFileVersion(file);
// netDxf is only compatible with AutoCad2000 and higher DXF version
if (dxfVersion < DxfVersion.AutoCad2000)
{
return;
}
// load file
DxfDocument loaded = DxfDocument.Load(file);
}
private static void Ellipse()
{
DxfDocument dxf = new DxfDocument();
Line line = new Line(new Vector3(0, 0, 0), new Vector3(2 * Math.Cos(Math.PI / 4), 2 * Math.Cos(Math.PI / 4), 0));
dxf.AddEntity(line);
Line line2 = new Line(new Vector3(0, 0, 0), new Vector3(0, -2, 0));
dxf.AddEntity(line2);
Arc arc = new Arc(Vector3.Zero, 2, 45, 270);
dxf.AddEntity(arc);
// ellipses are saved as polylines
Ellipse ellipse = new Ellipse(new Vector3(2, 2, 0), 5, 3);
ellipse.Rotation = 30;
ellipse.Normal = new Vector3(1, 1, 1);
ellipse.Thickness = 2;
dxf.AddEntity(ellipse);
dxf.Save("ellipse.dxf", DxfVersion.AutoCad2000);
dxf = new DxfDocument();
dxf.Load("ellipse.dxf");
}
/// <summary>
/// Saves the contours and hatches in layers corresponding to its tile
/// </summary>
/// <param name="outputDirectory"></param>
/// <param name="outputName"></param>
/// <returns></returns>
public bool ExportAsDXF(string outputDirectory, string outputName)
{
var outputFilePath = Path.Combine(outputDirectory, outputName);
var document = new DxfDocument(new HeaderVariables());
// combine geometries
var geometries = HatchLines.Concat(ContourLines).ToArray();
// clip geometries in tiles and results to dxf layer
for (int i = 0; i < Tiles.Count; i++)
{
for (int j = 0; j < geometries.Length; j++)
{
var results = GeometricArithmeticModule.ClipGeometry(
geometries[j],
Tiles[i]
);
for (int k = 0; k < results?.Count; k++)
{
document.AddEntity(
results[k].GetAsDXFEntity(
$"Tile {i}"
)
);
}
}
}
document.Save(outputFilePath);
return(File.Exists(outputFilePath));
}
private static void LoadSaveHatchTest()
{
DxfDocument dxf = new DxfDocument();
dxf.Load("Hatch2.dxf");
dxf.Save("HatchTest.dxf", DxfVersion.AutoCad2000);
}
public void writeDxf(string file, string inputText, double textHeight, Layer layer)
{
bool isBinary;
// this check is optional but recommended before loading a DXF file
DxfVersion dxfVersion = DxfDocument.CheckDxfFileVersion(file, out isBinary);
// netDxf is only compatible with AutoCad2000 and higher DXF version
if (dxfVersion < DxfVersion.AutoCad2000)
{
return;
}
// load file
dxfDocument = DxfDocument.Load(file);
// text
text = new Text(inputText, textLocation, textHeight);
text.Layer = layer;
text.Alignment = TextAlignment.BottomLeft;
dxfDocument.AddEntity(text);
// save to file
dxfDocument.Save(file);
}
private static void WritePolyline3d()
{
DxfDocument dxf = new DxfDocument();
List <Polyline3dVertex> vertexes = new List <Polyline3dVertex> {
new Polyline3dVertex(0, 0, 0),
new Polyline3dVertex(10, 0, 10),
new Polyline3dVertex(10, 10, 20),
new Polyline3dVertex(0, 10, 30)
};
Polyline3d poly = new Polyline3d(vertexes, true);
XData xdata = new XData(new ApplicationRegistry("netDxf"));
xdata.XDataRecord.Add(new XDataRecord(XDataCode.String, "extended data with netDxf"));
xdata.XDataRecord.Add(XDataRecord.OpenControlString);
xdata.XDataRecord.Add(new XDataRecord(XDataCode.String, "netDxf polyline3d"));
xdata.XDataRecord.Add(new XDataRecord(XDataCode.Integer, poly.Vertexes.Count));
xdata.XDataRecord.Add(XDataRecord.CloseControlString);
poly.XData = new Dictionary <ApplicationRegistry, XData>
{
{ xdata.ApplicationRegistry, xdata },
};
dxf.AddEntity(poly);
dxf.Save("polyline.dxf", DxfVersion.AutoCad2000);
}
private static void Face3d()
{
DxfDocument dxf = new DxfDocument();
Face3d face3d = new Face3d();
face3d.FirstVertex = new Vector3(0, 0, 0);
face3d.SecondVertex = new Vector3(1, 0, 0);
face3d.ThirdVertex = new Vector3(1, 1, 0);
face3d.FourthVertex = new Vector3(0, 1, 0);
dxf.AddEntity(face3d);
dxf.Save("face.dxf", DxfVersion.AutoCad2000);
dxf.Load("face.dxf");
dxf.Save("face return.dxf", DxfVersion.AutoCad2000);
}
public void saveDxfFromListListPoints(string savePath, List <List <System.Drawing.Point> > listListPoints)
{
ListAddedElements_as_List_Of_Point = listListPoints;
dxf_File = new DxfDocument(netDxf.Header.DxfVersion.AutoCad2013);
listToPolyline = ToPolyLine2(ListAddedElements_as_List_Of_Point);
ListAddedElements_as_PL = new List <List <shapes.Polyline> >();
ListAddedElements_as_PL.Add(listToPolyline);
allLists_LwPolyline = ToLwPolyline2(ListAddedElements_as_PL);
foreach (List <LwPolyline> List_LwPL in allLists_LwPolyline)
{
foreach (LwPolyline LwPL in List_LwPL)
{
LwPL.Layer = new netDxf.Tables.Layer(Werkzeug);
dxf_File.AddEntity(LwPL);
}
}
netDxf.Entities.Point newPt = new netDxf.Entities.Point(Width, Height, Depth);
dxf_File.AddEntity(newPt);
dxf_File.Save(savePath);
}
public void WriteToFile(Project toExport, string filename)
{
Model modelSpace = null;
if (toExport.GetModelCount() == 1)
{
modelSpace = toExport.GetModel(0);
}
else
{
modelSpace = toExport.FindModel("*Model_Space");
}
if (modelSpace == null)
{
modelSpace = toExport.GetActiveModel();
}
for (int i = 0; i < modelSpace.Count; i++)
{
EntityObject entity = GeoObjectToEntity(modelSpace[i]);
if (entity != null)
{
doc.Entities.Add(entity);
}
}
doc.Save(filename);
}
static void ConvertFile(string from, string to, bool displayshapes, bool outlineshapes)
{
ParsedGerber PLS = PolyLineSet.LoadGerberFile(new StandardConsoleLog(), from, true, State: new GerberParserState()
{
PreCombinePolygons = true
});
DxfDocument dxf = new DxfDocument();
// add your entities here
if (outlineshapes)
{
foreach (var a in PLS.OutlineShapes)
{
List <netDxf.Entities.PolylineVertex> Vertices = new List <netDxf.Entities.PolylineVertex>();
foreach (var v in a.Vertices)
{
Vertices.Add(new netDxf.Entities.PolylineVertex(v.X, v.Y, 0));
}
netDxf.Entities.Polyline pl = new netDxf.Entities.Polyline(Vertices, true);
pl.Color = new AciColor(System.Drawing.Color.Blue);
dxf.AddEntity(pl);
}
}
if (displayshapes)
{
foreach (var a in PLS.DisplayShapes)
{
List <netDxf.Entities.PolylineVertex> Vertices = new List <netDxf.Entities.PolylineVertex>();
foreach (var v in a.Vertices)
{
Vertices.Add(new netDxf.Entities.PolylineVertex(v.X, v.Y, 0));
}
netDxf.Entities.Polyline pl = new netDxf.Entities.Polyline(Vertices, true);
pl.Color = new AciColor(System.Drawing.Color.Green);
dxf.AddEntity(pl);
}
}
if (false)
{
foreach (var a in PLS.Shapes)
{
List <netDxf.Entities.PolylineVertex> Vertices = new List <netDxf.Entities.PolylineVertex>();
foreach (var v in a.Vertices)
{
Vertices.Add(new netDxf.Entities.PolylineVertex(v.X, v.Y, 0));
}
netDxf.Entities.Polyline pl = new netDxf.Entities.Polyline(Vertices, true);
pl.Color = new AciColor(System.Drawing.Color.Red);
dxf.AddEntity(pl);
}
}
// save to file
dxf.Save(to);
}
private static void WritePolyfaceMesh()
{
DxfDocument dxf = new DxfDocument();
List <PolyfaceMeshVertex> vertexes = new List <PolyfaceMeshVertex>
{
new PolyfaceMeshVertex(0, 0, 0),
new PolyfaceMeshVertex(10, 0, 0),
new PolyfaceMeshVertex(10, 10, 0),
new PolyfaceMeshVertex(5, 15, 0),
new PolyfaceMeshVertex(0, 10, 0)
};
List <PolyfaceMeshFace> faces = new List <PolyfaceMeshFace>
{
new PolyfaceMeshFace(new[] { 1, 2, -3 }),
new PolyfaceMeshFace(new[] { -1, 3, -4 }),
new PolyfaceMeshFace(new[] { -1, 4, 5 })
};
PolyfaceMesh mesh = new PolyfaceMesh(vertexes, faces);
dxf.AddEntity(mesh);
dxf.Save("mesh.dxf", DxfVersion.AutoCad2000);
}
private static void HatchTest1()
{
DxfDocument dxf = new DxfDocument();
Polyline poly = new Polyline();
poly.Vertexes.Add(new PolylineVertex(-10, -10));
poly.Vertexes.Add(new PolylineVertex(10, -10));
poly.Vertexes.Add(new PolylineVertex(10, 10));
poly.Vertexes.Add(new PolylineVertex(-10, 10));
poly.Vertexes[2].Bulge = 1;
poly.IsClosed = true;
Polyline poly2 = new Polyline();
poly2.Vertexes.Add(new PolylineVertex(-5, -5));
poly2.Vertexes.Add(new PolylineVertex(5, -5));
poly2.Vertexes.Add(new PolylineVertex(5, 5));
poly2.Vertexes.Add(new PolylineVertex(-5, 5));
poly2.Vertexes[1].Bulge = -0.25;
poly2.IsClosed = true;
Polyline poly3 = new Polyline();
poly3.Vertexes.Add(new PolylineVertex(-8, -8));
poly3.Vertexes.Add(new PolylineVertex(-6, -8));
poly3.Vertexes.Add(new PolylineVertex(-6, -6));
poly3.Vertexes.Add(new PolylineVertex(-8, -6));
poly3.IsClosed = true;
List <HatchBoundaryPath> boundary = new List <HatchBoundaryPath> {
new HatchBoundaryPath(new List <IEntityObject> {
poly
}),
new HatchBoundaryPath(new List <IEntityObject> {
poly2
}),
new HatchBoundaryPath(new List <IEntityObject> {
poly3
}),
};
Hatch hatch = new Hatch(HatchPattern.Net, boundary);
hatch.Layer = new Layer("hatch")
{
Color = AciColor.Red,
LineType = LineType.Continuous
};
hatch.Pattern.Angle = 30;
hatch.Pattern.Scale = 1 / hatch.Pattern.LineDefinitions[0].Delta.Y;
dxf.AddEntity(poly);
dxf.AddEntity(poly2);
dxf.AddEntity(poly3);
dxf.AddEntity(hatch);
dxf.Save("hatchTest.dxf", DxfVersion.AutoCad2000);
dxf.Load("hatchTest.dxf");
}
public void SaveDocument2DXF(string fileName)
{
if (docWrite != null)
{
docWrite.Save(fileName);
}
docWrite = ObjectFactory.CreateDoc();
}
public void Save()
{
#if UNITY_EDITOR
doc.Save("D:/testDXFBinary.dxf", true);
return;
#endif
MemoryStream stream = new MemoryStream();
if (doc.Save(stream))
{
DownloadFile(stream.ToArray(), stream.ToArray().Length, "testfile.dxf");;
}
else
{
Debug.Log("cant write file");
}
}
/// <summary>
/// Fügt Entity Objekte in dem aktuellen DXF Objekt hinzu.
/// </summary>
/// <param name="listObj"> Liste der hinzuzufügenden Entity Objekte</param>
public void JoinToDxF(params EntityObject[] listObj)
{
foreach (EntityObject item in listObj)
{
dxf_File.AddEntity(item);
dxf_File.Save(dxf_File.Name);
}
}
private static void ToPolyline()
{
DxfDocument dxf = new DxfDocument();
Vector3 center = new Vector3(1, 8, -7);
Vector3 normal = new Vector3(1, 1, 1);
Circle circle = new Circle(center, 7.5);
circle.Normal = normal;
Arc arc = new Arc(center, 5, 30, 215);
arc.Normal = normal;
Ellipse ellipse = new Ellipse(center, 15, 7.5);
ellipse.Rotation = 35;
ellipse.Normal = normal;
Ellipse ellipseArc = new Ellipse(center, 10, 5);
ellipseArc.StartAngle = 30;
ellipseArc.EndAngle = 325;
ellipseArc.Rotation = 35;
ellipseArc.Normal = normal;
dxf.AddEntity(circle);
dxf.AddEntity(circle.ToPolyline(10));
dxf.AddEntity(arc);
dxf.AddEntity(arc.ToPolyline(10));
dxf.AddEntity(ellipse);
dxf.AddEntity(ellipse.ToPolyline(10));
dxf.AddEntity(ellipseArc);
dxf.AddEntity(ellipseArc.ToPolyline(10));
dxf.Save("to polyline.dxf", DxfVersion.AutoCad2000);
dxf.Load("to polyline.dxf");
dxf.Save("to polyline2.dxf", DxfVersion.AutoCad2000);
}
void GeneratePartNo1(string fileName)
{
DxfDocument dxf = new DxfDocument();
AddRectangle(ref dxf, new Vector2(0d, 0), new Vector2(E, B + 2 * T));
dxf.Save(fileName);
}
/// <summary>
/// Fügt Entity Objekte in einer bereits vorhandenen DXF Datei hinzu.
/// </summary>
/// <param name="dxf_path">Pfad des DXF Documents, wo es hingespeichert werden soll</param>
/// <param name="doc">DXF Document wo es hinzugefügt werden soll</param>
/// <param name="listObj">Liste der hinzuzufügenden Entity Objekte</param>
static public void JoinToDxF(string dxf_path, ref DxfDocument doc, params EntityObject[] listObj)
{
foreach (EntityObject item in listObj)
{
doc.AddEntity(item);
}
doc.Save(dxf_path);
}
/// <summary>
/// Fügt Arbeitseigenschaften in einer bereits vorhandenen DXF Datei hinzu.
/// </summary>
/// <param name="dxf_path">Pfad des DXF Documents, wo es hingespeichert werden soll</param>
/// <param name="doc">DXF Document wo es hinzugefügt werden soll</param>
/// <param name="workPiece">Entsprechende Arbeitseigenschaften</param>
static public void JoinToDxF(string dxf_path, ref DxfDocument doc, ElementManager.workpiece workPiece)
{
foreach (LwPolyline item in doc.LwPolylines)
{
item.Layer = new netDxf.Tables.Layer(workPiece.werkzeugName);
}
netDxf.Entities.Point newPt = new netDxf.Entities.Point(workPiece.height, workPiece.width, workPiece.depth);
doc.AddEntity(newPt);
doc.Save(dxf_path);
}
public void Save()
{
#if UNITY_EDITOR
var mydocs = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
dxfDocument.Save(Path.Combine(mydocs, "testDXFBinary.dxf"), true);
return;
#endif
using (var stream = new MemoryStream())
{
if (dxfDocument.Save(stream))
{
JavascriptMethodCaller.DownloadByteArrayAsFile(stream.ToArray(), stream.ToArray().Length, "testfile.dxf");
}
else
{
Debug.Log("cant write file");
}
}
}
/// <inheritdoc/>
void IProjectExporter.Save(string path, ProjectContainer project)
{
_outputPath = System.IO.Path.GetDirectoryName(path);
var dxf = new DxfDocument(DxfVersion.AutoCad2010);
Add(dxf, project);
dxf.Save(path);
ClearCache(isZooming: false);
}
/// <inheritdoc/>
void Core2D.Interfaces.IProjectExporter.Save(string path, Core2D.Project.XProject project)
{
_outputPath = System.IO.Path.GetDirectoryName(path);
var dxf = new DxfDocument(DxfVersion.AutoCad2010);
Add(dxf, project);
dxf.Save(path);
ClearCache(isZooming: false);
}
//needs to go to cadgen exporter with a list of polylines and attributes
public static MemoryStream Get(string fileName, IExporter cadGenExporter, Action <string> action)
{
bool isBinary;
var ver = DxfDocument.CheckDxfFileVersion(fileName, out isBinary);
DxfDocument doc = DxfDocument.Load(fileName);
var docSector = doc.Texts.FirstOrDefault(x => string.Equals(x.Layer.Name, "Sector", StringComparison.InvariantCultureIgnoreCase));
var polys = GetPolys(doc);
var i = 0;
var c = polys.Count();
//Parallel.ForEach(polys, p =>
foreach (var p in polys)
{
var cI = Interlocked.Increment(ref i);
action($"Export DXF: {cI} / {c}; index:{p.index.Value}");
//CF - INDEX
int index;
if (int.TryParse(p.index.Value.Trim(), out index))
{
var points = p.poly.ToPoints();
var area = VectorExtensions.Area(points);
p.poly.XData.Clear();
var cg = cadGenExporter.Export(index, points, area, p.nrCadGeneral?.Value, docSector?.Value, p.nrCadastral?.Value).Result;
if (cg.Length > 0)
{
var xD = new XData(new ApplicationRegistry("TOPO"));
xD.XDataRecord.Add(new XDataRecord(XDataCode.ControlString, "{"));
foreach (var line in cg)
{
var xDR = new XDataRecord(XDataCode.String, line);
xD.XDataRecord.Add(xDR);
}
xD.XDataRecord.Add(new XDataRecord(XDataCode.ControlString, "}"));
p.poly.XData.Add(xD);
}
}
}//);
var stream = new MemoryStream();
doc.Save(stream, isBinary);
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
public void PrintM()
{
DxfDocument dxfDocument = new DxfDocument();
//Печать рамы
for (int i = 0; i < epureLines.Length; i++)
{
Line line = new Line(epureLines[i].StartPoint, epureLines[i].EndPoint);
dxfDocument.AddEntity(line);
}
//Печать эпюр. Нужно добавить кф отображения
for (int i = 0; i < epureLines.Length; i++)
{
double coefficient = 15;
var dx = Math.Abs(epureLines[i].StartPoint.X - epureLines[i].EndPoint.X);
var dy = (epureLines[i].EndPoint.Y - epureLines[i].StartPoint.Y);
var hypotenuse = Math.Sqrt(Math.Pow(dx, 2) + Math.Pow(dy, 2));
var cos = dx / hypotenuse;
double sin;
//Для ригелей у которых dy< 0 меняем направление по Х, для стоек оставляем изначальное (можно поменять направление ригелей для унификации)
switch (Math.Round(dx, 2))
{
case 0:
sin = dy / hypotenuse;
break;
default:
sin = -dy / hypotenuse;
break;
}
//var startMoment = Math.Sqrt(Math.Pow(epureLines[i].StartMoment, 2) / 2);
var pointStartMoment = new Vector2(epureLines[i].StartPoint.X + epureLines[i].StartMoment * sin / coefficient,
epureLines[i].StartPoint.Y + epureLines[i].StartMoment * cos / coefficient);
//var middleMoment = Math.Sqrt(Math.Pow(epureLines[i].MiddleMoment, 2) / 2);
var pointMiddle = new Vector2((epureLines[i].StartPoint.X + epureLines[i].EndPoint.X) / 2,
(epureLines[i].StartPoint.Y + epureLines[i].EndPoint.Y) / 2);
var pointMidlleMoment = new Vector2((epureLines[i].StartPoint.X + epureLines[i].EndPoint.X) / 2 + epureLines[i].MiddleMoment * sin / coefficient,
(epureLines[i].StartPoint.Y + epureLines[i].EndPoint.Y) / 2 + epureLines[i].MiddleMoment * cos / coefficient);
//var endtMoment = Math.Sqrt(Math.Pow(epureLines[i].EndMoment, 2) / 2);
var pointEndMoment = new Vector2(epureLines[i].EndPoint.X + epureLines[i].EndMoment * sin / coefficient,
epureLines[i].EndPoint.Y + epureLines[i].EndMoment * cos / coefficient);
Line line1 = new Line(epureLines[i].StartPoint, pointStartMoment);
Line line2 = new Line(pointMiddle, pointMidlleMoment);
Line line3 = new Line(epureLines[i].EndPoint, pointEndMoment);
Line line4 = new Line(pointStartMoment, pointMidlleMoment);
Line line5 = new Line(pointMidlleMoment, pointEndMoment);
var lines = new List <Line>()
{
line1, line2, line3, line4, line5
};
dxfDocument.AddEntity(lines);
}
dxfDocument.Save(@"e:\Програмирование\Перемножение эпюр\plot.dxf");
}
private void button_export(object sender, EventArgs e)
{
DxfDocument Doc = new DxfDocument();
/* Отрисовка участков */
for (int z = 0; z < MyXmlReader.spatials.Count; z++)
{
LwPolyline parcel = new LwPolyline();
foreach (var Point in MyXmlReader.spatials[z].Points)
{
centerX += (ulong)Point.X;
centerY += (ulong)Point.Y;
centerCounter++;
if (Switch.Checked)//Перевернуть X Y
{
parcel.Vertexes.Add(new LwPolylineVertex(new Vector2(Point.Y, Point.X)));
}
else
{
parcel.Vertexes.Add(new LwPolylineVertex(Point));
}
}
Doc.AddEntity(parcel);
}
/* Создаем надпись кад. номера */
Text cad_number = new Text();
cad_number.Value = MyXmlReader.CadastralNumber;
cad_number.Alignment = TextAlignment.MiddleCenter;
cad_number.Height = 2.5d;
if (Switch.Checked)
{
Vector3 textPosition = new Vector3((double)centerY / centerCounter, (double)centerX / centerCounter, 0);
cad_number.Position = textPosition;
}
else
{
Vector3 textPosition = new Vector3((double)centerX / centerCounter, (double)centerY / centerCounter, 0);
cad_number.Position = textPosition;
}
Doc.AddEntity(cad_number);
try
{
Doc.Save(textBoxTo.Text);
}
catch (IOException x)
{
MessageBox.Show(x.Message);
}
Application.Exit();
}
/// <summary>
/// Saves dxf file on given location
/// </summary>
/// <param name="filePath">Path to created file</param>
/// <returns>IDrawMapping</returns>
public IDrawMapping SaveDrawing(string filePath)
{
if (Parm == null)
{
throw new Exception("No parametars for assigned");
}
var fileInfo = new FileInfo(filePath);
dxf.Save(fileInfo.FullName);
return(this);
}
public static void Exportar(string path, DXFItem item)
{
DxfDocument dxf = new DxfDocument();
foreach (var c in item.entities.OfType <EntityObject>())
{
dxf.AddEntity((EntityObject)c.Clone());
}
dxf.Save(path);
}
/// <summary>
/// Fügt Entity Objekte in einer bereits vorhandenen DXF Datei hinzu.
/// </summary>
/// <param name="dxf_path">Pfad des DXF Documents, wo es hingespeichert werden soll</param>
/// <param name="doc">DXF Document wo es hinzugefügt werden soll</param>
/// <param name="workPiece">Entsprechende Arbeitseigenschaften</param>
/// <param name="listObj">Liste der hinzuzufügenden Entity Objekte</param>
static public void JoinToDxF(string dxf_path, ref DxfDocument doc, ElementManager.workpiece workPiece, params EntityObject[] listObj)
{
foreach (EntityObject item in listObj)
{
item.Layer = new netDxf.Tables.Layer(workPiece.werkzeugName);
doc.AddEntity(item);
}
netDxf.Entities.Point newPt = new netDxf.Entities.Point(workPiece.height, workPiece.width, workPiece.depth);
doc.AddEntity(newPt);
doc.Save(dxf_path);
}
private static void ReadDxfFile()
{
DxfDocument dxf = new DxfDocument();
//dxf.Load("AutoCad2007.dxf");
//dxf.Load("AutoCad2004.dxf");
dxf.Load("AutoCad2000.dxf");
dxf.Save("AutoCad2000 result.dxf", DxfVersion.AutoCad2000);
//dxf.Load("AutoCad12.dxf");
//dxf.Load("Tablet.dxf");
//dxf.Save("Tablet result.dxf", DxfVersion.AutoCad2000);
}
private static void Dxf2000()
{
DxfDocument dxf = new DxfDocument();
//line
Line line = new Line(new Vector3(0, 0, 0), new Vector3(5, 5, 5));
line.Layer = new Layer("line");
line.Layer.Color.Index = 6;
dxf.AddEntity(line);
dxf.Save("test2000.dxf", DxfVersion.AutoCad2000);
}
/// <summary>
/// Saves a block to a dxf file.
/// </summary>
/// <param name="file">Dxf file name.</param>
/// <param name="version">Version of the dxf database version.</param>
/// <param name="isBinary">Defines if the file will be saved as binary, by default it will be saved as text</param>
/// <returns>Return true if the file has been successfully save, false otherwise.</returns>
public bool Save(string file, DxfVersion version, bool isBinary = false)
{
DxfDocument dwg = new DxfDocument(version);
dwg.DrawingVariables.InsBase = this.position;
dwg.DrawingVariables.InsUnits = this.Record.Units;
Block copy = (Block) this.Clone();
dwg.AddEntity(copy.Entities);
foreach (AttributeDefinition attdef in copy.AttributeDefinitions.Values)
{
dwg.AddEntity(attdef);
}
return dwg.Save(file, isBinary);
}
/// <summary>
/// Saves a block to a dxf file.
/// </summary>
/// <param name="file">Dxf file name.</param>
/// <param name="version">Version of the dxf database version.</param>
/// <param name="isBinary">Defines if the file will be saved as binary, by default it will be saved as text</param>
/// <returns>Return true if the file has been successfully save, false otherwise.</returns>
public bool Save(string file, DxfVersion version, bool isBinary = false)
{
DxfDocument dwg = new DxfDocument(version);
dwg.DrawingVariables.InsBase = this.origin;
dwg.DrawingVariables.InsUnits = this.Record.Units;
foreach (EntityObject entity in this.entities)
dwg.AddEntity((EntityObject)entity.Clone());
foreach (AttributeDefinition attdef in this.attributes.Values)
dwg.AddEntity((EntityObject)attdef.Clone());
return dwg.Save(file, isBinary);
}
