fix(preflight): stop sparse bleed marks passing content-bleed (#120)

LoopLibCore/sources/pdfbleedmarginprobe.h

@@ -41,6 +41,10 @@ struct LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbeSettings
     QMarginsF bleedMM = QMarginsF(3.0, 3.0, 3.0, 3.0);
     bool fastOnly = false;
     qint64 maxRasterPixels = 250LL * 1000 * 1000;
+    /// Share of a bleed strip that artwork must cover (by bounds) or ink (by raster)
+    /// before the edge counts as populated. A margin holding only a few stray marks is
+    /// below it and is reported as empty.
+    qreal minEdgeCoverage = 0.10;
 };
 
 struct LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbeEdgeResult
@@ -49,6 +53,12 @@ struct LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbeEdgeResult
     int inkPixels = 0;
     int totalPixels = 0;
     QRectF stripRect;
+    /// Upper bound of the share of the strip covered by artwork bounds (0..1), set by the fast pass.
+    qreal boundsCoverage = 0.0;
+    /// False when hasContent rests on bounds that touch enough of the strip, but the filled
+    /// geometry (images, filled paths and glyphs, clipped) paints less than minEdgeCoverage of
+    /// it, and no raster measurement confirmed it.
+    bool confirmed = true;
 };
 
 struct LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbeResult
@@ -62,22 +72,31 @@ struct LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbeResult
     {
         return left.hasContent && right.hasContent && top.hasContent && bottom.hasContent;
     }
+
+    bool allEdgesConfirmed() const
+    {
+        return left.confirmed && right.confirmed && top.confirmed && bottom.confirmed;
+    }
 };
 
 /// Probes whether rendered artwork on a page extends into the bleed margin.
 ///
-/// Fast path: unions bounding rects from `PDFPrecompiledPage::calculateGraphicPieceInfos`
-/// and compares against the reference box expanded by the bleed amount. No rasterization.
+/// Fast path: measures how much of each bleed strip the bounding rects from
+/// `PDFPrecompiledPage::calculateGraphicPieceInfos` cover. A strip is populated when that
+/// coverage reaches `minEdgeCoverage`, so a few stray marks do not count. No rasterization.
+/// The edge is confirmed only when images and filled paths, cut by their clip, actually paint
+/// `minEdgeCoverage` of the strip; strokes alone leave it unconfirmed.
 ///
-/// Raster path (raster_confirm): renders only the four edge strips at probe_dpi
-/// and counts non-background pixels against a threshold.
+/// Raster path (raster_confirm): renders the four edge strips at probe_dpi and counts
+/// non-background pixels against `minEdgeCoverage`. It confirms or demotes every edge the bounds
+/// pass could not prove solid, and upgrades empty edges that the raster finds inked.
 class LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbe
 {
 public:
     explicit PDFBleedMarginProbe(PDFDocumentSession* session);
 
-    /// Full probe: fast bounds pass first, then raster confirmation if the settings
-    /// request it and the fast pass flagged missing content on any side.
+    /// Full probe: fast bounds pass first, then raster confirmation if the settings request it
+    /// and the fast pass left any side empty or unconfirmed.
     PDFBleedMarginProbeResult probe(const PDFPage* page,
                                     size_t pageIndex,
                                     const PDFBleedMarginProbeSettings& settings);
@@ -98,6 +117,6 @@ class LOOPLIBCORESHARED_EXPORT PDFBleedMarginProbe
     PDFDocumentSession* m_session;
 };
 
-} // namespace pdf
+}   // namespace pdf
 
-#endif // PDFBLEEDMARGINPROBE_H
+#endif   // PDFBLEEDMARGINPROBE_H

LoopLibCore/sources/pdfinkcoverageprobe.cpp

@@ -83,6 +83,52 @@ QRectF resolveAnalysisBox(const PDFPage* page, PDFInkCoverageAnalysisBox request
     return media;
 }
 
