如何查找具有给定颜色的 PDF 文本并替换它

在使用链接的 java 示例后，我设法让它工作。下面的代码将采用目标颜色和替换颜色。它将搜索文档，并用替换目标颜色的任何实例。

这应该适用于所有色彩空间。我使用 RGB 作为搜索条件，但如果需要，您可以将其更改为 DeviceCMYK 或 DeviceGray。

using System.Collections.ObjectModel;
using iText.Kernel.Colors;
using iText.Kernel.Exceptions;
using iText.Kernel.Pdf;
using iText.Kernel.Pdf.Canvas;
using iText.Kernel.Pdf.Canvas.Parser;
using iText.Kernel.Pdf.Canvas.Parser.Data;
using iText.Kernel.Pdf.Canvas.Parser.Listener;

class Program
{
    static void Main(string[] args)
    {
        // Replace the paths with your own file
        string inputPdfPath = "input.pdf";
        string outputPdfPath = "output.pdf";

        // set up PDF
        PdfReader reader = new(inputPdfPath);
        PdfWriter writer = new(outputPdfPath);
        PdfDocument pdfDocument = new PdfDocument(reader, writer);
        pdfDocument.SetTagged();

        // Use your own values here!
        Color find = new DeviceRgb(229, 18, 18);
        Color replacement = new DeviceRgb(0, 0, 0);
        // alternatively: new DeviceCmyk, new DeviceGray

        // Create a new editor
        PdfCanvasEditor editor = new(find, replacement);

        // Replace every page
        for (int i = 1; i <= pdfDocument.GetNumberOfPages(); i++)
        {
            editor.EditPage(pdfDocument, i);
        }

        // Save changes to output file
        pdfDocument.Close();
    }
}

public class PdfCanvasEditor : PdfCanvasProcessor
{
    /// <summary> 
    /// The color of content in the document 
    /// </summary>
    private Color currentColor;
    /// <summary> 
    /// Color specified by the user to be replaced 
    /// </summary>
    private Color colorToFind;

    private Color replacementColor;

    /// <summary> 
    /// These operators may indicate that a color change has occurred 
    /// </summary>
    private List<string> TEXT_SHOWING_OPERATORS = new() { "Tj", "'", "\"", "TJ" };

    /// <summary> 
    /// Holds output canvas and related resources 
    /// </summary>
    protected PdfCanvas canvas = null;

    public PdfCanvasEditor(iText.Kernel.Colors.Color find, iText.Kernel.Colors.Color replace) : base(new ContentListener()) {
        this.colorToFind = find;
        this.replacementColor = replace;
    }


    /// <summary>
    /// Edits a page by a given number
    /// </summary>
    public void EditPage(PdfDocument pdfDocument, int pageNumber)
    {
        if ((pdfDocument.GetReader() == null) || (pdfDocument.GetWriter() == null))
        {
            throw new PdfException("PdfDocument must be editable");
        }

        // Get the current page and resources
        PdfPage page = pdfDocument.GetPage(pageNumber);
        PdfResources pdfResources = page.GetResources();

        // Create a new canvas to make changes on
        PdfCanvas pdfCanvas = new PdfCanvas(new PdfStream(), pdfResources, pdfDocument);
        // Make the changes
        EditContent(page.GetContentBytes(), pdfResources, pdfCanvas);

        // Overwrites the old page with the new data
        page.Put(PdfName.Contents, pdfCanvas.GetContentStream());
    }

    /// <summary> 
    /// Edits content for a page with the binary data 
    /// </summary>
    public void EditContent(byte[] contentBytes, PdfResources resources, PdfCanvas canvas)
    {
        this.canvas = canvas;
        ProcessContent(contentBytes, resources);
        this.canvas = null;
    }

    /// <summary> 
    /// Copies a page to the "new" document. 
    /// </summary>
    public void Write(PdfCanvasProcessor processor, PdfLiteral pdfOperator, IList<PdfObject> operands)
    {
        PdfOutputStream pdfOutputStream = canvas.GetContentStream().GetOutputStream();
        int index = 0;

        // Copy each object to the new page
        foreach (PdfObject obj in operands)
        {
            pdfOutputStream.Write(obj);
            if (operands.Count > ++index) {
                pdfOutputStream.WriteSpace();
            } else {
                pdfOutputStream.WriteNewLine();
            }
        }
    }

