Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.
C# audio-converteravaloniabatch-conversionconvertercsharpdocument-converterdocx-to-pdfdotnetdrag-and-dropfile-conversionfile-converterheic-converterhwphwpximage-converterlinuxmacospdf-convertervideo-converterwindows
// DWG / DXF without AutoCAD: DXF ↔ DWG with ACadSharp and the built-in renderer (PDF, SVG, PNG). Drawings are
// generated by CadBuilder; outputs are parsed back (DXF/DWG readers, SVG XML, PDFsharp, pixels).
using System.Xml.Linq;
using ACadSharp;
using ACadSharp.Entities;
using ACadSharp.IO;
using ACadSharp.Tables;
using CSMath;
using Filee.Core.Conversion;
using Filee.Core.Presets;
using Filee.Engines.Cad;
using ImageMagick;
using PdfSharp.Pdf.Content;
using PdfSharp.Pdf.Content.Objects;
using PdfSharp.Pdf.IO;
using SkiaSharp;
namespace Filee.Engines.Tests;
public class CadTests(EngineFixture fx) : IClassFixture<EngineFixture>
{
private async Task<string> ConvertAsync(string input, string target, Preset? preset = null)
{
var job = await fx.ConvertAsync([input], preset ?? new Preset { TargetFormat = target });
Assert.True(job.State == JobState.Completed, string.Join("; ", job.Files.Select(f => $"{f.ErrorKey} {f.ErrorDetail}")));
return job.Outputs.Single();
}
private string SampleDxf() => CadBuilder.SaveDxf(CadBuilder.Sample(), fx.NewFolder(), "도면.dxf");
// ───────────────────────── Routes ─────────────────────────
[Theory]
[InlineData("dwg", "png")]
[InlineData("dwg", "pdf")]
[InlineData("dwg", "svg")]
[InlineData("dwg", "dxf")]
[InlineData("dxf", "dwg")]
[InlineData("dxf", "jpg")]
[InlineData("dxf", "webp")]
public void Cad_formats_are_converted_by_the_cad_engine_in_one_step(string from, string to)
{
var route = fx.Catalog.CreatePlanner().Plan(from, to);
Assert.NotNull(route);
Assert.Equal("cad", Assert.Single(route.Steps).Converter.Id);
}
// ───────────────────────── DXF ↔ DWG ─────────────────────────
[Fact]
public async Task Dxf_to_dwg_and_back_keeps_every_entity()
{
var source = SampleDxf();
var expected = CadBuilder.Census(DxfReader.Read(source));
var dwg = await ConvertAsync(source, "dwg");
Assert.Equal("AC1032"u8.ToArray(), (await File.ReadAllBytesAsync(dwg, TestContext.Current.CancellationToken))[..6]);
var fromDwg = DwgReader.Read(dwg);
Assert.Equal(expected, CadBuilder.Census(fromDwg));
var dxf = await ConvertAsync(dwg, "dxf", new Preset { TargetFormat = "dxf", Output = { FileNamePattern = "{name}_back" } });
var back = DxfReader.Read(dxf);
Assert.Equal(ACadVersion.AC1032, back.Header.Version);
Assert.Equal(expected, CadBuilder.Census(back));
// Content survives, not just the count: Korean text (UTF-8 in 2018 DXF), blocks, attributes, layer states.
Assert.Contains(back.Entities.OfType<TextEntity>(), t => t.Value == CadBuilder.KoreanText);
var bolt = back.Entities.OfType<Insert>().First(i => i.Attributes.Count > 0);
Assert.Equal("BOLT", bolt.Block.Name);
Assert.Equal(2, bolt.Block.Entities.OfType<Circle>().Count() + bolt.Block.Entities.OfType<Line>().Count());
Assert.Equal(["ID=B1", "ID=B2"], fromDwg.Entities.OfType<Insert>().SelectMany(i => i.Attributes).Select(a => $"{a.Tag}={a.Value}"));
Assert.Equal(["ID=B1"], bolt.Attributes.Select(a => $"{a.Tag}={a.Value}"));
Assert.False(back.Layers["Off"].IsOn);
Assert.True(back.Layers["Frozen"].Flags.HasFlag(LayerFlags.Frozen));
}
[Fact]
public async Task Binary_dxf_is_read()
{
var binary = CadBuilder.SaveDxf(CadBuilder.Sample(), fx.NewFolder(), "binary.dxf", binary: true);
Assert.True(DxfReader.IsBinary(binary));
var dwg = await ConvertAsync(binary, "dwg");
Assert.Equal(CadBuilder.Census(DxfReader.Read(binary)), CadBuilder.Census(DwgReader.Read(dwg)));
}
[Fact]
public void Korean_text_in_pre_2007_files_is_decoded()
{
// Before AutoCAD 2007, text is stored in the drawing's code page (CP949 for Korean).
var doc = new CadDocument();
doc.Entities.Add(new TextEntity(CadBuilder.KoreanText) { Height = 2.5 });
doc.Header.Version = ACadVersion.AC1018;
doc.Header.CodePage = "kcs5601";
var dir = fx.NewFolder();
var dwg = Path.Combine(dir, "old.dwg");
DwgWriter.Write(dwg, doc);
Assert.Equal(CadBuilder.KoreanText, CadFile.Read(dwg, "dwg").Entities.OfType<TextEntity>().Single().Value);
// Korean AutoCAD names the code page ANSI_949 in DXF, which ACadSharp does not know by that name.
var dxf = CadBuilder.SaveDxf(doc, dir, "old.dxf");
var bytes = File.ReadAllBytes(dxf);
var header = System.Text.Encoding.ASCII.GetString(bytes);
var at = header.IndexOf("kcs5601", StringComparison.Ordinal);
Assert.True(at > 0);
File.WriteAllBytes(dxf, [.. bytes[..at], .. "ANSI_949"u8.ToArray(), .. bytes[(at + 7)..]]);
Assert.Contains("ANSI_949", File.ReadAllText(dxf, System.Text.Encoding.Latin1));
// ACadSharp alone garbles it; when this starts to pass, CadFile.OpenDxf's workaround can go.
Assert.NotEqual(CadBuilder.KoreanText, DxfReader.Read(dxf).Entities.OfType<TextEntity>().Single().Value);
Assert.Equal(CadBuilder.KoreanText, CadFile.Read(dxf, "dxf").Entities.OfType<TextEntity>().Single().Value);
}
[Theory]
[InlineData("broken.dwg", "not a DWG drawing")]
[InlineData("broken.dxf", "not a valid DXF drawing")]
public async Task Damaged_files_fail_with_a_clear_message(string name, string message)
{
var path = Path.Combine(fx.NewFolder(), name);
await File.WriteAllTextAsync(path, "This is not a drawing.\n0\nSECTION\n", TestContext.Current.CancellationToken);
var job = await fx.ConvertAsync([path], new Preset { TargetFormat = "pdf" });
Assert.Equal(JobState.Failed, job.State);
Assert.Contains(message, job.Files.Single().ErrorDetail, StringComparison.OrdinalIgnoreCase);
}
// ───────────────────────── Rendering ─────────────────────────
[Fact]
public async Task Dxf_to_svg_has_paths_and_text()
{
var svg = XDocument.Load(await ConvertAsync(SampleDxf(), "svg"));
XNamespace ns = "http://www.w3.org/2000/svg";
var root = svg.Root!;
Assert.Equal(ns + "svg", root.Name);
var width = double.Parse(root.Attribute("width")!.Value, System.Globalization.CultureInfo.InvariantCulture);
var height = double.Parse(root.Attribute("height")!.Value, System.Globalization.CultureInfo.InvariantCulture);
Assert.InRange(width, 1500, 1600); // 420 mm at 96 dpi on the long edge
Assert.True(height < width, "a wide drawing gives a landscape page");
var paths = svg.Descendants(ns + "path").ToList();
Assert.True(paths.Count >= 5, $"{paths.Count} paths");
Assert.Contains(paths, p => p.Attribute("stroke")?.Value == "blue");
var text = string.Concat(svg.Descendants(ns + "text").Select(t => t.Value.Trim()));
Assert.Contains("MTEXT", text);
Assert.Contains("B1", text); // the block attribute
Assert.Contains("1/2", text); // stacked fraction
Assert.Contains(CadBuilder.KoreanText.Replace(" ", "", StringComparison.Ordinal), text.Replace(" ", "", StringComparison.Ordinal));
// Entities on the OFF and frozen layers are red: nothing red may appear.
Assert.DoesNotContain(svg.Descendants(), e => e.Attribute("stroke")?.Value == "red" || e.Attribute("fill")?.Value == "red");
}
[Fact]
public async Task Dxf_to_pdf_is_one_vector_page()
{
var pdf = await ConvertAsync(SampleDxf(), "pdf");
using var document = PdfReader.Open(pdf, PdfDocumentOpenMode.Import);
Assert.Equal(1, document.PageCount);
var page = document.Pages[0];
// A3 landscape: 420 × 297 mm.
Assert.Equal(420 / 25.4 * 72, page.Width.Point, 0.5);
Assert.Equal(297 / 25.4 * 72, page.Height.Point, 0.5);
var operators = Operators(ContentReader.ReadContent(page)).ToList();
Assert.Contains(OpCodeName.l, operators); // lines
Assert.Contains(OpCodeName.c, operators); // curves (circle, arc, bulge)
Assert.True(operators.Contains(OpCodeName.f) || operators.Contains(OpCodeName.fx), "the solid hatch is a filled path");
Assert.True(operators.Contains(OpCodeName.Tj) || operators.Contains(OpCodeName.TJ), "text is real text");
Assert.DoesNotContain(OpCodeName.BI, operators); // no inline raster images
}
[Fact]
public async Task Dxf_to_png_draws_the_visible_layers_only()
{
var png = await ConvertAsync(SampleDxf(), "png");
using var image = new MagickImage(png);
Assert.Equal(2480u, Math.Max(image.Width, image.Height)); // A3 long edge at 150 dpi
var (ink, blue, red, _) = CountPixels(image);
Assert.True(ink > 5000, $"{ink} drawn pixels");
Assert.True(blue > 1000, $"{blue} blue pixels");
Assert.Equal(0, red);
}
[Fact]
public async Task A_drawing_far_from_the_origin_still_fills_the_page()
{
// The header claims the drawing spans (0,0)-(10,10); the page must be fitted to the real entities.
var source = CadBuilder.SaveDxf(CadBuilder.FarFromOrigin(), fx.NewFolder(), "far.dxf");
var png = await ConvertAsync(source, "png", new Preset { TargetFormat = "png", Pdf = { RenderDpi = 50 } });
using var image = new MagickImage(png);
var (_, _, _, box) = CountPixels(image);
Assert.True(box.Width > image.Width * 0.9, $"drawing spans {box.Width} of {image.Width} px");
Assert.True(box.Height > image.Height * 0.8, $"drawing spans {box.Height} of {image.Height} px");
Assert.InRange(image.Width / (double)image.Height, 1.8, 2.2); // the page has the drawing's 2:1 aspect
}
[Fact]
public async Task Dxf_to_other_image_formats_applies_image_options()
{
var jpg = await ConvertAsync(SampleDxf(), "jpg", new Preset { TargetFormat = "jpg", Image = { Resize = ResizeMode.LongEdge, LongEdge = 800, Quality = 80 } });
using var image = new MagickImage(jpg);
Assert.Equal(MagickFormat.Jpeg, image.Format);
Assert.Equal(800u, Math.Max(image.Width, image.Height));
}
// ───────────────────────── Scene details ─────────────────────────
[Fact]
public void Layer_zero_in_a_block_follows_the_insert_layer()
{
// AutoCAD: an insert on an OFF layer hides the block's layer-0 entities, but entities on their own
// (visible) layer stay; an insert on a frozen layer hides everything.
var doc = new CadDocument();
var off = new Layer("Off") { IsOn = false };
var frozen = new Layer("Frozen") { Flags = LayerFlags.Frozen };
var own = new Layer("Own") { Color = CadBuilder.Visible };
doc.Layers.Add(off);
doc.Layers.Add(frozen);
doc.Layers.Add(own);
var block = new BlockRecord("B");
block.Entities.Add(new Line(new XYZ(0, 0, 0), new XYZ(10, 0, 0)));
block.Entities.Add(new Line(new XYZ(0, 5, 0), new XYZ(10, 5, 0)) { Layer = own });
doc.BlockRecords.Add(block);
CadBuilder.Add(doc, off, new Insert(block));
CadBuilder.Add(doc, frozen, new Insert(block) { InsertPoint = new XYZ(0, 100, 0) });
var scene = CadSceneBuilder.Build(doc, TestContext.Current.CancellationToken);
var stroke = Assert.IsType<StrokePrimitive>(Assert.Single(scene.Items));
Assert.Equal(new SKColor(0, 0, 255), stroke.Color);
Assert.Equal(5, stroke.Figures.Single().Start.Y, 9);
}
[Fact]
public void Inserts_apply_base_point_scale_rotation_and_arrays()
{
var doc = new CadDocument();
var block = new BlockRecord("Square");
block.BlockEntity.BasePoint = new XYZ(1, 1, 0);
var square = new LwPolyline(new LwPolyline.Vertex(1, 1), new LwPolyline.Vertex(2, 1), new LwPolyline.Vertex(2, 2), new LwPolyline.Vertex(1, 2)) { IsClosed = true };
block.Entities.Add(square);
doc.BlockRecords.Add(block);
// Base point (1,1) lands on (10,10); scaled ×2 and turned 90°, the unit square covers x 8..10, y 10..12 ...
doc.Entities.Add(new Insert(block) { InsertPoint = new XYZ(10, 10, 0), XScale = 2, YScale = 2, Rotation = Math.PI / 2 });
// ... and a 2 × 3 array (column spacing 10, row spacing 20) of the plain square from (100,0).
doc.Entities.Add(new Insert(block) { InsertPoint = new XYZ(100, 0, 0), ColumnCount = 3, RowCount = 2, ColumnSpacing = 10, RowSpacing = 20 });
var scene = CadSceneBuilder.Build(doc, TestContext.Current.CancellationToken);
Assert.Equal(7, scene.Items.Count);
var first = Bounds(scene.Items[0]);
Assert.Equal((8.0, 10.0, 10.0, 12.0), (Math.Round(first.MinX, 9), Math.Round(first.MinY, 9), Math.Round(first.MaxX, 9), Math.Round(first.MaxY, 9)));
Assert.Equal(8, scene.Extents.MinX, 9);
Assert.Equal(121, scene.Extents.MaxX, 9); // last column at 100 + 2·10, one unit wide
Assert.Equal(21, scene.Extents.MaxY, 9); // second row at 20
}
[Fact]
public void Dimensions_draw_their_block_with_the_measurement()
{
var scene = CadSceneBuilder.Build(CadBuilder.Sample(), TestContext.Current.CancellationToken);
var texts = scene.Items.OfType<TextPrimitive>().Select(t => t.Text).ToList();
Assert.Contains(texts, t => t.Contains("100", StringComparison.Ordinal)); // the aligned dimension's value
Assert.True(scene.Items.OfType<FillPrimitive>().Count() >= 3, "the solid hatch and two arrowheads");
Assert.Empty(scene.Skipped);
Assert.False(scene.Truncated);
}
[Fact]
public void Line_types_and_pattern_hatches_are_drawn()
{
var scene = CadSceneBuilder.Build(CadBuilder.Sample(), TestContext.Current.CancellationToken);
var dashed = Assert.Single(scene.Items.OfType<StrokePrimitive>(), s => s.Dashes is not null);
Assert.Equal([5.0, -2.5], dashed.Dashes!);
// 45° lines 2 units apart across a 20 × 20 square (28.3 units across its diagonal): about 15 lines,
// generated over the bounding box and clipped to the boundary when drawn.
var hatch = Assert.Single(scene.Items.OfType<HatchLinesPrimitive>());
Assert.InRange(hatch.Lines.Count, 14, 18);
Assert.Single(hatch.Boundary);
// The clamped spline runs from its first to its last control point and stays inside their hull
// (lowest point of this Bézier at y ≈ -22.89); the ellipse arc runs three quarters from its major axis end.
var figures = scene.Items.OfType<StrokePrimitive>().SelectMany(s => s.Figures).ToList();
var spline = Assert.Single(figures, f => f.Start == new Vec2(0, -20));
Assert.Equal(60, spline.End.X, 9);
Assert.Equal(-20, spline.End.Y, 9);
var splineBox = Box2.Empty;
spline.AddTo(ref splineBox);
Assert.InRange(splineBox.MinY, -22.89, -22.85);
var ellipse = Assert.Single(figures, f => f.Start == new Vec2(97, -20));
Assert.Equal(85, ellipse.End.X, 9);
Assert.Equal(-26, ellipse.End.Y, 9);
}
[Fact]
public void Mtext_formatting_codes_are_decoded()
{
var format = new MTextFormat(2, null, null, null, false, false, 1, 0);
var paragraphs = CadTextCodes.ParseMText("{\\fArial|b1|i0;Bold} \\H3x;Big\\Pline \\S1/2; %%d \\U+AC00\\~end", format);
Assert.Equal(2, paragraphs.Count);
Assert.Equal("Bold", paragraphs[0][0].Text);
Assert.True(paragraphs[0][0].Format.Bold);
Assert.Equal("Arial", paragraphs[0][0].Format.FontFamily);
Assert.Equal(6, paragraphs[0][^1].Format.Height); // \H3x of 2
Assert.Equal("line 1/2 ° 가\u00A0end", string.Concat(paragraphs[1].Select(r => r.Text)));
Assert.Equal("Ø25 ±0.1 45°", CadTextCodes.DecodeText("%%c25 %%p0.1 45%%d"));
}
[Fact]
public void Rational_spline_reproduces_a_circle()
{
// A quarter circle as a rational quadratic B-spline (weights 1, √2/2, 1).
var points = CadCurves.SampleNurbs(2, [new Vec3(1, 0, 0), new Vec3(1, 1, 0), new Vec3(0, 1, 0)], [0, 0, 0, 1, 1, 1], [1, Math.Sqrt(0.5), 1]);
Assert.True(points.Count > 5);
Assert.All(points, p => Assert.Equal(1, Math.Sqrt(p.X * p.X + p.Y * p.Y), 9));
Assert.Equal(new Vec3(0, 1, 0), points[^1]);
}
[Fact]
public void Bulge_arcs_follow_the_autocad_convention()
{
// Bulge 1 = counter-clockwise half circle; the centre lies halfway.
var (center, radius, start, sweep) = CadCurves.BulgeArc(new Vec2(0, 0), new Vec2(10, 0), 1);
Assert.Equal(5, center.X, 9);
Assert.Equal(0, center.Y, 9);
Assert.Equal(5, radius, 9);
Assert.Equal(Math.PI, Math.Abs(start), 9);
Assert.Equal(Math.PI, sweep, 9);
}
[Fact]
public void Korean_text_uses_a_font_with_hangul()
{
var primary = CadFonts.Resolve(null, false, false);
var runs = CadFonts.Layout("도면 ABC", primary);
var hangul = runs.First(r => r.Text.Contains('도'));
Assert.SkipUnless(hangul.Typeface.ContainsGlyph('도'), "no font with Hangul on this machine");
Assert.True(hangul.Advance > 0);
Assert.Contains(runs, r => r.Text.Contains('A') && r.Typeface.ContainsGlyph('A'));
}
[Fact]
public void Text_measures_the_same_after_the_idle_app_released_the_caches()
{
var before = CadFonts.Layout("도면 ABC", CadFonts.Resolve(null, false, false)).Select(r => (r.Text, r.Advance)).ToList();
Filee.Engines.Infrastructure.EngineCaches.Release();
var after = CadFonts.Layout("도면 ABC", CadFonts.Resolve(null, false, false)).Select(r => (r.Text, r.Advance)).ToList();
Assert.Equal(before, after);
}
// ───────────────────────── Helpers ─────────────────────────
private static IEnumerable<OpCodeName> Operators(CSequence sequence)
{
foreach (var item in sequence)
{
if (item is COperator op)
yield return op.OpCode.OpCodeName;
else if (item is CSequence inner)
foreach (var nested in Operators(inner))
yield return nested;
}
}
private static Box2 Bounds(ScenePrimitive primitive)
{
var box = Box2.Empty;
foreach (var figure in ((StrokePrimitive)primitive).Figures)
figure.AddTo(ref box);
return box;
}
/// <summary>Drawn (not white), blue and red pixels plus the bounding box of everything drawn.</summary>
private static (int Ink, int Blue, int Red, (int Width, int Height) Box) CountPixels(MagickImage image)
{
using var pixels = image.GetPixels();
var bytes = pixels.ToByteArray(PixelMapping.RGB)!;
int ink = 0, blue = 0, red = 0;
int minX = int.MaxValue, minY = int.MaxValue, maxX = -1, maxY = -1;
var width = (int)image.Width;
for (var i = 0; i < bytes.Length; i += 3)
{
int r = bytes[i], g = bytes[i + 1], b = bytes[i + 2];
if (r > 240 && g > 240 && b > 240)
continue;
var x = i / 3 % width;
var y = i / 3 / width;
(minX, minY, maxX, maxY) = (Math.Min(minX, x), Math.Min(minY, y), Math.Max(maxX, x), Math.Max(maxY, y));
ink++;
if (b > 150 && r < 100 && g < 100)
blue++;
if (r > 150 && g < 100 && b < 100)
red++;
}
return (ink, blue, red, maxX < 0 ? (0, 0) : (maxX - minX + 1, maxY - minY + 1));
}
}