Make 'floatMultiplier' and 'arcTolerance' in PdfCleanUpTool non-static configuration

DEVSIX-5770

Author: AnhelinaM

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

@@ -33,6 +33,7 @@ public class CleanUpProperties {
     private IMetaInfo metaInfo;
     private boolean processAnnotations;
     private Double overlapRatio;
+    private PathOffsetApproximationProperties offsetProperties = new PathOffsetApproximationProperties();
 
     /**
      * Creates default CleanUpProperties instance.
@@ -54,9 +55,12 @@ IMetaInfo getMetaInfo() {
      * Sets additional meta info.
      *
      * @param metaInfo the meta info to set
+     *
+     * @return this {@link CleanUpProperties} instance
      */
-    public void setMetaInfo(IMetaInfo metaInfo) {
+    public CleanUpProperties setMetaInfo(IMetaInfo metaInfo) {
         this.metaInfo = metaInfo;
+        return this;
     }
 
     /**
@@ -74,9 +78,12 @@ public boolean isProcessAnnotations() {
      * Default processing behaviour: remove annotation if there is overlap with a redaction region.
      *
      * @param processAnnotations is page annotations will be processed
+     *
+     * @return this {@link CleanUpProperties} instance
      */
-    public void setProcessAnnotations(boolean processAnnotations) {
+    public CleanUpProperties setProcessAnnotations(boolean processAnnotations) {
         this.processAnnotations = processAnnotations;
+        return this;
     }
 
     /**
@@ -98,16 +105,42 @@ public Double getOverlapRatio() {
      * Example: if the overlap ratio is set to 0.3, the content region will be removed if it overlaps with
      * the redaction area by at least 30%.
      *
-     * @param overlapRatio The overlap ratio to set.
+     * @param overlapRatio the overlap ratio to set
+     *
+     * @return this {@link CleanUpProperties} instance
      */
-    public void setOverlapRatio(Double overlapRatio) {
+    public CleanUpProperties setOverlapRatio(Double overlapRatio) {
         if (overlapRatio == null) {
             this.overlapRatio = null;
-            return;
+            return this;
         }
         if (overlapRatio <= 0 || overlapRatio > 1) {
             throw new IllegalArgumentException(CleanupExceptionMessageConstant.OVERLAP_RATIO_SHOULD_BE_IN_RANGE);
         }
         this.overlapRatio = overlapRatio;
+        return this;
+    }
+
+    /**
+     * Get {@link PathOffsetApproximationProperties} specifying approximation parameters for
+     * {@link com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperOffset} operations.
+     *
+     * @return {@link PathOffsetApproximationProperties} parameters
+     */
+    public PathOffsetApproximationProperties getOffsetProperties() {
+        return offsetProperties;
+    }
+
+    /**
+     * Set {@link PathOffsetApproximationProperties} specifying approximation parameters for
+     * {@link com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperOffset} operations.
+     *
+     * @param offsetProperties {@link PathOffsetApproximationProperties} to set
+     *
+     * @return this {@link CleanUpProperties} instance
+     */
+    public CleanUpProperties setOffsetProperties(PathOffsetApproximationProperties offsetProperties) {
+        this.offsetProperties = offsetProperties;
+        return this;
     }
 }

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

@@ -0,0 +1,105 @@
+/*
+    This file is part of the iText (R) project.
+    Copyright (c) 1998-2024 Apryse Group NV
+    Authors: Apryse Software.
+
+    This program is offered under a commercial and under the AGPL license.
+    For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+    AGPL licensing:
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.itextpdf.pdfcleanup;
+
+import com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperBridge;
+
+/**
+ * Contains properties for {@link com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperOffset} operations.
+ */
+public class PathOffsetApproximationProperties {
+    private double arcTolerance = 0.0025;
+    private boolean calculateOffsetMultiplierDynamically = false;
+
+    /**
+     * Creates new {@link PathOffsetApproximationProperties} instance.
+     */
+    public PathOffsetApproximationProperties() {
+        // Empty constructor.
+    }
+
+    /**
+     * Specifies if floatMultiplier should be calculated dynamically. Default value is {@code false}.
+     *
+     * <p>
+     * When a document with line arts is being cleaned up, there are a lot of calculations with floating point numbers.
+     * All of them are translated into fixed point numbers by multiplying by this floatMultiplier coefficient.
+     * It is possible to dynamically adjust the preciseness of the calculations.
+     *
+     * @param calculateDynamically {@code true} if floatMultiplier should be calculated dynamically,
+     *                             {@code false} for default value specified by {@link ClipperBridge#ClipperBridge()}
+     *
+     * @return this {@link PathOffsetApproximationProperties} instance
+     */
+    public PathOffsetApproximationProperties calculateOffsetMultiplierDynamically(boolean calculateDynamically) {
+        this.calculateOffsetMultiplierDynamically = calculateDynamically;
+        return this;
+    }
+
+    /**
+     * Checks whether floatMultiplier should be calculated dynamically.
+     *
+     * <p>
+     * When a document with line arts is being cleaned up, there are a lot of calculations with floating point numbers.
+     * All of them are translated into fixed point numbers by multiplying by this floatMultiplier coefficient.
+     * It is possible to dynamically adjust the preciseness of the calculations.
+     *
+     * @return {@code true} if floatMultiplier should be calculated dynamically, {@code false} for default value
+     */
+    public boolean calculateOffsetMultiplierDynamically() {
+        return this.calculateOffsetMultiplierDynamically;
+    }
+
+    /**
+     * Gets arc tolerance which is the maximum difference between the true and the faceted representation of curves
+     * (arcs) in units. Used as the criterion of a good approximation of rounded line joins and line caps.
+     *
+     * <p>
+     * Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable
+     * imprecision (tolerance) when arcs are approximated in an offsetting operation. Smaller values will increase
+     * smoothness up to a point though at a cost of performance and in creating more vertices to construct the arc.
+     *
+     * @return arc tolerance specifying maximum difference between the true and the faceted representation of arcs
+     */
+    public double getArcTolerance() {
+        return arcTolerance;
+    }
+
+    /**
+     * Sets arc tolerance which is the maximum difference between the true and the faceted representation of curves
+     * (arcs) in units. Used as the criterion of a good approximation of rounded line joins and line caps.
+     *
+     * <p>
+     * Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable
+     * imprecision (tolerance) when arcs are approximated in an offsetting operation. Smaller values will increase
+     * smoothness up to a point though at a cost of performance and in creating more vertices to construct the arc.
+     *
+     * @param arcTolerance maximum difference between the true and the faceted representation of arcs
+     *
+     * @return this {@link PathOffsetApproximationProperties} instance
+     */
+    public PathOffsetApproximationProperties setArcTolerance(double arcTolerance) {
+        this.arcTolerance = arcTolerance;
+        return this;
+    }
+}