Fix SVG fill import and round-trip export

Author: tomasf

Sources/Cadova/Abstract Layer/Import/2D/GeometrySVGConsumer.swift

@@ -107,7 +107,7 @@ internal final class ShapeExtractionRenderer: SVGRenderer {
         let fillRule = FillRule(from: rule)
         var polygons: [SimplePolygon] = []
 
-        for subpath in finishedPath.subpaths where subpath.isClosed {
+        for subpath in finishedPath.subpaths {
             let points = subpath.bezierPath.points(segmentation: segmentation)
             if points.count >= 3 {
                 polygons.append(SimplePolygon(points))

Sources/Cadova/Concrete Layer/Output Providers/SVGDataProvider.swift

@@ -15,9 +15,9 @@ struct SVGDataProvider: OutputDataProvider {
 
         let document = Document()
         let svg = document.makeDocumentElement(name: "svg", defaultNamespace: "http://www.w3.org/2000/svg")
-        svg[attribute: "viewBox"] = String(format: "%g %g %g %g",
-                                           bounds.minimum.x, bounds.minimum.y,
-                                           bounds.size.x, bounds.size.y)
+        svg[attribute: "width"] = String(format: "%g", bounds.size.x)
+        svg[attribute: "height"] = String(format: "%g", bounds.size.y)
+        svg[attribute: "viewBox"] = String(format: "%g %g %g %g", 0.0, 0.0, bounds.size.x, bounds.size.y)
 
         let metadata = options[Metadata.self]
         if let title = metadata.title {
@@ -29,10 +29,11 @@ struct SVGDataProvider: OutputDataProvider {
 
         let path = svg.addElement("path")
         path[attribute: "fill"] = "black"
+        path[attribute: "fill-rule"] = "nonzero"
         path[attribute: "d"] = shapePoints.map {
             "M " + $0.vertices.map {
-                String(format: "%g,%g", $0.x, $0.y)
-            }.joined(separator: " ")
+                String(format: "%g,%g", $0.x - bounds.minimum.x, $0.y - bounds.minimum.y)
+            }.joined(separator: " ") + " Z"
         }.joined(separator: " ")
 
         return try document.xmlData()

Tests/Tests/Import.swift

@@ -100,4 +100,32 @@ struct ImportTests {
             Issue.record("Unexpected error type: \(type(of: error)) - \(error)")
         }
     }
+
+    @Test func `SVG export and import preserves geometry`() async throws {
+        let geometry: any Geometry2D = Rectangle(x: 20, y: 10)
+            .subtracting {
+                Rectangle(x: 5, y: 4)
+                    .translated(x: 10, y: 3)
+            }
+
+        let originalMeasurements = try await geometry.measurements
+
+        let tempURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("cadova-test-\(UUID().uuidString).svg")
+        defer { try? FileManager.default.removeItem(at: tempURL) }
+
+        let context = EvaluationContext()
+        let result = try await context.buildResult(for: geometry.withDefaultSegmentation(), in: .defaultEnvironment)
+        let provider = SVGDataProvider(result: result, options: [])
+        try await provider.writeOutput(to: tempURL, context: context)
+
+        let importedGeometry = Import(svg: tempURL, scale: .pixels)
+        let importedMeasurements = try await importedGeometry.measurements
+        let symmetricDifferenceArea = try await importedGeometry.symmetricDifferenceArea(with: geometry)
+
+        #expect(importedMeasurements.area ≈ originalMeasurements.area)
+        #expect(importedMeasurements.contourCount == originalMeasurements.contourCount)
+        #expect(importedMeasurements.boundingBox ≈ originalMeasurements.boundingBox)
+        #expect(symmetricDifferenceArea.equals(0, within: 1e-6))
+    }
 }

Tests/Tests/SVGImport.swift

@@ -25,6 +25,24 @@ struct SVGImportTests {
         #expect(bounds!.maximum ≈ [11, 21])
     }
 
+    @Test func `SVG import fills open paths by implicitly closing them`() async throws {
+        let svg = """
+        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20">
+          <path d="M0 0 L10 0 L10 10" fill="black" />
+        </svg>
+        """
+
+        let geometry = Import(svg: Data(svg.utf8), scale: .pixels)
+        let measurements = try await geometry.measurements
+        let bounds = try await geometry.bounds
+
+        #expect(measurements.area.equals(50, within: 0.05))
+        #expect(measurements.contourCount == 1)
+        #expect(bounds != nil)
+        #expect(bounds!.minimum ≈ [0, 10])
+        #expect(bounds!.maximum ≈ [10, 20])
+    }
+
     @Test func `SVG import converts text`() async throws {
         let url = Bundle.module.url(forResource: "svg_text", withExtension: "svg", subdirectory: "resources")!
         let geometry = Import(svg: url, scale: .pixels)