[RELEASE] iText 7 pdfSweep - 2.0.1

https://github.com/itext/i7j-pdfsweep/releases/tag/2.0.1

* release/2.0.1:
  [RELEASE] 2.0.1-SNAPSHOT -> 2.0.1
  Introduce reusing of already filtered images
  Bump iText Core dependency version
  Fixed an issue where .getFontFromAcroForm() method was called on a pdf without an AcroForm, resulting in a NullPointerException. This is fixed by adding an extra check on the availability of the AcroForm before querying it. Also changed .drawOverlayText() so instead of throwing a NullPointerException it throws a PdfException.
  Update copyright header
  Remove empty @param and @return Javadoc tags
  [RELEASE] Update pom for 2.0.1-SNAPSHOT development
  Avoid unnecessary TJ operator before writing text with ` or ", handle empty TJ array
  Process new line operators while text cleaning. Minor changes.

Author: iText-CI

pom.xml

@@ -5,12 +5,12 @@
   <parent>
     <groupId>com.itextpdf</groupId>
     <artifactId>root</artifactId>
-    <version>7.1.0</version>
+    <version>7.1.2</version>
     <relativePath />
   </parent>
 
   <artifactId>cleanup</artifactId>
-  <version>2.0.0</version>
+  <version>2.0.1</version>
 
   <name>pdfSweep</name>
   <url>http://itextpdf.com/</url>

src/main/java/com/itextpdf/pdfcleanup/FilteredImagesCache.java

@@ -0,0 +1,115 @@
+package com.itextpdf.pdfcleanup;
+
+import com.itextpdf.kernel.geom.Rectangle;
+import com.itextpdf.kernel.pdf.PdfDocument;
+import com.itextpdf.kernel.pdf.PdfIndirectReference;
+import com.itextpdf.kernel.pdf.PdfStream;
+import com.itextpdf.kernel.pdf.canvas.parser.data.ImageRenderInfo;
+import com.itextpdf.kernel.pdf.xobject.PdfImageXObject;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+class FilteredImagesCache {
+    private Map<PdfIndirectReference, List<FilteredImageKey>> cache = new HashMap<>();
+
+    static FilteredImageKey createFilteredImageKey(ImageRenderInfo image, List<Rectangle> areasToBeCleaned, PdfDocument document) {
+        PdfStream imagePdfObject = image.getImage().getPdfObject();
+        if (imagePdfObject.getIndirectReference() == null) {
+            imagePdfObject.makeIndirect(document);
+        }
+        return new FilteredImageKey(image, areasToBeCleaned);
+    }
+
+    /**
+     * Retrieves saved result of image filtering based on given set of cleaning areas.
+     * This won't handle the case when same filtering result is produced by different sets of areas,
+     * e.g. if one set is { (0, 0, 50, 100), (50, 0, 50, 100)} and another one is {(0, 0, 100, 100)},
+     * even though filtering results are essentially the same, current {@link FilteredImagesCache}
+     * will treat this two cases as different filtering results.
+     * @param imageKey the defining filtering case
+     * @return result of image filtering based on given set of cleaning areas if such was already processed and saved,
+     * null otherwise.
+     */
+    PdfImageXObject get(FilteredImageKey imageKey) {
+        List<FilteredImageKey> cachedFilteredImageKeys = cache.get(imageKey.getImageIndRef());
+        if (cachedFilteredImageKeys != null) {
+            for (FilteredImageKey cacheKey : cachedFilteredImageKeys) {
+                if (rectanglesEqualWithEps(cacheKey.getCleanedAreas(), imageKey.getCleanedAreas())) {
+                    return cacheKey.getFilteredImage();
+                }
+            }
+        }
+        return null;
+    }
+
+    void put(FilteredImageKey imageKey, PdfImageXObject filteredImage) {
+        if (imageKey.getCleanedAreas() == null || imageKey.getCleanedAreas().isEmpty()) {
+            return;
+        }
+        List<FilteredImageKey> filteredImageKeys = cache.get(imageKey.getImageIndRef());
+        if (filteredImageKeys == null) {
+            cache.put(imageKey.getImageIndRef(), filteredImageKeys = new ArrayList<>());
+        }
+        filteredImageKeys.add(imageKey);
+        imageKey.setFilteredImage(filteredImage);
+    }
+
+    private boolean rectanglesEqualWithEps(List<Rectangle> cacheRects, List<Rectangle> keyRects) {
+        if (keyRects == null || cacheRects.size() != keyRects.size()) {
+            return false;
+        }
+
+        Set<Rectangle> cacheRectsSet = new LinkedHashSet<>(cacheRects);
+        for (Rectangle keyArea : keyRects) {
+            boolean found = false;
+            for (Rectangle cacheArea : cacheRectsSet) {
+                if (keyArea.equalsWithEpsilon(cacheArea)) {
+                    found = true;
+                    cacheRectsSet.remove(cacheArea);
+                    break;
+                }
+            }
+            if (!found) {
+                break;
+            }
+        }
+        return cacheRectsSet.isEmpty();
+    }
+
+    static class FilteredImageKey {
+        private ImageRenderInfo image;
+        private List<Rectangle> cleanedAreas;
+        private PdfImageXObject filteredImage;
+
+        FilteredImageKey(ImageRenderInfo imageInfo, List<Rectangle> cleanedAreas) {
+            this.image = imageInfo;
+            this.cleanedAreas = cleanedAreas;
+        }
+
+        List<Rectangle> getCleanedAreas() {
+            return cleanedAreas;
+        }
+
+        ImageRenderInfo getImageRenderInfo() {
+            return image;
+        }
+
+        PdfIndirectReference getImageIndRef() {
+            return image.getImage().getPdfObject().getIndirectReference();
+        }
+
+        PdfImageXObject getFilteredImage() {
+            return filteredImage;
+        }
+
+        void setFilteredImage(PdfImageXObject filteredImage) {
+            this.filteredImage = filteredImage;
+        }
+    }
+}

src/main/java/com/itextpdf/pdfcleanup/LineDashPattern.java

@@ -326,7 +326,6 @@ private static Point getUnitVector(Point vector) {
      * This is the Euclidean distance between the tip of the vector and the origin.
      *
      * @param vector input vector
-     * @return
      */
     private static double getVectorEuclideanNorm(Point vector) {
         return vector.distance(0, 0);
@@ -355,7 +354,6 @@ private static float applyDash(Path dashedPath, Point segStart, Point segEnd, Po
      * @param segStart start of the line segment
      * @param segEnd   end of the line segment
      * @param point    query point
-     * @return
      */
     private static boolean liesOnSegment(Point segStart, Point segEnd, Point point) {
         return point.getX() >= Math.min(segStart.getX(), segEnd.getX()) &&

src/main/java/com/itextpdf/pdfcleanup/PdfCleanUpEventListener.java

@@ -81,6 +81,9 @@ public void eventOccurred(IEventData data, EventType type) {
      * @return the TextRenderInfo objects that were encountered when processing the last text rendering operation
      */
     List<TextRenderInfo> getEncounteredText() {
+        if (content.size() == 0) {
+            throw new PdfException(textDataExpected);
+        }
         ArrayList<TextRenderInfo> text = new ArrayList<>(content.size());
         for (IEventData data : content) {
             if (data instanceof TextRenderInfo) {

src/main/java/com/itextpdf/pdfcleanup/PdfCleanUpFilter.java

@@ -54,7 +54,10 @@ This file is part of the iText (R) project.
 import com.itextpdf.kernel.geom.Rectangle;
 import com.itextpdf.kernel.geom.Subpath;
 import com.itextpdf.kernel.pdf.PdfArray;
+import com.itextpdf.kernel.pdf.PdfDocument;
+import com.itextpdf.kernel.pdf.PdfIndirectReference;
 import com.itextpdf.kernel.pdf.PdfNumber;
+import com.itextpdf.kernel.pdf.PdfStream;
 import com.itextpdf.kernel.pdf.PdfTextArray;
 import com.itextpdf.kernel.pdf.canvas.PdfCanvasConstants;
 import com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperBridge;
@@ -71,6 +74,7 @@ This file is part of the iText (R) project.
 import com.itextpdf.kernel.pdf.canvas.parser.data.ImageRenderInfo;
 import com.itextpdf.kernel.pdf.canvas.parser.data.PathRenderInfo;
 import com.itextpdf.kernel.pdf.canvas.parser.data.TextRenderInfo;
+import com.itextpdf.kernel.pdf.xobject.PdfImageXObject;
 import org.apache.commons.imaging.ImageFormats;
 import org.apache.commons.imaging.ImageInfo;
 import org.apache.commons.imaging.ImageReadException;
@@ -120,8 +124,6 @@ public PdfCleanUpFilter(List<Rectangle> regions) {
 
     /**
      * Generic class representing the result of filtering an object of type T
-     *
-     * @param <T>
      */
     static class FilterResult<T> {
         private boolean isModified;
@@ -143,8 +145,6 @@ boolean isModified() {
 
         /**
          * Get the result after filtering
-         *
-         * @return
          */
         T getFilterResult() {
             return filterResult;
@@ -155,7 +155,6 @@ T getFilterResult() {
      * Filter a TextRenderInfo object
      *
      * @param text the TextRenderInfo to be filtered
-     * @return
      */
     FilterResult<PdfArray> filterText(TextRenderInfo text) {
         PdfTextArray textArray = new PdfTextArray();
@@ -177,24 +176,34 @@ FilterResult<PdfArray> filterText(TextRenderInfo text) {
         return new FilterResult<PdfArray>(true, textArray);
     }
 
+    FilteredImagesCache.FilteredImageKey createFilteredImageKey(ImageRenderInfo image, PdfDocument document) {
+        return FilteredImagesCache.createFilteredImageKey(image, getImageAreasToBeCleaned(image), document);
+    }
+
     /**
      * Filter an ImageRenderInfo object
      *
      * @param image the ImageRenderInfo object to be filtered
-     * @return
      */
     FilterResult<ImageData> filterImage(ImageRenderInfo image) {
-        List<Rectangle> areasToBeCleaned = getImageAreasToBeCleaned(image);
-        if (areasToBeCleaned == null) {
+        return filterImage(image, getImageAreasToBeCleaned(image));
+    }
+
+    FilterResult<ImageData> filterImage(FilteredImagesCache.FilteredImageKey imageKey) {
+        return filterImage(imageKey.getImageRenderInfo(), imageKey.getCleanedAreas());
+    }
+
+    FilterResult<ImageData> filterImage(ImageRenderInfo image, List<Rectangle> imageAreasToBeCleaned) {
+        if (imageAreasToBeCleaned == null) {
             return new FilterResult<>(true, null);
-        } else if (areasToBeCleaned.isEmpty()) {
-            return new FilterResult<>(false, ImageDataFactory.create(image.getImage().getImageBytes()));
+        } else if (imageAreasToBeCleaned.isEmpty()) {
+            return new FilterResult<>(false, null);
         }
 
         byte[] filteredImageBytes;
         try {
             byte[] originalImageBytes = image.getImage().getImageBytes();
-            filteredImageBytes = processImage(originalImageBytes, areasToBeCleaned);
+            filteredImageBytes = processImage(originalImageBytes, imageAreasToBeCleaned);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -206,7 +215,6 @@ FilterResult<ImageData> filterImage(ImageRenderInfo image) {
      * Filter a PathRenderInfo object
      *
      * @param path the PathRenderInfo object to be filtered
-     * @return
      */
     com.itextpdf.kernel.geom.Path filterStrokePath(PathRenderInfo path) {
         PdfArray dashPattern = path.getLineDashPattern();
@@ -220,7 +228,6 @@ com.itextpdf.kernel.geom.Path filterStrokePath(PathRenderInfo path) {
      * Filter a PathRenderInfo object
      *
      * @param path the PathRenderInfo object to be filtered
-     * @return
      */
     com.itextpdf.kernel.geom.Path filterFillPath(PathRenderInfo path, int fillingRule) {
         return filterFillPath(path.getPath(), path.getCtm(), fillingRule);
@@ -230,7 +237,6 @@ com.itextpdf.kernel.geom.Path filterFillPath(PathRenderInfo path, int fillingRul
      * Returns whether the given TextRenderInfo object needs to be cleaned up
      *
      * @param renderInfo the input TextRenderInfo object
-     * @return
      */
     private boolean isTextNotToBeCleaned(TextRenderInfo renderInfo) {
         Point[] textRect = getTextRectangle(renderInfo);
@@ -402,7 +408,6 @@ private void cleanImage(BufferedImage image, List<Rectangle> areasToBeCleaned) {
      * Get the bytes of the BufferedImage (in JPG format)
      *
      * @param image input image
-     * @return
      */
     private byte[] getJPGBytes(BufferedImage image) {
         ByteArrayOutputStream outputStream = null;
@@ -465,10 +470,7 @@ private com.itextpdf.kernel.geom.Path filterStrokePath(com.itextpdf.kernel.geom.
     /**
      * Note: this method will close all unclosed subpaths of the passed path.
      *
-     * @param path        path
-     * @param ctm         ctm
      * @param fillingRule If the subpath is contour, pass any value.
-     * @return filterFillPath
      */
     private com.itextpdf.kernel.geom.Path filterFillPath(com.itextpdf.kernel.geom.Path path, Matrix ctm, int fillingRule) {
         path.closeAllSubpaths();
@@ -570,7 +572,6 @@ private static List<Subpath> convertToSquares(List<Subpath> degenerateSubpaths,
      * Approximates a given Path with a List of Point objects
      *
      * @param path input path
-     * @return
      */
     private static List<Point> getPathApproximation(com.itextpdf.kernel.geom.Path path) {
         List<Point> approx = new ArrayList<Point>() {
@@ -634,7 +635,6 @@ private static Point[] getRotatedSquareVertices(Point[] orthogonalSquareVertices
      *
      * @param center center of the circle
      * @param radius radius of the circle
-     * @return
      */
     private static BezierCurve[] approximateCircle(Point center, double radius) {
         // The circle is split into 4 sectors. Arc of each sector
@@ -693,7 +693,6 @@ private Point[] transformPoints(Matrix transformationMatrix, boolean inverse, Po
      * Get the bounding box of a TextRenderInfo object
      *
      * @param renderInfo input TextRenderInfo object
-     * @return
      */
     private Point[] getTextRectangle(TextRenderInfo renderInfo) {
         LineSegment ascent = renderInfo.getAscentLine();
@@ -711,7 +710,6 @@ private Point[] getTextRectangle(TextRenderInfo renderInfo) {
      * Convert a Rectangle object into 4 Points
      *
      * @param rect input Rectangle
-     * @return
      */
     private Point[] getRectangleVertices(Rectangle rect) {
         Point[] points = {
@@ -731,7 +729,6 @@ private Point[] getRectangleVertices(Rectangle rect) {
      * @param p2 second Point
      * @param p3 third Point
      * @param p4 fourth Point
-     * @return
      */
     private Rectangle getAsRectangle(Point p1, Point p2, Point p3, Point p4) {
         List<Double> xs = Arrays.asList(p1.getX(), p2.getX(), p3.getX(), p4.getX());
@@ -750,7 +747,6 @@ private Rectangle getAsRectangle(Point p1, Point p2, Point p3, Point p4) {
      *
      * @param rect1 first Rectangle
      * @param rect2 second Rectangle
-     * @return
      */
     private Rectangle getRectanglesIntersection(Rectangle rect1, Rectangle rect2) {
         float x1 = Math.max(rect1.getLeft(), rect2.getLeft());