private async Task <DxfFile> WriteToFile(Drawing drawing)
{
using (var stream = await WriteToStream(drawing))
{
return(DxfFile.Load(stream));
}
}
static void Main(string[] args)
{
DxfFile dxfFile = DxfFile.Load(@"D:\Test\Spline.dxf");
IList <DxfEntity> dxfEntities = dxfFile.Entities;
foreach (var entity in dxfEntities)
{
if (entity is DxfSpline)
{
DxfSpline dxfSpline = entity as DxfSpline;
Point2D[] p = new Point2D[dxfSpline.ControlPoints.Count];
double[] t = new double[dxfSpline.KnotValues.Count];
for (int i = 0; i < p.Length; i++)
{
p[i] = new Point2D(dxfSpline.ControlPoints[i].X, dxfSpline.ControlPoints[i].Y);
}
for (int i = 0; i < t.Length; i++)
{
t[i] = dxfSpline.KnotValues[i];
}
Point2D test = new Point2D(dxfSpline.ControlPoints[0].X, dxfSpline.ControlPoints[0].Y);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.1);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.2);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.3);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.4);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.5);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.6);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.7);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.8);
test = NET.Spline.EvaluateSpline(p, t, dxfSpline.DegreeOfCurve, 0.9);
test = new Point2D(dxfSpline.ControlPoints[dxfSpline.ControlPoints.Count - 1].X, dxfSpline.ControlPoints[dxfSpline.ControlPoints.Count - 1].Y);
}
}
}
public void ReadDxbNoLengthOrPositionStreamTest()
{
var data = DxbSentinel.Concat(new byte[]
{
// color
136, // type specifier for new color
0x01, 0x00, // color index 1
// line
0x01, // type specifier
0x01, 0x00, // P1.X = 0x0001
0x02, 0x00, // P1.Y = 0x0002
0x03, 0x00, // P1.Z = 0x0003
0x04, 0x00, // P2.X = 0x0004
0x05, 0x00, // P2.Y = 0x0005
0x06, 0x00, // P2.Z = 0x0006
0x0 // null terminator
}).ToArray();
using (var ms = new MemoryStream(data))
using (var stream = new StreamWithNoLengthOrPosition(ms))
{
var file = DxfFile.Load(stream);
var line = (DxfLine)file.Entities.Single();
Assert.Equal(1, line.Color.RawValue);
Assert.Equal(new DxfPoint(1, 2, 3), line.P1);
Assert.Equal(new DxfPoint(4, 5, 6), line.P2);
}
}
public void ExceptionOnNonDxfFileTest()
{
using (var ms = new MemoryStream())
{
// made to look like the start of an R14 DWG
var dwgBytes = new[]
{
'A', 'C', '1', '0', '1', '4',
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
foreach (var b in dwgBytes)
{
ms.WriteByte((byte)b);
}
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
try
{
DxfFile.Load(ms);
throw new Exception("Previous call should have thrown.");
}
catch (DxfReadException ex)
{
if (ex.Message != "Not a valid DXF file header: `AC1014`.")
{
throw new Exception("Improper exception", ex);
}
}
}
}
public async void VerifyNonDefaultVersionIsPreservedInWriteTest()
{
using (var ms1 = new MemoryStream())
{
var drawing = new Drawing();
// write file as R13
using (new DxfFileSettingsProvider(new DxfFileSettings()
{
FileVersion = DxfFileVersion.R13
}))
{
Assert.True(await Workspace.ReaderWriterService.TryWriteDrawing("filename.dxf", drawing, ViewPort.CreateDefaultViewPort(), ms1, preserveSettings: false));
}
// verify that it was written as such
ms1.Seek(0, SeekOrigin.Begin);
var file = DxfFile.Load(ms1);
Assert.Equal(DxfAcadVersion.R13, file.Header.Version);
using (var ms2 = new MemoryStream())
{
// write it again
Assert.True(await Workspace.ReaderWriterService.TryWriteDrawing("filename.dxf", drawing, ViewPort.CreateDefaultViewPort(), ms2, preserveSettings: true));
// verify again that it was written correctly without specifying drawing settings
ms2.Seek(0, SeekOrigin.Begin);
file = DxfFile.Load(ms2);
Assert.Equal(DxfAcadVersion.R13, file.Header.Version);
}
}
}
public void ReadDxbPolylineTest()
{
var data = DxbSentinel.Concat(new byte[]
{
19, // polyline
0x00, 0x00, // is closed = false
20, // vertex
0x01, 0x00, // x
0x02, 0x00, // y
20, // vertex
0x03, 0x00, // x
0x04, 0x00, // y
17, // seqend
0x00 // null terminator
}).ToArray();
using (var stream = new MemoryStream(data))
{
var file = DxfFile.Load(stream);
var poly = (DxfPolyline)file.Entities.Single();
Assert.Equal(2, poly.Vertices.Count);
Assert.Equal(new DxfPoint(1.0, 2.0, 0.0), poly.Vertices[0].Location);
Assert.Equal(new DxfPoint(3.0, 4.0, 0.0), poly.Vertices[1].Location);
}
}
public string Upload()
{
var upload = Request.Form.Files["file"];
if (upload != null)
{
// получаем имя файла
var fileName = Path.GetFileName(upload.FileName);
using (var ms = new MemoryStream())
{
upload.CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
try
{
var dxfFile = DxfFile.Load(ms);
var fileJson = new DxfToJsonConverter().EncodeFileJson(dxfFile);
return(fileJson);
}
catch (Exception e)
{
return($"{{\"error\":\"{e.Message}\"}}");
}
}
}
return("{\"error\":\"No File Uploaded\"}");
}
public void ReadEmptyFileTest()
{
using (var ms = new MemoryStream())
{
var _ = DxfFile.Load(ms);
}
}
public void ReadDxbNoLengthOrPositionStreamTest()
{
var data = new byte[]
{
// DXB sentinel
(byte)'A', (byte)'u', (byte)'t', (byte)'o', (byte)'C', (byte)'A', (byte)'D', (byte)' ', (byte)'D', (byte)'X', (byte)'B', (byte)' ', (byte)'1', (byte)'.', (byte)'0', (byte)'\r', (byte)'\n', 0x1A, 0x0,
// color
136, // type specifier for new color
0x01, 0x00, // color index 1
// line
0x01, // type specifier
0x01, 0x00, // P1.X = 0x0001
0x02, 0x00, // P1.Y = 0x0002
0x03, 0x00, // P1.Z = 0x0003
0x04, 0x00, // P1.X = 0x0004
0x05, 0x00, // P1.Y = 0x0005
0x06, 0x00, // P1.Z = 0x0006
// null terminator
0x0
};
using (var ms = new MemoryStream(data))
using (var stream = new StreamWithNoLengthOrPosition(ms))
{
var file = DxfFile.Load(stream);
var line = (DxfLine)file.Entities.Single();
Assert.Equal(1, line.Color.RawValue);
Assert.Equal(new DxfPoint(1, 2, 3), line.P1);
Assert.Equal(new DxfPoint(4, 5, 6), line.P2);
}
}
private void buttonOpenDxf_Click(object sender, EventArgs e)
{
var opf = new OpenFileDialog();
opf.Filter = "DXF Files(*.dxf)|*.dxf";
if (opf.ShowDialog() == DialogResult.OK)
{
dxfFile = DxfFile.Load(opf.FileName);
var(centerX, centerY) = new Mather().GetCenter(dxfFile);
Renderer.OffsetX = -centerX + pictureBoxMain.Width / 2f;
Renderer.OffsetY = centerY - pictureBoxMain.Height / 2f;
Renderer.Render(dxfFile, bitmap, pictureBoxMain.Width, pictureBoxMain.Height);
// var encodedFile = new DxfToJsonConverter().EncodeFileJson(dxfFile);
// File.WriteAllText("json.json", encodedFile);
pictureBoxMain.Refresh();
labelCost.Text = "Cost: " + new Mather().GetFileTotalLength(dxfFile) + " c.u.";
}
Focus();
}
private DxfFile WriteToFile(Drawing drawing)
{
using (var stream = WriteToStream(drawing))
{
return(DxfFile.Load(stream));
}
}
public IEnumerable <DxfLine> Trace(Stream data, Settings settings)
{
var dxf = DxfFile.Load(data);
var unitsConversion = GetConversionToMillimeters(dxf);
var lines = TraceDxf(dxf, settings, unitsConversion);
return(lines.ToArray());
}
public static int Export(string path, IEnumerable <NFP> polygons, IEnumerable <NFP> sheets)
{
Dictionary <DxfFile, int> dxfexports = new Dictionary <DxfFile, int>();
for (int i = 0; i < sheets.Count(); i++)
{
DxfFile sheetdxf;
double sheetwidth;
GenerateSheetOutline(sheets, i, out sheetdxf, out sheetwidth);
foreach (NFP nFP in polygons)
{
var pivot = nFP.Points[0];
DxfFile fl;
if (nFP.fitted == false || !nFP.Name.ToLower().Contains(".dxf") || nFP.sheet.Id != sheets.ElementAt(i).Id)
{
continue;
}
else
{
fl = DxfFile.Load(nFP.Name);
}
double sheetXoffset = -sheetwidth * i;
DxfPoint offsetdistance = new DxfPoint(nFP.x + sheetXoffset, nFP.y, 0D);
List <DxfEntity> newlist = OffsetToNest(fl.Entities, new DxfPoint(pivot.x, pivot.y, 0), offsetdistance, nFP.Rotation);
foreach (DxfEntity ent in newlist)
{
sheetdxf.Entities.Add(ent);
}
}
dxfexports.Add(sheetdxf, sheets.ElementAt(i).Id);
}
int sheetcount = 0;
for (int i = 0; i < dxfexports.Count(); i++)
{
var dxf = dxfexports.ElementAt(i).Key;
var id = dxfexports.ElementAt(i).Value;
if (dxf.Entities.Count != 1)
{
sheetcount += 1;
FileInfo fi = new FileInfo(path);
dxf.Save($"{fi.FullName.Substring(0, fi.FullName.Length - 4)}{id}.dxf", true);
}
}
return(sheetcount);
}
public void ReadBinaryDxfNoLengthOrPositionStreamTest()
{
// this file contains 12 lines
using (var fs = new FileStream("diamond-bin.dxf", FileMode.Open, FileAccess.Read))
using (var stream = new StreamWithNoLengthOrPosition(fs))
{
var file = DxfFile.Load(stream);
Assert.Equal(12, file.Entities.Count);
Assert.Equal(12, file.Entities.Where(e => e.EntityType == DxfEntityType.Line).Count());
}
}
protected static DxfFile Parse(string data)
{
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, new UTF8Encoding(false)))
{
writer.WriteLine(data.Trim());
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
return(DxfFile.Load(ms));
}
}
private DxfFile RoundTripFileThroughODA(DxfFile file)
{
using (var input = new ManageTemporaryDirectory())
using (var output = new ManageTemporaryDirectory())
{
file.Save(Path.Combine(input.DirectoryPath, "drawing.dxf"));
AssertODAConvert(input.DirectoryPath, output.DirectoryPath, file.Header.Version);
var result = DxfFile.Load(Path.Combine(output.DirectoryPath, "drawing.dxf"));
return(result);
}
}
public bool Load(System.IO.Stream stream)
{
try
{
return(Load(DxfFile.Load(stream)));
}
catch (Exception ex)
{
_log.Warn($"Libray IxMilia.Dxf failed to load DXF stream : {ex.Message}");
return(false);
}
}
public void ReadWithExtraTrailingNewlinesTest()
{
// file must be created this way to ensure all appropriate newlines are present for parsing
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms))
{
writer.Write("0\r\nEOF\r\n\r\n");
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
var file = DxfFile.Load(ms);
}
}
public bool Load(string filePath)
{
try
{
return(Load(DxfFile.Load(filePath)));
}
catch (Exception ex)
{
_log.Warn($"Libray IxMilia.Dxf failed to load DXF file {filePath} : {ex.Message}");
return(false);
}
}
public void BinaryReaderTest()
{
// this file contains 12 lines
var file = DxfFile.Load("diamond-bin.dxf");
Assert.Equal(12, file.Entities.Count);
Assert.Equal(12, file.Entities.Where(e => e.EntityType == DxfEntityType.Line).Count());
var first = (DxfLine)file.Entities.First();
Assert.Equal(new DxfPoint(45, 45, 0), first.P1);
Assert.Equal(new DxfPoint(45, -45, 0), first.P2);
}
public void SkipBomTest()
{
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
writer.Write((char)0xFEFF); // BOM
writer.Write("0\r\nEOF");
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
var file = DxfFile.Load(stream);
Assert.Equal(0, file.Layers.Count);
}
}
public void IxMiliaReadODATest()
{
// use ODA to convert a minimum-working-file to each of its supported versions and try to open with IxMilia
var exceptions = new List <Exception>();
var versions = new[]
{
DxfAcadVersion.R9,
DxfAcadVersion.R10,
DxfAcadVersion.R12,
DxfAcadVersion.R13,
DxfAcadVersion.R14,
DxfAcadVersion.R2000,
DxfAcadVersion.R2004,
DxfAcadVersion.R2007,
DxfAcadVersion.R2010,
DxfAcadVersion.R2013,
DxfAcadVersion.R2018,
};
foreach (var desiredVersion in versions)
{
using (var input = new ManageTemporaryDirectory())
using (var output = new ManageTemporaryDirectory())
{
var inputDir = input.DirectoryPath;
var outputDir = output.DirectoryPath;
var barePath = Path.Combine(inputDir, "bare.dxf");
File.WriteAllText(barePath, MinimumFileText);
AssertODAConvert(inputDir, outputDir, desiredVersion);
var convertedFilePath = Directory.EnumerateFiles(outputDir, "*.dxf").Single();
using (var fs = new FileStream(convertedFilePath, FileMode.Open))
{
try
{
var file = DxfFile.Load(fs);
Assert.IsType <DxfLine>(file.Entities.Single());
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
}
if (exceptions.Count > 0)
{
throw new AggregateException("Error reading ODA-produced files", exceptions);
}
}
public void IxMiliaReadAutoCadTest()
{
// use AutoCad to convert a minimum-working-file to each of its supported versions and try to open with IxMilia
var exceptions = new List <Exception>();
using (var directory = new ManageTemporaryDirectory())
{
var tempDir = directory.DirectoryPath;
var barePath = Path.Combine(tempDir, "bare.dxf");
File.WriteAllText(barePath, MinimumFileText);
var scriptLines = new List <string>();
scriptLines.Add("FILEDIA 0");
scriptLines.Add($"DXFIN \"{barePath}\"");
foreach (var version in new[] { "R12", "2000", "2004", "2007", "2010", "2013" })
{
var fullPath = Path.Combine(tempDir, $"result-{version}.dxf");
scriptLines.Add($"DXFOUT \"{fullPath}\" V {version} 16");
}
scriptLines.Add("FILEDIA 1");
scriptLines.Add("QUIT Y");
scriptLines.Add("");
var scriptPath = Path.Combine(tempDir, "script.scr");
File.WriteAllLines(scriptPath, scriptLines);
ExecuteAutoCadScript(scriptPath);
foreach (var resultPath in Directory.EnumerateFiles(tempDir, "result-*.dxf"))
{
using (var fs = new FileStream(resultPath, FileMode.Open))
{
try
{
var file = DxfFile.Load(fs);
Assert.IsType <DxfLine>(file.Entities.Single());
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
}
if (exceptions.Count > 0)
{
throw new AggregateException("Error reading AutoCad-produced files", exceptions);
}
}
public void BinaryReaderPostR13Test()
{
var bytes = new List <byte>();
void WriteB(params byte[] bs)
{
foreach (var b in bs)
{
bytes.Add(b);
}
}
void WriteS(string s, bool addTerminator = true)
{
foreach (var c in s)
{
bytes.Add((byte)c);
}
if (addTerminator)
{
bytes.Add(0x00);
}
}
WriteS("AutoCAD Binary DXF\r\n", addTerminator: false);
WriteB(0x1A, 0x00);
WriteB(0x00, 0x00);
WriteS("SECTION");
WriteB(0x02, 0x00);
WriteS("HEADER");
WriteB(0x09, 0x00);
WriteS("$LWDISPLAY");
WriteB(0x22, 0x01);
WriteB(0x01);
WriteB(0x00, 0x00);
WriteS("ENDSEC");
WriteB(0x00, 0x00);
WriteS("EOF");
using (var ms = new MemoryStream())
{
ms.Write(bytes.ToArray(), 0, bytes.Count);
ms.Seek(0, SeekOrigin.Begin);
var file = DxfFile.Load(ms);
Assert.True(file.Header.DisplayLineweightInModelAndLayoutTab);
}
}
public void RoundTripBinaryFileTest(DxfAcadVersion version)
{
var file = new DxfFile();
file.Header.Version = version;
file.Header.CurrentLayer = "current-layer";
using (var ms = new MemoryStream())
{
file.Save(ms, asText: false);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
var roundTripped = DxfFile.Load(ms);
Assert.Equal("current-layer", roundTripped.Header.CurrentLayer);
}
}
public async void VerifyDefaultDxfVersionInWriteTest()
{
using (var ms = new MemoryStream())
{
var drawing = new Drawing();
// write file with defaults
Assert.True(await Workspace.ReaderWriterService.TryWriteDrawing("filename.dxf", drawing, ViewPort.CreateDefaultViewPort(), ms, preserveSettings: false));
// verify that the written default is correct
ms.Seek(0, SeekOrigin.Begin);
var file = DxfFile.Load(ms);
Assert.Equal(DxfAcadVersion.R12, file.Header.Version);
}
}
public void ReadFileWithExplicitNullEncodingTest()
{
// ensure that a `null` text encoding doesn't break file reading
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, Encoding.ASCII))
{
writer.WriteLine(@"
0
EOF
".Trim());
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
var _file = DxfFile.Load(ms, defaultEncoding: null);
}
}
public static bool ReadFile(string fileName, out DxfFile dxfFile)
{
try
{
using (var fs = new FileStream(fileName, FileMode.Open))
{
dxfFile = DxfFile.Load(fs);
return(true);
}
}
catch
{
dxfFile = null;
return(false);
}
}
public void WriteDxbTest()
{
// write file
var file = new DxfFile();
file.Entities.Add(new DxfLine(new DxfPoint(1, 2, 3), new DxfPoint(4, 5, 6)));
var stream = new MemoryStream();
file.SaveDxb(stream);
stream.Seek(0, SeekOrigin.Begin);
// read it back in
var dxb = DxfFile.Load(stream);
var line = (DxfLine)dxb.Entities.Single();
Assert.Equal(new DxfPoint(1, 2, 3), line.P1);
Assert.Equal(new DxfPoint(4, 5, 6), line.P2);
}
public void UseCodePageInNonUnicodeFilesTest()
{
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, Encoding.ASCII))
{
// R2004 means non-Unicode. Characters are handled via $DWGCODEPAGE
var head = @"
0
SECTION
2
HEADER
9
$ACADVER
1
AC1018
9
$DWGCODEPAGE
3
ANSI_1252
9
$PROJECTNAME
1".Trim();
var tail = @"
0
ENDSEC
0
EOF".Trim();
var ansi1252bytes = new byte[]
{
0xDF, // German sharp S
};
writer.WriteLine(head);
writer.Flush();
ms.Write(ansi1252bytes, 0, ansi1252bytes.Length);
writer.WriteLine();
writer.WriteLine(tail);
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
var file = DxfFile.Load(ms, Encoding.ASCII); // force ASCII encoding that $DWGCODEPAGE will override
Assert.Equal("ß", file.Header.ProjectName);
}
}