    /// <summary> 
    /// Modifies a given color if it is found 
    /// </summary>
    public void Write(PdfCanvasProcessor processor, PdfLiteral pdfLiteral, IList<PdfObject> operands, bool isColor)
    {
        Console.WriteLine("Processing PDF data");
        string operatorString = pdfLiteral.ToString();

        // Only check a color if there is a related operator
        if (TEXT_SHOWING_OPERATORS.Contains(operatorString))
        {
            if (currentColor == null)
            {
                // Gets the color of the content
                Color currentFillColor = GetGraphicsState().GetFillColor();
                
                // If the color matches, start the replacement process
                if (colorToFind.Equals(currentFillColor))
                {
                    // Set the current color
                    currentColor = currentFillColor;

                    // Replace it
                    List<PdfObject> list = GetColorList(replacementColor);
                    Write(processor, new PdfLiteral("rg"), list);
                }
            }
        }
        else if (currentColor != null)
        {
            if (currentColor is DeviceCmyk)
            {
                List<PdfObject> list = GetColorList(replacementColor);
                Write(processor, new PdfLiteral("k"), list);
            }
            else if (currentColor is DeviceGray)
            {
                List<PdfObject> list = GetColorList(replacementColor);
                Write(processor, new PdfLiteral("g"), list);
            }
            else
            {
                List<PdfObject> list = GetColorList(replacementColor);
                Write(processor, new PdfLiteral("rg"), list);
            }

            // Reset. Allows for more colors to be replaced
            currentColor = null;
        }

        Write(processor, pdfLiteral, operands);
    }

    /// <summary> 
    /// Overrides PdfContentStreamProcessor methods 
    /// </summary>
    public override IContentOperator RegisterContentOperator(string operatorString, IContentOperator pdfOperator)
    {
        ContentOperatorWrapper wrapper = new ContentOperatorWrapper(this);
        wrapper.setOriginalOperator(pdfOperator);
        IContentOperator formerOperator = base.RegisterContentOperator(operatorString, wrapper);
        if (formerOperator is ContentOperatorWrapper)
        {
            return ((ContentOperatorWrapper)formerOperator).getOriginalOperator();
        }
        else
        {
            return formerOperator;
        }
    }

    /// <summary>
    /// Gets a color list based on the color space
    /// </summary>
    private List<PdfObject> GetColorList(Color color)
    {
        List<PdfObject> list = new();
        float[] values = color.GetColorValue();
        if (color is DeviceCmyk)
        {
            list.Add(new PdfNumber(values[0]));
            list.Add(new PdfNumber(values[1]));
            list.Add(new PdfNumber(values[2]));
            list.Add(new PdfNumber(values[3]));
            list.Add(new PdfLiteral("k"));
        }
        else if (color is DeviceGray)
        {
            list.Add(new PdfNumber(values[0]));
            list.Add(new PdfLiteral("g"));
        }
        else
        {
            list.Add(new PdfNumber(values[0]));
            list.Add(new PdfNumber(values[1]));
            list.Add(new PdfNumber(values[2]));
            list.Add(new PdfLiteral("rg"));
        }

        return list;
    }

    /// <summary>
    /// A content operator class to wrap all content operators to forward the invocation to the editor
    /// </summary>
    class ContentOperatorWrapper : IContentOperator
    {
        private PdfCanvasEditor editor;
        private IContentOperator originalOperator = null;
        
        public ContentOperatorWrapper(PdfCanvasEditor editor)
        {
            this.editor = editor;
        }

        public IContentOperator getOriginalOperator()
        {
            return originalOperator;
        }

        public void setOriginalOperator(IContentOperator originalOperator)
        {
            this.originalOperator = originalOperator;
        }


        public void Invoke(PdfCanvasProcessor processor, PdfLiteral pdfLiteral, IList<PdfObject> operands)
        {
            if (originalOperator != null && !"Do".Equals(pdfLiteral.ToString()))
            {
                originalOperator.Invoke(processor, pdfLiteral, operands);
            }
            editor.Write(processor, pdfLiteral, operands, true);
        }
    }

    /// <summary> 
    /// A listener which will emit when an event that may have colored text occurs 
    /// </summary>
    class ContentListener : IEventListener
    {
        public void EventOccurred(IEventData data, EventType type) { }

        ICollection<EventType> IEventListener.GetSupportedEvents()
        {
            return new Collection<EventType>() {
                EventType.BEGIN_TEXT, EventType.RENDER_TEXT, EventType.END_TEXT, EventType.RENDER_IMAGE,
                EventType.RENDER_PATH, EventType.CLIP_PATH_CHANGED
            };
        }
    }
}