+/// Device raster of an analysis box at a resolution. An empty size means the box
+/// cannot be rasterized.
+struct CompositorRaster
+{
+    QSize size;
+    QTransform pagePointToDevice;
+    bool budgetExceeded = false;
+};
+
+CompositorRaster planCompositorRaster(const PDFPage* page, const QRectF& analysisBox, int dpi, qint64 maxRasterPixels)
+{
+    CompositorRaster raster;
+    const PageRotation pageRotation = page->getPageRotation();
+    const QRectF rotatedAnalysisBox = PDFPage::getRotatedBox(analysisBox, pageRotation).normalized();
+    const qreal pointToPixel = static_cast<qreal>(dpi) / 72.0;
+    const double widthReal = std::ceil(rotatedAnalysisBox.width() * pointToPixel);
+    const double heightReal = std::ceil(rotatedAnalysisBox.height() * pointToPixel);
+
+    if (!std::isfinite(widthReal) || !std::isfinite(heightReal) || widthReal <= 0.0 || heightReal <= 0.0 || widthReal > static_cast<double>(std::numeric_limits<int>::max()) || heightReal > static_cast<double>(std::numeric_limits<int>::max()))
+    {
+        return raster;
+    }
+
+    const int width = qMax(1, static_cast<int>(widthReal));
+    const int height = qMax(1, static_cast<int>(heightReal));
+    if (maxRasterPixels > 0 && static_cast<qint64>(width) * static_cast<qint64>(height) > maxRasterPixels)
+    {
+        raster.budgetExceeded = true;
+        return raster;
+    }
+
+    raster.size = QSize(width, height);
+    raster.pagePointToDevice = PDFRenderer::createMediaBoxToDevicePointMatrix(rotatedAnalysisBox, QRect(QPoint(0, 0), raster.size), pageRotation);
+    return raster;
+}
+
+PDFTransparencyRendererSettings compositorRendererSettings()
+{
+    PDFTransparencyRendererSettings rendererSettings;
+    rendererSettings.flags.setFlag(PDFTransparencyRendererSettings::ActiveColorMask, false);
+    rendererSettings.flags.setFlag(PDFTransparencyRendererSettings::SeparationSimulation, true);
+    rendererSettings.activeColorMask = PDFPixelFormat::getAllColorsMask();
+    rendererSettings.renderPolicy = PDFRenderPolicy::forPreflightAnalysis();
+    return rendererSettings;
+}
+
 }   // namespace
 
 PDFInkCoverageProbe::PDFInkCoverageProbe(PDFDocumentSession* session) :
@@ -114,39 +160,15 @@ PDFInkCoverageProbeResult PDFInkCoverageProbe::probe(const PDFPage* page,
         return result;
     }
 
-    const PageRotation pageRotation = page->getPageRotation();
-    const QRectF rotatedAnalysisBox = PDFPage::getRotatedBox(analysisBox, pageRotation).normalized();
-    const QSizeF mediaSize = rotatedAnalysisBox.size();
-    const qreal pointToPixel = static_cast<qreal>(settings.dpi) / 72.0;
-    const double widthReal = std::ceil(mediaSize.width() * pointToPixel);
-    const double heightReal = std::ceil(mediaSize.height() * pointToPixel);
-
-    if (!std::isfinite(widthReal) || !std::isfinite(heightReal) || widthReal <= 0.0 || heightReal <= 0.0 || widthReal > static_cast<double>(std::numeric_limits<int>::max()) || heightReal > static_cast<double>(std::numeric_limits<int>::max()))
-    {
-        return result;
-    }
-
-    const int width = qMax(1, static_cast<int>(widthReal));
-    const int height = qMax(1, static_cast<int>(heightReal));
-    const qint64 rasterPixels = static_cast<qint64>(width) * static_cast<qint64>(height);
-    if (settings.maxRasterPixels > 0 && rasterPixels > settings.maxRasterPixels)
+    const CompositorRaster raster = planCompositorRaster(page, analysisBox, settings.dpi, settings.maxRasterPixels);
+    result.budgetExceeded = raster.budgetExceeded;
+    if (raster.size.isEmpty())
     {
-        result.budgetExceeded = true;
         return result;
     }
 
