Update comparison reports and images for MiniPdf vs Reference PDF

- Updated the generated timestamps in comparison reports for both DOCX and XLSX formats.
- Improved scores and visual comparisons for the "SA8000 ch sample" and "Expense report basic1" entries.
- Added new images for "SA8000 ch sample" and "Weekly schedule planner1" comparisons.
- Enhanced the pixel comparison algorithm in `compare_pdfs.py` to resize images for better accuracy.
- Added a new entry for "Weekly schedule planner1" in the XLSX report with detailed results.
- Adjusted overall average scores in both reports based on updated visual scores.

Author: shps951023

MiniPdf.Api/Program.cs

@@ -5,11 +5,16 @@
 foreach (var dir in new[] { "/home/fonts", Path.Combine(AppContext.BaseDirectory, "Fonts") })
 {
     if (!Directory.Exists(dir)) continue;
-    foreach (var file in Directory.GetFiles(dir, "*.ttf"))
-    {
-        var name = Path.GetFileNameWithoutExtension(file);
-        MiniPdf.RegisterFont(name, File.ReadAllBytes(file));
-    }
+    foreach (var ext in new[] { "*.ttf", "*.ttc", "*.otf" })
+        foreach (var file in Directory.GetFiles(dir, ext))
+        {
+            try
+            {
+                var name = Path.GetFileNameWithoutExtension(file);
+                MiniPdf.RegisterFont(name, File.ReadAllBytes(file));
+            }
+            catch { /* skip fonts that fail to parse */ }
+        }
 }
 
 var builder = WebApplication.CreateBuilder(args);

MiniPdf.Api/startup.sh

@@ -4,8 +4,11 @@
 # /home/ is persistent storage on Azure App Service Linux.
 
 FONT_DIR="/home/fonts"
+FONT_COUNT=$(find "$FONT_DIR" -maxdepth 1 -name '*.ttf' -o -name '*.ttc' 2>/dev/null | wc -l)
 
-if [ ! -f "$FONT_DIR/.done" ]; then
+if [ "$FONT_COUNT" -ge 10 ]; then
+    echo "[startup] Found $FONT_COUNT fonts in $FONT_DIR (uploaded), skipping download."
+elif [ ! -f "$FONT_DIR/.done" ]; then
     echo "[startup] Downloading fonts to $FONT_DIR ..."
     mkdir -p "$FONT_DIR"
 

src/MiniPdf/ExcelReader.cs

