A sample App which compares PDF Documents, pages, or indirect objects

comparePDFs.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Datalogics.PDFL;

/*
 * 
 * A sample which compares PDF Documents, pages, or indirect objects.
 * 
 * Copyright (c) 2007-2017, Datalogics, Inc. All rights reserved.
 *
 * The information and code in this sample is for the exclusive use of Datalogics
 * customers and evaluation users only.  Datalogics permits you to use, modify and
 * distribute this file in accordance with the terms of your license agreement.
 * Sample code is for demonstrative purposes only and is not intended for production use.
 *
 */
namespace comparePDFs
{
    class ComparePDFs
    {
        enum compare { doc, page, obj };

        enum cosType { cosNull, Array, Boolean, Dict, Integer, Name, Real, Stream, String };

        static cosType GetObjType(PDFObject obj)
        {
            if (obj is PDFBoolean) { return cosType.Boolean; }
            else if (obj is PDFInteger) { return cosType.Integer; }
            else if (obj is PDFReal) { return cosType.Real; }
            else if (obj is PDFName) { return cosType.Name; }
            else if (obj is PDFString) { return cosType.String; }
            else if (obj is PDFArray) { return cosType.Array; }
            else if (obj is PDFDict) { return cosType.Dict; }
            else if (obj is PDFStream) { return cosType.Stream; }
            else { return cosType.cosNull; }
        }

        static HashSet<string> getKeySet(PDFDict dict)
        {
            var keySet = new HashSet<string>();
            foreach (PDFName keyObj in dict.Keys)
            {
                keySet.Add(keyObj.Value);
            }

            return keySet;
        }

        static string describeObject(PDFObject obj)
        {
            var objType = GetObjType(obj);
            switch (objType)
            {
                case cosType.cosNull:
                    return "null";
                case cosType.Boolean:
                    return (obj as PDFBoolean).Value.ToString();
                case cosType.Integer:
                    return (obj as PDFInteger).Value.ToString();
                case cosType.Real:
                    return (obj as PDFReal).Value.ToString("0.###");
                case cosType.Name:
                    return (obj as PDFName).Value;
                case cosType.String:
                    return (obj as PDFString).Value;
                case cosType.Dict:
                    return "-dict-";
                case cosType.Stream:
                    return "-stream-";
                case cosType.Array:
                    {
                        var arrayObj = obj as PDFArray;
                        switch (arrayObj.Length)
                        {
                            case 6: return String.Format("[ {0} {1} {2} {3} {4} {5}]",
                                describeObject(arrayObj.Get(0)),
                                describeObject(arrayObj.Get(1)),
                                describeObject(arrayObj.Get(2)),
                                describeObject(arrayObj.Get(3)),
                                describeObject(arrayObj.Get(4)),
                                describeObject(arrayObj.Get(5)));
                            case 5: return String.Format("[ {0} {1} {2} {3} {4}]",
                                describeObject(arrayObj.Get(0)),
                                describeObject(arrayObj.Get(1)),
                                describeObject(arrayObj.Get(2)),
                                describeObject(arrayObj.Get(3)),
                                describeObject(arrayObj.Get(4)));
                            case 4: return String.Format("[ {0} {1} {2} {3}]",
                                describeObject(arrayObj.Get(0)),
                                describeObject(arrayObj.Get(1)),
                                describeObject(arrayObj.Get(2)),
                                describeObject(arrayObj.Get(3)));
                            case 3: return String.Format("[ {0} {1} {2}]",
                                describeObject(arrayObj.Get(0)),
                                describeObject(arrayObj.Get(1)),
                                describeObject(arrayObj.Get(2)));
                            case 2: return String.Format("[ {0} {1}]",
                                describeObject(arrayObj.Get(0)),
                                describeObject(arrayObj.Get(1)));
                            case 1: return String.Format("[ {0} ]",
                                describeObject(arrayObj.Get(0)));
                            case 0: return "[ ]";
                            default: return "-array-";
                        }
                    }
                default:
                    return "None";
            }
        }