-    PDFTransparencyRendererSettings rendererSettings;
+    PDFTransparencyRendererSettings rendererSettings = compositorRendererSettings();
     rendererSettings.flags.setFlag(PDFTransparencyRendererSettings::SaveOriginalProcessImage, true);
-    rendererSettings.flags.setFlag(PDFTransparencyRendererSettings::ActiveColorMask, false);
-    rendererSettings.flags.setFlag(PDFTransparencyRendererSettings::SeparationSimulation, true);
-    rendererSettings.activeColorMask = PDFPixelFormat::getAllColorsMask();
-    rendererSettings.renderPolicy = PDFRenderPolicy::forPreflightAnalysis();
-
-    const QSize imageSize(width, height);
-    const QTransform pagePointToDevice = PDFRenderer::createMediaBoxToDevicePointMatrix(
-        rotatedAnalysisBox,
-        QRect(QPoint(0, 0), imageSize),
-        pageRotation);
     PDFInkMapper inkMapper(nullptr, document);
     inkMapper.createSpotColors(true);
 
@@ -157,8 +179,8 @@ PDFInkCoverageProbeResult PDFInkCoverageProbe::probe(const PDFPage* page,
                                      m_session->getOptionalContentActivity(),
                                      &inkMapper,
                                      rendererSettings,
-                                     pagePointToDevice);
-    renderer.beginPaint(imageSize);
+                                     raster.pagePointToDevice);
+    renderer.beginPaint(raster.size);
     renderer.processContents();
     renderer.endPaint();
     result.diagnostics = renderer.getRenderDiagnostics();
@@ -269,7 +291,7 @@ PDFInkCoverageProbeResult PDFInkCoverageProbe::probe(const PDFPage* page,
     }
 
     bool invertible = false;
-    const QTransform deviceToPage = pagePointToDevice.inverted(&invertible);
+    const QTransform deviceToPage = raster.pagePointToDevice.inverted(&invertible);
     if (!invertible)
     {
         result.regions.clear();
@@ -310,4 +332,57 @@ PDFInkCoverageProbeResult PDFInkCoverageProbe::probe(const PDFPage* page,
     return result;
 }
 
+PDFOverprintProbe::PDFOverprintProbe(PDFDocumentSession* session) :
+    m_session(session)
+{
+}
+
+PDFOverprintProbeResult PDFOverprintProbe::probe(const PDFPage* page, int dpi, qint64 maxRasterPixels)
+{
+    PDFOverprintProbeResult result;
+    if (!page || !m_session || dpi <= 0)
+    {
+        return result;
+    }
+
+    PDFDocument* document = m_session->getDocument();
+    if (!document)
+    {
+        return result;
+    }
+
+    const QRectF analysisBox = resolveAnalysisBox(page, PDFInkCoverageAnalysisBox::Bleed);
+    if (!isUsableBox(analysisBox))
+    {
+        return result;
+    }
+
+    const CompositorRaster raster = planCompositorRaster(page, analysisBox, dpi, maxRasterPixels);
+    result.budgetExceeded = raster.budgetExceeded;
+    if (raster.size.isEmpty())
+    {
+        return result;
+    }
+
+    PDFInkMapper inkMapper(nullptr, document);
+    inkMapper.createSpotColors(true);
+
+    PDFTransparencyRenderer renderer(page,
+                                     document,
+                                     m_session->getFontCache(),
+                                     m_session->getCMS(),
+                                     m_session->getOptionalContentActivity(),
+                                     &inkMapper,
+                                     compositorRendererSettings(),
+                                     raster.pagePointToDevice);
+    renderer.beginPaint(raster.size);
+    renderer.processContents();
+    renderer.endPaint();
+
+    result.rendered = true;
+    result.diagnostics = renderer.getRenderDiagnostics();
+    result.observation = renderer.getOverprintObservation();
+    return result;
+}
+
 }   // namespace pdf

LoopLibCore/sources/pdfinkcoverageprobe.h

