3-Heights™ PDF Validator – vérifier des fichier PDF et PDF/A à leur conformité

Le 3-Heights™ PDF Validator sert au contrôle de qualité de documents PDF et des processus qui les produisent. Les documents sont vérifiés quant à leur conformité avec les normes ISO pour PDF et PDF/A.

PDF est un format largement répandu. Par conséquent il est important que l’interopérabilité soit assurée. En particulier dans le cas d’informations importantes pour l’entreprise ou d’informations qui doivent être archivées, il faut vérifier que les documents soient corrects et qu’ils soient lisibles à long terme. Cette tâche précisément est assumée par le Validator, que ce soit pour des documents individuels ou en traitement par lots.

Vérification

Vérification de la conformité des documents à la norme PDF et PDF/A

Archives numériques à long terme

Intégrer dans des systèmes d’archivage

Contrôle qualité

Assurer les directives de l’entreprise

Bayer CropScience mise sur le format d’archivage à long terme PDF/A

Cette transformation est avantageuse pour le client à plusieurs titres : contrairement aux pages TIFF, il est possible d’effectuer des recherches dans les documents PDF et d’en copier/coller le contenu. De plus, l’index peut être utilisé pour naviguer rapidement dans le document.

3-Heights™ PDF Validator verifies electronic insurance applications

Electronic insurance applications were previously transferred as normal PDF documents, resulting in the necessity for a hand-written signature on paper. This process has been simplified with the implementation of the Signature Pad and the change to PDF/A format.

Illustration du produit 3-Heights™ PDF Validator

PDF Validator - fonctions

  • Valider les documents PDF sur la base de diverses spécifications PDF (PDF1.x, PDF 2.0, PDF/A-1, PDF/A-2, PDF/A-3)
  • Contrôles lexicaux, syntaxiques et sémantiques dépendant de la conformité PDF
  • Rapports détaillés ou résumés (log file)
  • Description détaillée de l'erreur (numéro, type, description, objet PDF, numéro de page)
  • Classification par erreurs, avertissements et informations
  • En option interruption de la validation après l’apparition de la première erreur
  • Lecture de documents PDF cryptés
  • Déterminer la conformité déclarée du document
  • Valider la conformité avec les directives définies dans le profil personnalisé
  • Lire ou écrire un document à partir d'un fichier, d'une mémoire ou d'un flux
Graphique fonctionnel 3-Heights™ PDF Validator

Conformité

  • Standards:
    • ISO 32000-1 (PDF 1.7)
    • ISO 32000-2 (PDF 2.0)
    • ISO 19005-1 (PDF/A-1)
    • ISO 19005-2 (PDF/A-2)
    • ISO 19005-3 (PDF/A-3)
  • Assurance qualité : veraPDF test corpus and Isartor test suite

Formats supportée