        static void compareObjs(string path, PDFObject left, PDFObject right, ref HashSet<string> visited, ref HashSet<string> skipSet)
        {
            if (left != null && right != null && left.Indirect && right.Indirect)
            {
                var visitedTag = String.Format("{0}:{1}", left.ID, right.ID);
                if (visited.Contains(visitedTag))
                    return;
                else
                    visited.Add(visitedTag);
            }
            var leftType = GetObjType(left);
            var rightType = GetObjType(right);
            if (leftType != rightType)
            {
                if (leftType == cosType.Integer && rightType == cosType.Real)
                {
                    if ((double)(left as PDFInteger).Value != (right as PDFReal).Value)
                        Console.WriteLine("{0}: {1} vs. {2}", path, describeObject(left), describeObject(right));
                }
                else if (leftType == cosType.Real && rightType == cosType.Integer)
                {
                    if ((left as PDFReal).Value != (double)((right as PDFInteger).Value))
                        Console.WriteLine("{0}: {1} vs. {2}", path, describeObject(left), describeObject(right));
                }
                else
                {
                    Console.WriteLine("{0}: {1} vs. {2}", path, describeObject(left), describeObject(right));
                }
                return;
            }

            switch (leftType)
            {
                case cosType.Boolean:
                    {
                        var leftElem = left as PDFBoolean;
                        var rightElem = right as PDFBoolean;
                        if (leftElem.Value != rightElem.Value)
                        {
                            Console.WriteLine("{0}: {1} vs {2}", path, describeObject(left), describeObject(right));
                        }
                        return;
                    }

                case cosType.Integer:
                    {
                        var leftElem = left as PDFInteger;
                        var rightElem = right as PDFInteger;
                        if (leftElem.Value != rightElem.Value)
                        {
                            Console.WriteLine("{0}: {1} vs {2}", path, describeObject(left), describeObject(right));
                        }
                        return;
                    }
                case cosType.Real:
                    {
                        var leftElem = left as PDFReal;
                        var rightElem = right as PDFReal;
                        if (leftElem.Value != rightElem.Value)
                        {
                            Console.WriteLine("{0}: {1} vs {2}", path, describeObject(left), describeObject(right));
                        }
                        return;
                    }
                case cosType.Name:
                    {
                        var leftElem = left as PDFName;
                        var rightElem = right as PDFName;
                        if (!leftElem.Value.Equals(rightElem.Value))
                        {
                            Console.WriteLine("{0}: {1} vs {2}", path, describeObject(left), describeObject(right));
                        }
                        return;
                    }
                case cosType.String:
                    {
                        var leftElem = left as PDFString;
                        var rightElem = right as PDFString;
                        if (!leftElem.Value.Equals(rightElem.Value))
                        {
                            Console.WriteLine("{0}: {1} vs {2}", path, describeObject(left), describeObject(right));
                        }
                        return;
                    }
                case cosType.Array:
                    {
                        var leftElem = left as PDFArray;
                        var rightElem = right as PDFArray;
                        var leftLen = leftElem.Length;
                        var rightLen = rightElem.Length;
                        var compareLen = Math.Min(leftLen, rightLen);
                        if (leftLen != rightLen)
                            Console.WriteLine("{0}[]: Length is {1} vs {2}", path, leftLen, rightLen);
                        for (int i = 0; i < compareLen; i++)
                        {
                            var newPath = path + "[" + i.ToString() + "]";
                            compareObjs(newPath, leftElem.Get(i), rightElem.Get(i), ref visited, ref skipSet);
                        }
                        if (leftLen > compareLen)
                        {
                            for (int i = compareLen; i < leftLen; i++)
                            {
                                Console.WriteLine("{0}[{1}] << {2}", path, i, describeObject(leftElem.Get(i)));
                            }
                        }
                        else if (rightLen > compareLen)
                        {
                            for (int i = compareLen; i < rightLen; i++)
                            {
                                Console.WriteLine("{0}[{1}] >> {2}", path, i, describeObject(rightElem.Get(i)));
                            }
                        }
                        return;
                    }
                case cosType.Dict:
                    {
                        var leftElem = left as PDFDict;
                        var rightElem = right as PDFDict;
                        var leftKeys = getKeySet(leftElem);
                        var rightKeys = getKeySet(rightElem);
                        leftKeys.ExceptWith(skipSet);
                        rightKeys.ExceptWith(skipSet);
                        var compareKeys = getKeySet(leftElem);
                        compareKeys.IntersectWith(rightKeys);
                        leftKeys.ExceptWith(compareKeys);
                        rightKeys.ExceptWith(compareKeys);
                        foreach (var key in leftKeys)
                        {
                            Console.WriteLine("{0}:{1} << {2}", path, key, describeObject(leftElem.Get(key)));
                        }
                        foreach (var key in rightKeys)
                        {
                            Console.WriteLine("{0}:{1} >> {2}", path, key, describeObject(rightElem.Get(key)));
                        }
                        foreach (var key in compareKeys)
                        {
                            var newPath = path + ":" + key;
                            compareObjs(newPath, leftElem.Get(key), rightElem.Get(key), ref visited, ref skipSet);
                        }
                        return;
                    }
                case cosType.Stream:
                    {
                        var leftElem = left as PDFStream;
                        var rightElem = right as PDFStream;
                        var leftLen = leftElem.Length;
                        var rightLen = rightElem.Length;
                        if (leftLen != rightLen)
                            Console.WriteLine("{0}: Stream length is {1} vs {2}", path, leftLen, rightLen);
                        var leftKeys = getKeySet(leftElem.Dict);
                        var rightKeys = getKeySet(rightElem.Dict);
                        leftKeys.ExceptWith(skipSet);
                        rightKeys.ExceptWith(skipSet);
                        var compareKeys = getKeySet(leftElem.Dict);
                        compareKeys.IntersectWith(rightKeys);
                        leftKeys.ExceptWith(compareKeys);
                        rightKeys.ExceptWith(compareKeys);
                        foreach (var key in leftKeys)
                        {
                            Console.WriteLine("{0}:{1} << {2}", path, key, describeObject(leftElem.Dict.Get(key)));
                        }
                        foreach (var key in rightKeys)
                        {
                            Console.WriteLine("{0}:{1} >> {2}", path, key, describeObject(rightElem.Dict.Get(key)));
                        }
                        foreach (var key in compareKeys)
                        {
                            var newPath = path + ":" + key;
                            compareObjs(newPath, leftElem.Dict.Get(key), rightElem.Dict.Get(key), ref visited, ref skipSet);
                        }
                        return;
                    }
            }
        }