@@ -109,6 +109,27 @@ class LOOPLIBCORESHARED_EXPORT PDFInkCoverageProbe
     PDFDocumentSession* m_session;
 };
 
+struct LOOPLIBCORESHARED_EXPORT PDFOverprintProbeResult
+{
+    bool rendered = false;   // false when rasterization was unavailable or over budget
+    bool budgetExceeded = false;
+    PDFRenderDiagnostics diagnostics;
+    PDFOverprintObservation observation;
+};
+
+/// Renders a page on the overprint-accurate compositor (the Output Preview path) and
+/// reports the overprint that compositor applied, instead of reading page-view state.
+class LOOPLIBCORESHARED_EXPORT PDFOverprintProbe
+{
+public:
+    explicit PDFOverprintProbe(PDFDocumentSession* session);
+
+    PDFOverprintProbeResult probe(const PDFPage* page, int dpi, qint64 maxRasterPixels);
+
+private:
+    PDFDocumentSession* m_session;
+};
+
 }   // namespace pdf
 
 #endif   // PDFINKCOVERAGEPROBE_H

LoopLibCore/sources/pdfpainter.cpp

@@ -886,6 +886,8 @@ PDFPrecompiledPage::GraphicPieceInfos PDFPrecompiledPage::calculateGraphicPieceI
     struct State
     {
         QTransform matrix;
+        QPainterPath clipPath;
+        bool clipped = false;
     };
     std::stack<State> stateStack;
     stateStack.emplace();
@@ -926,6 +928,9 @@ PDFPrecompiledPage::GraphicPieceInfos PDFPrecompiledPage::calculateGraphicPieceI
                     info.type = data.isText ? GraphicPieceInfo::Type::Text : GraphicPieceInfo::Type::VectorGraphics;
                     info.boundingRect = pagePath.controlPointRect();
                     info.pagePath = pagePath;
+                    info.isFilled = data.brush.style() != Qt::NoBrush;
+                    info.isClipped = stateStack.top().clipped;
+                    info.clipPath = stateStack.top().clipPath;
 
                     const int elementCount = pagePath.elementCount();
                     for (int i = 0; i < elementCount; ++i)
@@ -976,6 +981,8 @@ PDFPrecompiledPage::GraphicPieceInfos PDFPrecompiledPage::calculateGraphicPieceI
                     info.type = GraphicPieceInfo::Type::Image;
                     info.boundingRect = pagePath.controlPointRect();
                     info.pagePath = pagePath;
+                    info.isClipped = stateStack.top().clipped;
+                    info.clipPath = stateStack.top().clipPath;
 
                     const int elementCount = pagePath.elementCount();
                     for (int i = 0; i < elementCount; ++i)
@@ -1059,7 +1066,10 @@ PDFPrecompiledPage::GraphicPieceInfos PDFPrecompiledPage::calculateGraphicPieceI
 
             case InstructionType::Clip:
             {
-                // Do nothing, we are just collecting information
+                State& state = stateStack.top();
+                const QPainterPath pageClip = state.matrix.map(m_clips[instruction.dataIndex].clipPath);
+                state.clipPath = state.clipped ? state.clipPath.intersected(pageClip) : pageClip;
+                state.clipped = true;
                 break;
             }
 

LoopLibCore/sources/pdfpainter.h

@@ -297,6 +297,9 @@ class LOOPLIBCORESHARED_EXPORT PDFPrecompiledPage
         std::array<uint8_t, 64> hash = {};   ///< Hash of all data
         std::array<uint8_t, 64> imageHash = {};   ///< Hash of the image only
         QPainterPath pagePath;
+        bool isFilled = false;   ///< Path piece painted with a fill brush (pagePath is the unstroked path)
+        bool isClipped = false;   ///< A clip was in effect when the piece was painted
+        QPainterPath clipPath;   ///< Clip in effect, in page coordinates (valid when isClipped)
     };
 
     using GraphicPieceInfos = std::vector<GraphicPieceInfo>;