Formats d’entrée

  • PDF 1.3 à 1.7
  • PDF 2.0
  • PDF/A-1a, PDF/A-1b
  • PDF/A-2a, PDF/A-2b, PDF/A-2u
  • PDF/A-3a, PDF/A-3b, PDF/A-3u
        Loupe grossissante pour nos manuels PDF et notre exemple de code PDF

        MANUELS

        API | Shell

        Domaines d'application - validation et contrôle de la qualité des documents PDF et PDF/A

        Entrée du courrier

        Dans le courrier entrant le Validator vérifie les documents quant aux exigences minimales requises, par exemple concernant la sécurité, la conformité, la reproductibilité ou la standardisation (PDF/A + PDF). Les documents non conformes sont refusés.

        Archivage

        Dans les archives le module joue le rôle d’un « portier » : les documents qui ne correspondent pas au standard sont refusés. Le Validator peut aussi être employé pour le contrôle de qualité d’archives existantes et pour l’assurance qualité lors de la conversion d’archives TIFF vers PDF/A.

        Sortie du courrier

        Dans le courrier sortant, la qualité des documents PDF est vérifiée avant leur envoi. Les directives du destinataire sont également prises en compte.

        Gestion de la qualité

        Le Validator peut être utilisé dans la gestion de la qualité. L’on peut ainsi contrôler l’observation des directives de l’entreprise (CI) ou la conformité en général p.ex. après la conversion d’un autre format.

        Fabricants de logiciels/OEM

        Le Validator sert au contrôle des données entrantes et sortantes dans des applications telles que p.ex. les systèmes de workflow, les systèmes DMS et les logiciels d’application pour les signatures (“you sign what you see”).

        Check if document meets a specific compliance

        Select a PDF/A compliance level and check whether the input PDF document it is compliant or not. In case it is not compliant, get a detailed description of the compliance violations.

        l'exemple C# :
        // Create the validator
        using (PdfValidator validator = new PdfValidator())
        {
            // Open input file
            if (!validator.Open(inputPath, "", complianceLevel))
                throw new Exception(String.Format("Input file {0} cannot be opened. " + 
                    "{1} (ErrorCode: 0x{2:x}).", inputPath, validator.ErrorMessage, validator.ErrorCode));
        
            // Validate document
            // If true, the PDF is compliant to the specified compliance level.
            // If false, the validation either aborted or the PDF is not compliant to 
            // the specified compliance level.
            if (!validator.Validate())
            {
                if (validator.ErrorCode == PDFErrorCode.PDF_E_CONFORMANCE)
                {
                    Console.WriteLine("Document {0} is not {1} compliant.", inputPath, 
                        compliance);
        
                    // Print compliance violations
                    PdfError currError = validator.GetFirstError();
                    while (currError != null)
                    {
                        Console.WriteLine("Page: {0}, Object: {1}, {2}", currError.PageNo, 
                            currError.ObjectNo, currError.Message);
                        currError = validator.GetNextError();
                    }
                }
                else
                    throw new Exception(String.Format("Validation of {0} was aborted. {1} " + 
                        "(ErrorCode: 0x{2:x}).", inputPath, validator.ErrorMessage, validator.ErrorCode));
            }
            else
                Console.WriteLine("Document {0} is {1} compliant.", inputPath, compliance);
        
            // Close input file
            validator.Close();
        }
        
        l'exemple Java :
        // Create the validator
        validator = new PdfValidatorAPI();
        
        // Open input file
        if (!validator.open(inputPath, "", complianceLevel))
            throw new IOException(String.format("Input file %s cannot be opened. %s (ErrorCode: 0x%08x).", 
                inputPath, validator.getErrorMessage(), validator.getErrorCode()));
        
        // Validate document
        // If true, the PDF is compliant to the specified compliance level.
        // If false, the validation either aborted or the PDF is not compliant to 
        // the specified compliance level.
        if (!validator.validate())       
        {
            if (validator.getErrorCode() == NativeLibrary.ERRORCODE.PDF_E_CONFORMANCE)
            {
                System.out.printf("Document %s is not %s compliant.\n", inputPath, compliance);
        
                // Print compliance violations
                PdfError currError = validator.getFirstError();
                while (currError != null)
                {
                    System.out.printf("Page: %d, Object: %s, %s\n", currError.getPageNo(), 
                        currError.getObjectNo(), currError.getMessage());
                    currError = validator.getNextError();
                }
            }
            else
                throw new IOException(String.format("Validation of %s was aborted. %s (ErrorCode: 0x%08x).",
                    inputPath, validator.getErrorMessage(), validator.getErrorCode()));
        }
        else
            System.out.printf("Document %s is %s compliant.\n", inputPath, compliance);
        
        // Close input file
        validator.close();
        
        l'exemple C :
        // Create the validator
        pValidator = PdfValidatorCreateObject();
        
        // Open input file
        if (!PdfValidatorOpen(pValidator, szInputPath, _T(""), iCompliance))
        {
            _tprintf(_T("Input file %s cannot be opened. %s (ErrorCode: 0x%08x).\n"), szInputPath, PdfValidatorGetErrorMessage(pValidator), PdfValidatorGetErrorCode(pValidator));
            iReturnValue = 1;
            goto cleanup;
        }
        
        // Validate document
        // If true, the PDF is compliant to the specified compliance level.
        // If false, the validation either aborted or the PDF is not compliant to 
        // the specified compliance level.
        if (!PdfValidatorValidate(pValidator))
        {
            if (PdfValidatorGetErrorCode(pValidator) == PDF_E_CONFORMANCE)
            {
                _tprintf(_T("Document %s is not %s compliant.\n"), szInputPath, szCompliance);
        
                // Print compliance violations
                pCurrError = PdfValidatorGetFirstError(pValidator);
                while (pCurrError != NULL)
                {
                    int nBufSize = PdfValidatorErrorGetMessage(pCurrError, NULL, 0);
                    TCHAR* szErrorBuff = malloc(nBufSize*sizeof(TCHAR));
                    PdfValidatorErrorGetMessage(pCurrError, szErrorBuff, nBufSize);
                    _tprintf(_T("Page: %d, Object: %d, %s\n"), PdfValidatorErrorGetPageNo(pCurrError), PdfValidatorErrorGetObjectNo(pCurrError), szErrorBuff);
                    pCurrError = PdfValidatorGetNextError(pValidator);
                    free(szErrorBuff);
                }
            }
            else
            {
                _tprintf(_T("Validation of %s was aborted. %s (ErrorCode: 0x%08x).\n"), szInputPath, PdfValidatorGetErrorMessage(pValidator), PdfValidatorGetErrorCode(pValidator));
            }
        }
        else
        {
            _tprintf(_T("Document %s is %s compliant.\n"), szInputPath, szCompliance);
        }
        
        // Close input file 
        PdfValidatorClose(pValidator);
        
        PDF Expert Blog - trust in PDF validation software

        Can I trust PDF validation software?

        If I use validation software from different manufacturers I sometimes get different results. Why can this happen? Does it mean that I can't trust the software? What can I do about it? I hear these and more questions very often and I can understand the user's concerns...