@@ -314,6 +314,7 @@ private static void RenderSheet(PdfDocument doc, ExcelSheet sheet, ConversionOpt
                     columnWidths: sheet.ColumnWidths,
                     defaultColumnWidth: sheet.DefaultColumnWidth,
                     charts: sheet.Charts.Count > 0 ? sheet.Charts : null,
+                    shapes: sheet.Shapes.Count > 0 ? sheet.Shapes : null,
                     mergedCells: sheet.MergedCells,
                     rowHeights: sheet.RowHeights,
                     defaultRowHeight: sheet.DefaultRowHeight,
@@ -372,6 +373,7 @@ private static void RenderSheet(PdfDocument doc, ExcelSheet sheet, ConversionOpt
                                 images: sheet.Images.Count > 0 ? sheet.Images : null,
                                 columnWidths: sheet.ColumnWidths, defaultColumnWidth: sheet.DefaultColumnWidth,
                                 charts: sheet.Charts.Count > 0 ? sheet.Charts : null,
+                                shapes: sheet.Shapes.Count > 0 ? sheet.Shapes : null,
                                 mergedCells: sheet.MergedCells, rowHeights: sheet.RowHeights,
                                 defaultRowHeight: sheet.DefaultRowHeight, customHeightRows: sheet.CustomHeightRows,
                                 isLandscape: sheet.IsLandscape, printScale: combined2, paperSize: sheet.PaperSize,
@@ -566,6 +568,7 @@ private static void RenderSheet(PdfDocument doc, ExcelSheet sheet, ConversionOpt
                 columnWidths: trimmedColWidths,
                 defaultColumnWidth: sheet.DefaultColumnWidth,
                 charts: trimmedCharts.Count > 0 ? trimmedCharts : null,
+                shapes: sheet.Shapes.Count > 0 ? sheet.Shapes : null,
                 mergedCells: trimmedMerged,
                 rowHeights: trimmedRowHeights,
                 defaultRowHeight: sheet.DefaultRowHeight,
@@ -1688,25 +1691,25 @@ float RenderPrintTitleRows()
                     {
                         var bc = border.Left.Color ?? borderColor;
                         var bw = Math.Max(0.08f, BorderStyleWidth(border.Left.Style) * borderScaleFactor);
-                        currentPage!.AddLine(bx, byTop, bx, byBottom, bc, bw);
+                        currentPage!.AddLine(bx, byTop, bx, byBottom, bc, bw, BorderDashPattern(border.Left.Style, bw));
                     }
                     if (border.Right is { Style: not "none" and not "" })
                     {
                         var bc = border.Right.Color ?? borderColor;
                         var bw = Math.Max(0.08f, BorderStyleWidth(border.Right.Style) * borderScaleFactor);
-                        currentPage!.AddLine(bxRight, byTop, bxRight, byBottom, bc, bw);
+                        currentPage!.AddLine(bxRight, byTop, bxRight, byBottom, bc, bw, BorderDashPattern(border.Right.Style, bw));
                     }
                     if (border.Top is { Style: not "none" and not "" })
                     {
                         var bc = border.Top.Color ?? borderColor;
                         var bw = Math.Max(0.08f, BorderStyleWidth(border.Top.Style) * borderScaleFactor);
-                        currentPage!.AddLine(bx, byTop, bxRight, byTop, bc, bw);
+                        currentPage!.AddLine(bx, byTop, bxRight, byTop, bc, bw, BorderDashPattern(border.Top.Style, bw));
                     }
                     if (border.Bottom is { Style: not "none" and not "" })
                     {
                         var bc = border.Bottom.Color ?? borderColor;
                         var bw = Math.Max(0.08f, BorderStyleWidth(border.Bottom.Style) * borderScaleFactor);
-                        currentPage!.AddLine(bx, byBottom, bxRight, byBottom, bc, bw);
+                        currentPage!.AddLine(bx, byBottom, bxRight, byBottom, bc, bw, BorderDashPattern(border.Bottom.Style, bw));
                     }
                 }
 
@@ -1796,6 +1799,55 @@ float RenderPrintTitleRows()
 
         // (Trailing empty page logic moved to RenderSheet for proper per-sheet page tracking)
 
+        // Place drawing shapes (rectangles used as decorative frames)
+        const float ShapeEmuToPt = 1f / 12700f;
+        foreach (var shape in sheet.Shapes)
+        {
+            // Resolve anchor positions using rowTopY and colXStarts
+            if (!rowTopY.TryGetValue(shape.FromRow, out var shapeTop))
+                continue;
+            if (!rowTopY.TryGetValue(shape.ToRow, out var shapeBot))
+            {
+                // If toRow is beyond rendered rows, use bottom margin
+                shapeBot = options.MarginBottom;
+            }
+
+            // Determine which column group the shape's from-column falls into
+            var fromIdx = Array.IndexOf(columns, shape.FromCol);
+            if (fromIdx < 0) fromIdx = 0;
+            var toIdx = Array.IndexOf(columns, shape.ToCol);
+            if (toIdx < 0) toIdx = columns.Length - 1;
+
+            var shapeX = colXStarts[fromIdx] + shape.FromColOffEmu * ShapeEmuToPt;
+            var shapeXRight = toIdx < colXStarts.Length ?
+                colXStarts[toIdx] + shape.ToColOffEmu * ShapeEmuToPt :
+                colXStarts[^1] + colWidths[^1];
+
+            // Adjust for row offsets
+            shapeTop -= shape.FromRowOffEmu * ShapeEmuToPt;
+            shapeBot -= shape.ToRowOffEmu * ShapeEmuToPt;
+
+            var shapeW = shapeXRight - shapeX;
+            var shapeH = shapeTop - shapeBot;
+            if (shapeW <= 0 || shapeH <= 0) continue;
+
+            var shapePage = rowPage.TryGetValue(shape.FromRow, out var sp) ? sp : currentPage!;
+
+            // Render fill
+            if (shape.FillColor is { } fc)
+                shapePage.AddRectangle(shapeX, shapeBot, shapeW, shapeH, fc);
+
+            // Render border
+            if (shape.BorderColor is { } bc && shape.BorderWidthPt > 0)
+            {
+                var bw = shape.BorderWidthPt;
+                shapePage.AddLine(shapeX, shapeTop, shapeXRight, shapeTop, bc, bw);         // top
+                shapePage.AddLine(shapeX, shapeBot, shapeXRight, shapeBot, bc, bw);         // bottom
+                shapePage.AddLine(shapeX, shapeTop, shapeX, shapeBot, bc, bw);              // left
+                shapePage.AddLine(shapeXRight, shapeTop, shapeXRight, shapeBot, bc, bw);    // right
+            }
+        }
+
         // Place embedded images and chart placeholders
         if (sheet.Images.Count == 0 && sheet.Charts.Count == 0) return;
 
@@ -3291,8 +3343,22 @@ private static bool ShouldUsePdfBold(bool requestedBold, float fontSize, string?
     {
         "thick" => 1.5f,
         "medium" or "mediumDashed" or "mediumDashDot" or "mediumDashDotDot" => 1f,
-        "hair" => 0.1f,
-        _ => 0.3f // thin, dashed, dotted, dashDot, dashDotDot, double, slantDashDot
+        "dotted" or "hair" => 0.1f,
+        _ => 0.3f // thin, dashed, dashDot, dashDotDot, double, slantDashDot
+    };
+
+    /// <summary>
+    /// Maps OOXML border style names to PDF dash patterns.
+    /// Returns null for solid lines.
+    /// </summary>
+    private static float[]? BorderDashPattern(string style, float lineWidth) => style switch
+    {
+        "dotted" => new[] { 0.2f, 0.8f },
+        "dashed" or "mediumDashed" => new[] { 4f, 2f },
+        "dashDot" or "mediumDashDot" or "slantDashDot" => new[] { 4f, 1.5f, Math.Max(0.5f, lineWidth), 1.5f },
+        "dashDotDot" or "mediumDashDotDot" => new[] { 4f, 1f, Math.Max(0.5f, lineWidth), 1f, Math.Max(0.5f, lineWidth), 1f },
+        "hair" => new[] { 0.5f, 0.5f },
+        _ => null // solid: thin, medium, thick
     };
 
     /// <summary>

src/MiniPdf/ExcelToPdfConverter.cs

@@ -61,7 +61,8 @@ internal sealed record PdfLineBlock(
     float X2,            // end X in points
     float Y2,            // end Y in points
     PdfColor Color,      // stroke color
-    float LineWidth = 1f // stroke width in points
+    float LineWidth = 1f, // stroke width in points
+    float[]? DashPattern = null // PDF dash array (e.g. [1,1] for dotted, [3,3] for dashed)
 );
 
 /// <summary>
@@ -209,9 +210,9 @@ public PdfPage AddCompoundPolygon(List<List<PdfPoint>> subpaths, PdfColor? fillC
     /// <summary>
     /// Adds a line segment at the specified coordinates.
     /// </summary>
-    public PdfPage AddLine(float x1, float y1, float x2, float y2, PdfColor? color = null, float lineWidth = 1f)
+    public PdfPage AddLine(float x1, float y1, float x2, float y2, PdfColor? color = null, float lineWidth = 1f, float[]? dashPattern = null)
     {
-        _lineBlocks.Add(new PdfLineBlock(x1, y1, x2, y2, color ?? new PdfColor(0, 0, 0), lineWidth));
+        _lineBlocks.Add(new PdfLineBlock(x1, y1, x2, y2, color ?? new PdfColor(0, 0, 0), lineWidth, dashPattern));
         return this;
     }
 

src/MiniPdf/PdfPage.cs

@@ -758,6 +758,20 @@ private static string BuildContentStream(PdfPage page, bool hasUnicodeFont, Dict
             var ly2 = line.Y2.ToString("F3", CultureInfo.InvariantCulture);
             sb.Append($"{lr} {lg} {lb} RG\n");
             sb.Append($"{lw} w\n");
+            if (line.DashPattern is { Length: > 0 })
+            {
+                sb.Append('[');
+                for (var di = 0; di < line.DashPattern.Length; di++)
+                {
+                    if (di > 0) sb.Append(' ');
+                    sb.Append(line.DashPattern[di].ToString("F1", CultureInfo.InvariantCulture));
+                }
+                sb.Append("] 0 d\n");
+            }
+            else
+            {
+                sb.Append("[] 0 d\n");
+            }
             sb.Append($"{lx1} {ly1} m\n");
             sb.Append($"{lx2} {ly2} l\n");
             sb.Append("S\n");
@@ -1269,7 +1283,21 @@ private static bool IsRgbaPng(byte[] data)
     {
         if (data.Length < 26) return false;
         if (!data.AsSpan(0, 8).SequenceEqual(PngSignature.AsSpan())) return false;
-        return data[24] == 8 && data[25] == 6; // 8-bit RGBA
+        if (data[24] == 8 && data[25] == 6) return true; // 8-bit RGBA
+        // Palette PNG with tRNS chunk also has alpha
+        if (data[25] == 3)
+        {
+            var pos = 8;
+            while (pos + 12 <= data.Length)
+            {
+                var chunkLen = (data[pos] << 24) | (data[pos + 1] << 16) | (data[pos + 2] << 8) | data[pos + 3];
+                var chunkType = Encoding.ASCII.GetString(data, pos + 4, 4);
+                if (chunkType == "tRNS") return true;
+                if (chunkType == "IEND") break;
+                pos += 12 + chunkLen;
+            }
+        }
+        return false;
     }
 
     private static bool TryDecodePngToRgb(byte[] data, out int width, out int height, out byte[] rgb, out byte[]? alpha)
@@ -1285,26 +1313,46 @@ private static bool TryDecodePngToRgb(byte[] data, out int width, out int height
         height = (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23];
         var bitDepth  = data[24];
         var colorType = data[25];
-        // Supported: RGB (2) with 8-bit depth, RGBA (6) with 8-bit depth
-        if (bitDepth != 8 || colorType is not (2 or 6))
-            return false;
+        // Supported: RGB (2) 8-bit, RGBA (6) 8-bit, Indexed (3) 1/2/4/8-bit
+        if (colorType == 3)
+        {
+            if (bitDepth is not (1 or 2 or 4 or 8)) return false;
+        }
+        else
+        {
+            if (bitDepth != 8 || colorType is not (2 or 6)) return false;
+        }
 
-        int channels = colorType == 6 ? 4 : 3;
+        int channels = colorType == 6 ? 4 : colorType == 2 ? 3 : 1; // palette uses 1 byte per pixel (at 8-bit)
 
-        // Collect all IDAT chunks and concatenate their compressed data
+        // Collect IDAT data and palette/transparency chunks
         using var idatStream = new System.IO.MemoryStream();
+        byte[]? palette = null;
+        byte[]? trns = null;
         var pos = 8;
         while (pos + 12 <= data.Length)
         {
             var chunkLen = (data[pos] << 24) | (data[pos + 1] << 16) | (data[pos + 2] << 8) | data[pos + 3];
             var chunkType = Encoding.ASCII.GetString(data, pos + 4, 4);
             if (chunkType == "IDAT")
                 idatStream.Write(data, pos + 8, chunkLen);
+            else if (chunkType == "PLTE")
+            {
+                palette = new byte[chunkLen];
+                Array.Copy(data, pos + 8, palette, 0, chunkLen);
+            }
+            else if (chunkType == "tRNS")
+            {
+                trns = new byte[chunkLen];
+                Array.Copy(data, pos + 8, trns, 0, chunkLen);
+            }
             else if (chunkType == "IEND")
                 break;
             pos += 12 + chunkLen;
         }
 
+        if (colorType == 3 && palette == null) return false; // palette PNG requires PLTE
+
         // zlib-compressed data: skip 2-byte zlib header, decompress raw deflate
         var compressed = idatStream.ToArray();
         if (compressed.Length < 3) return false;
@@ -1323,11 +1371,18 @@ private static bool TryDecodePngToRgb(byte[] data, out int width, out int height
             return false;
         }
 
-        // Apply PNG row filters to get raw RGB data
-        var stride = width * channels;
+        // Apply PNG row filters to get raw pixel data
+        // For palette images, stride is bytes per row of indexed data (may pack multiple pixels per byte)
+        int stride;
+        if (colorType == 3)
+            stride = (width * bitDepth + 7) / 8; // bits per pixel, packed
+        else
+            stride = width * channels;
         var outputRgb = new byte[width * height * 3];
-        byte[]? outputAlpha = channels == 4 ? new byte[width * height] : null;
+        byte[]? outputAlpha = (channels == 4 || (colorType == 3 && trns != null)) ? new byte[width * height] : null;
         var prevRow = new byte[stride];
+        // For palette filtering, the filter unit is 1 byte (regardless of sub-byte packing)
+        var filterUnit = colorType == 3 ? 1 : channels;
 
         for (var row = 0; row < height; row++)
         {
@@ -1343,7 +1398,7 @@ private static bool TryDecodePngToRgb(byte[] data, out int width, out int height
                     break;
                 case 1: // Sub
                     for (var x = 0; x < stride; x++)
-                        cur[x] = (byte)(raw[x] + (x >= channels ? cur[x - channels] : 0));
+                        cur[x] = (byte)(raw[x] + (x >= filterUnit ? cur[x - filterUnit] : 0));
                     break;
                 case 2: // Up
                     for (var x = 0; x < stride; x++)
@@ -1352,16 +1407,16 @@ private static bool TryDecodePngToRgb(byte[] data, out int width, out int height
                 case 3: // Average
                     for (var x = 0; x < stride; x++)
                     {
-                        var a = x >= channels ? cur[x - channels] : 0;
+                        var a = x >= filterUnit ? cur[x - filterUnit] : 0;
                         cur[x] = (byte)(raw[x] + (a + prevRow[x]) / 2);
                     }
                     break;
                 case 4: // Paeth
                     for (var x = 0; x < stride; x++)
                     {
-                        var a = x >= channels ? cur[x - channels] : 0;
+                        var a = x >= filterUnit ? cur[x - filterUnit] : 0;
                         var b = prevRow[x];
-                        var c = x >= channels ? prevRow[x - channels] : 0;
+                        var c = x >= filterUnit ? prevRow[x - filterUnit] : 0;
                         cur[x] = (byte)(raw[x] + PaethPredictor(a, b, c));
                     }
                     break;
@@ -1370,15 +1425,46 @@ private static bool TryDecodePngToRgb(byte[] data, out int width, out int height
                     break;
             }
 
-            // Convert to RGB; extract alpha channel separately if RGBA
+            // Convert to RGB; handle palette mapping for indexed color
             var outBase = row * width * 3;
-            for (var px = 0; px < width; px++)
+            if (colorType == 3)
+            {
+                // Palette: each pixel is an index into the PLTE table
+                for (var px = 0; px < width; px++)
+                {
+                    int idx;
+                    if (bitDepth == 8)
+                        idx = cur[px];
+                    else
+                    {
+                        // Sub-byte packing: extract the pixel index from packed bytes
+                        var pixelsPerByte = 8 / bitDepth;
+                        var byteIdx = px / pixelsPerByte;
+                        var bitShift = (pixelsPerByte - 1 - px % pixelsPerByte) * bitDepth;
+                        var mask = (1 << bitDepth) - 1;
+                        idx = (cur[byteIdx] >> bitShift) & mask;
+                    }
+                    var palBase = idx * 3;
+                    if (palBase + 2 < palette!.Length)
+                    {
+                        outputRgb[outBase + px * 3]     = palette[palBase];
+                        outputRgb[outBase + px * 3 + 1] = palette[palBase + 1];
+                        outputRgb[outBase + px * 3 + 2] = palette[palBase + 2];
+                    }
+                    if (outputAlpha != null)
+                        outputAlpha[row * width + px] = (trns != null && idx < trns.Length) ? trns[idx] : (byte)255;
+                }
+            }
+            else
             {
-                outputRgb[outBase + px * 3]     = cur[px * channels];
-                outputRgb[outBase + px * 3 + 1] = cur[px * channels + 1];
-                outputRgb[outBase + px * 3 + 2] = cur[px * channels + 2];
-                if (channels == 4)
-                    outputAlpha![row * width + px] = cur[px * channels + 3];
+                for (var px = 0; px < width; px++)
+                {
+                    outputRgb[outBase + px * 3]     = cur[px * channels];
+                    outputRgb[outBase + px * 3 + 1] = cur[px * channels + 1];
+                    outputRgb[outBase + px * 3 + 2] = cur[px * channels + 2];
+                    if (channels == 4)
+                        outputAlpha![row * width + px] = cur[px * channels + 3];
+                }
             }
 
             cur.CopyTo(prevRow, 0);