        static void Main(string[] args)
        {
            Console.WriteLine("comparePDFs:");

            string[] compareFiles = new string[2];
            compare comparisonLeft = compare.doc;
            compare comparisonRight = compare.doc;
            int numCompareFiles = 0;
            int leftID = -1, rightID = -1;
            string outFile = null;

            int n = 0;
            while (n < args.Length)
            {
                var arg = args[n++];
                switch (arg)
                {
                    case "-p": if (leftID == -1) comparisonLeft = compare.page; comparisonRight = compare.page; break;
                    case "-o": if (leftID == -1) comparisonLeft = compare.obj; comparisonRight = compare.obj; break;
                    case "-out": outFile = args[n++]; break;
                    default:
                        {
                            int num;
                            bool isNumeric = Int32.TryParse(arg, out num);
                            if (isNumeric)
                            {
                                if (leftID == -1)
                                    leftID = num;
                                else
                                    rightID = num;
                            }
                            else if (System.IO.File.Exists(arg))
                            {
                                compareFiles[numCompareFiles++] = arg;
                            }
                        }
                        break;
                }
            }
            if ((comparisonLeft == compare.doc && numCompareFiles < 2) ||
                (comparisonLeft != compare.doc && rightID == -1))
            {
                Console.WriteLine("Usage: file1 [-o|-p id1] [file2 | [-o|-p][ id2]] [-out outfile]");
                return;
            }

            using (Library lib = new Library())
            {
                Console.WriteLine("Initialized the library.");

                var visited = new HashSet<string>();
                var rootSkipSet = new HashSet<string>();
                var pageSkipSet = new HashSet<string>();

                rootSkipSet.Add("Pages");
                rootSkipSet.Add("Metadata");

                pageSkipSet.Add("Parent");

                try
                {
                    FileStream ostrm = null;
                    StreamWriter writer = null;
                    TextWriter oldOut = Console.Out;
                    if (outFile != null)
                    {
                        try
                        {
                            ostrm = new FileStream(outFile, FileMode.OpenOrCreate, FileAccess.Write);
                            writer = new StreamWriter(ostrm);
                            Console.SetOut(writer);
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Error: Cannot open {0} for writing: {1}", outFile, ex.Message);
                            return;
                        }
                    }
                    var docLeft = new Document(compareFiles[0]);
                    var docRight = new Document(compareFiles[numCompareFiles - 1]);
                    Console.WriteLine("{0} << vs. >> {1}", compareFiles[0], compareFiles[numCompareFiles - 1]);

                    if (comparisonLeft == compare.doc)
                    {
                        compareObjs("Root", docLeft.Root, docRight.Root, ref visited, ref rootSkipSet);
                        //TODO: Enumeration of NameTrees, NumberTrees.
                        int pagesLeft = docLeft.NumPages;
                        int pagesRight = docRight.NumPages;
                        var comparePages = Math.Min(pagesLeft, pagesRight);

                        for (int i = 0; i < comparePages; i++)
                        {
                            var path = String.Format("Page[{0}]", i);
                            compareObjs(path, docLeft.GetPage(i).PDFDict, docRight.GetPage(i).PDFDict, ref visited, ref pageSkipSet);
                        }
                    }
                    else
                    {
                        var label = String.Format("{0} {1} vs. {2} {3}",
                            comparisonLeft == compare.obj ? "Obj" : "Page",
                            leftID,
                            comparisonRight == compare.obj ? "Obj" : "Page",
                            rightID);
                        PDFObject leftObj = (comparisonLeft == compare.obj ? docLeft.FindPDFObjectByID(leftID) : docLeft.GetPage(leftID).PDFDict);
                        PDFObject rightObj = (comparisonRight == compare.obj ? docRight.FindPDFObjectByID(rightID) : docRight.GetPage(rightID).PDFDict);
                        compareObjs(label, leftObj, rightObj, ref visited, ref pageSkipSet);
                    }
                    
                    try
                    {
                        docLeft.Close(); 
                        docRight.Close();
                    }
                    catch (ApplicationException ex) { }

                    if (outFile != null)
                    {
                        Console.SetOut(oldOut);
                        writer.Close();
                        ostrm.Close();
                    }
                }
                catch (LibraryException ex)
                {
                    Console.WriteLine("** Error: {0}", ex.Message);
                }
            }

            Console.WriteLine("Done.");
        }
    }
}