Skip to content

armgit / Filee

Public Imported from GitHub
0

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.

19.7 KB
Raw Blame
// 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));
    }
}