Les mauvaises performances de convertir tif en pdf à l'aide de ITextSharp

Résumé: Comment puis-je réduire la quantité de temps qu'il faut pour convertir le fil de fichiers pdf à l'aide itextsharp?

De fond: je suis la conversion d'une partie assez grande tif est au format pdf à l'aide de C# et itextsharp, et j'en suis très mauvais rendement. Les fichiers tiff sont environ 50ko un morceau, et certains documents ont jusqu'à 150 séparer les fichiers tif (représentant chacune une page). Pour une page 132 document (~6500 ko), il a fallu environ 13 minutes pour convertir. Lors de la conversion, le CPU seul serveur, il a été en cours d'exécution sur à 100%, m'amenant à croire que le processus a été liée à l'UC. Le fichier de sortie pdf 3,5 MO. Je suis ok avec la taille, mais le temps semble un peu élevé pour moi.

Code:

private void CombineAndConvertTif(IList<FileInfo> inputFiles, FileInfo outputFile)
{
    using (FileStream fs = new FileStream(outputFile.FullName, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
    {
        Document document = new Document(PageSize.A4, 50, 50, 50, 50);
        PdfWriter writer = PdfWriter.GetInstance(document, fs);
        document.Open();
        PdfContentByte cb = writer.DirectContent;

        foreach (FileInfo inputFile in inputFiles)
        {
            using (Bitmap bm = new Bitmap(inputFile.FullName))
            {
                int total = bm.GetFrameCount(FrameDimension.Page);

                for (int k = 0; k < total; ++k)
                {
                    bm.SelectActiveFrame(FrameDimension.Page, k);
                    //Testing shows that this line takes the lion's share (80%) of the time involved.
                    iTextSharp.text.Image img =
                        iTextSharp.text.Image.GetInstance(bm, null, true);
                    img.ScalePercent(72f / 200f * 100);
                    img.SetAbsolutePosition(0, 0);

                    cb.AddImage(img);
                    document.NewPage();
                }
            }
        }

        document.Close();
        writer.Close();
    }

}

InformationsquelleAutor C. Ross | 2009-12-30

c#itextsharp performance

11

Modifier la méthode GetInstance argument
```
GetInstance(bm, ImageFormat.Tiff) 
```
ce qui pourrait augmenter la performance
```
iTextSharp.text.Image img =  iTextSharp.text.Image.GetInstance(bm, ImageFormat.Tiff);
```
- Je ne suis pas sûr que pourquoi ça fonctionne, mais ça fonctionne.
- Fait une ÉNORME différence. 800ms par image en bas à 5ms dans mon cas.
- a travaillé pour moi aussi... j'ai utilisé ImageFormat.PNG au lieu de Tiff... quelqu'un a une explication de pourquoi est si rapide?
InformationsquelleAutor

Je ne suis pas sûr de ce qui était disponible lorsque cette question a été posté, mais il semble que iText 5.x a plus à offrir lors de la conversion de TIFF de PDF. Il y a aussi un code de base de l'échantillon dans iText en Action, 2e Édition "part3.chapter10.PagedImages" et je n'ai pas remarqué de problèmes de performances. Cependant, il n'a pas vraiment poignée de mise à l'échelle et bien alors je l'ai changé comme ceci:

public static void AddTiff(Document pdfDocument, Rectangle pdfPageSize, String tiffPath)
{
    RandomAccessFileOrArray ra = new RandomAccessFileOrArray(tiffPath);
    int pageCount = TiffImage.GetNumberOfPages(ra);

    for (int i = 1; i <= pageCount; i++) 
    {
        Image img = TiffImage.GetTiffImage(ra, i);

        if (img.ScaledWidth > pdfPageSize.Width || img.ScaledHeight > pdfPageSize.Height)
        {
            if (img.DpiX != 0 && img.DpiY != 0 && img.DpiX != img.DpiY)
            {
                img.ScalePercent(100f);
                float percentX = (pdfPageSize.Width * 100) / img.ScaledWidth;
                float percentY = (pdfPageSize.Height * 100) / img.ScaledHeight;

                img.ScalePercent(percentX, percentY);
                img.WidthPercentage = 0;
            }
            else
            {
                img.ScaleToFit(pdfPageSize.Width, pdfPageSize.Height);
            }
        }

        Rectangle pageRect = new Rectangle(0, 0, img.ScaledWidth, img.ScaledHeight);

        pdfDocument.SetPageSize(pageRect);
        pdfDocument.SetMargins(0, 0, 0, 0);
        pdfDocument.NewPage();
        pdfDocument.Add(img);
    }
}

InformationsquelleAutor Mathew Leger

3

Le problème, c'est avec le temps qu'il faut pour iTextSharp à la finition de déconner avec votre Système.De dessin.L'Image de l'objet.

À cette vitesse jusqu'à littéralement un 10ème de seconde à quelques tests, j'ai couru vous avez besoin pour enregistrer l'image sélectionnée à un flux de mémoire et de passer ensuite le tableau d'octets de données directement à la méthode GetInstance dans iTextSharp, voir ci-dessous...
```
bm.SelectActiveFrame(FrameDimension.Page, k);

iTextSharp.text.Image img;
using(System.IO.MemoryStream mem = new System.IO.MemoryStream())
{
    //This jumps all the inbuilt processing iTextSharp will perform
    //This will create a larger pdf though
    bm.Save(mem, System.Drawing.Imaging.ImageFormat.Png);
    img = iTextSharp.text.Image.GetInstance(mem.ToArray());
}

img.ScalePercent(72f / 200f * 100);
```
InformationsquelleAutor Craig McNicholas
2

Vous êtes à croquer tout à fait un grand nombre de données, de sorte que si l'exportation en PDF le processus est lent, et vous n'êtes pas à l'aide d'un PC rapide, alors vous pourriez être coincé avec ce genre de performance.

Le moyen le plus évident pour accélérer le processus sur un système multi-core serait de multi-thread il.

Diviser le code en deux étapes. Tout d'abord, une série d'images qui peuvent être convertis et stockés dans une liste, la liste peut être sortie de la PDF. Avec la taille des fichiers que vous êtes en train de parler, l'utilisation de la mémoire pour stocker l'intégralité du document en mémoire pendant le traitement ne devrait pas être un problème.

Vous pouvez alors faire la première étape de ce processus multi-thread - vous pourrait déclencher un pool de threads thread pour chaque image doit être convertie, en plafonnant le nombre de threads actifs (roughtly un par cœur de PROCESSEUR suffit plus de ne pas obtenir beaucoup). Aln alternative est de diviser votre liste d'entrées dans n listes (de nouveau, une liste par cœur de PROCESSEUR) et puis le feu hors de threads que de simplement traiter leur propre liste. Cela réduit le filetage des frais généraux, mais peut entraîner dans certains threds la finition d'un long temps avant que d'autres (si leur charge de travail s'avère être beaucoup moins) de sorte qu'il ne peut pas toujours tout à fait aussi rapide.

Par de le diviser en deux passes vous peut également le gain de performance (même sans mutlithreading) en faisant tout le traitement de l'input et puis tout le traitement de sortie comme des étapes distinctes, qui sera probablement de réduire le disque de recherche impliqués (selon la quantité de RAM dont vous disposez pour les caches disque sur votre PC).

Noter que mutithreading il ne sera pas d'une grande utilité si vous n'avez qu'un seul core CPU (même si l'on pouvait encore voir des gains dans certaines parties du processus d'I/O bound, on dirait que vous vous êtes principalement en CPU).

Vous pouvez également expérimenter avec le redimensionnement de l'image bitmap en utilisant quelque chose d'autre que itextsharp appels - je ne sais rien à propos de itextsharp mais il est possible que son image le code de conversion est lente, ou de ne pas faire usage de matériel graphique dans une manière que d'autres techniques de mise à l'échelle peut être en mesure de. Il peut également y être mise à l'échelle des options que vous pouvez définir qui vous donnera un compromis entre la qualité et la vitesse que vous pourriez essayer.
- Je suis en cours d'exécution sur une vieille saleté seul serveur de base, malheureusement. Sinon, en voyant la CPU, de la nature, je n'hésiterais pas à le diviser. Dans cette situation, les autres threads aurait probablement un <i>négatif</i> effet. Merci pour la réponse idéale si.
InformationsquelleAutor Jason Williams
1

J'ai eu exactement ce problème. J'ai fini à l'aide d'Adobe Acrobat option Traitement par Lots ce qui a bien fonctionné. Je viens de mettre en place un nouveau Processus de traitement par Lots qui convertit tous les fichiers tiff dans un dossier cible pour les fichiers Pdf écrite à un dossier de destination et l'a commencée. Il était facile à mettre en place mais le traitement a duré plus longtemps que j'ai aimé. Il l'a fait faire le travail.

Malheureusement Adobe Acrobat n'est pas gratuit, mais vous devriez en tenir compte (peser le coût de votre temps pour développer un "libre" de la solution par rapport au coût du logiciel).
- Malheureusement, cela ne résout pas ce problème, parce que les fichiers Pdf doivent être combinées dans le processus.
InformationsquelleAutor Jay Riggs
0
```
//Testing shows that this line takes the lion's share (80%) of the time involved.
iTextSharp.text.Image img =
  iTextSharp.text.Image.GetInstance(bm, null, true);
```
Peut-être stupide suggestion (ne pas avoir un grand testset droit maintenant pour l'essayer en local), mais donnez-moi le bénéfice du doute:

Vous êtes une boucle dans un multitiff ici, la sélection d'image après image. bm est cette (énorme, 6,5 M) de l'image dans la mémoire. Je ne sais pas assez sur iTextSharps interne de traitement d'image, mais peut-être que vous pouvez aider ici en fournissant seulement une seule image de la page ici?
Pouvez-vous essayer de créer une nouvelle image de la taille désirée, dessin bm sur elle (voir les options de l'objet Graphique pour les propriétés liées à la vitesse: InterpolationMode par exemple) et en le passant dans cette seule image au lieu de l'énorme chose pour chaque appel?

InformationsquelleAutor Benjamin Podszun

Basé sur vos échantillons, j'ai fait une fonction qui fait les deux, basé sur une simple Énumération, vous définissez le mode de travail, le voici: c'est

private static void CombineAndConvertTif(FileInfo inputFile, FileInfo outputFile)
{
Encoder myEncoder = Encoder.Quality;
EncoderParameters myEncoderParameters = new EncoderParameters(1);
EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 50L);
myEncoderParameters.Param[0] = myEncoderParameter;
ImageCodecInfo jgpEncoder = GetEncoder(ImageFormat.Jpeg);
Console.Write("Converting {0} to {1}... ", inputFile.Name, outputFile.Name);
Stopwatch sw = Stopwatch.StartNew();
using (
FileStream fs = new FileStream(
outputFile.FullName, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
Document document = new Document(PageSize.A4, 50, 50, 50, 50);
PdfWriter writer = PdfWriter.GetInstance(document, fs);
writer.CompressionLevel = 100;
writer.SetFullCompression();
document.Open();
PdfContentByte cb = writer.DirectContent;
using (Bitmap bm = new Bitmap(inputFile.FullName))
{
int pages = bm.GetFrameCount(FrameDimension.Page);
for (int currentPage = 0; currentPage < pages; ++currentPage)
{
bm.SelectActiveFrame(FrameDimension.Page, currentPage);
bm.SetResolution(96, 96);
Image img;
if (QualityMode == QualityMode.Slow)
{
#region Low speed, smaller files
img = iTextSharp.text.Image.GetInstance(bm, null, true);
#endregion
}
else
{
#region Fast speed, bigger files
using (MemoryStream mem = new MemoryStream())
{
bm.Save(mem, jgpEncoder, myEncoderParameters);
img = Image.GetInstance(mem.ToArray());
}
#endregion
}
img.ScalePercent(72f / 200f * 100);
img.SetAbsolutePosition(0, 0);
cb.AddImage(img);
document.NewPage();
}
}
document.Close();
writer.Close();
}
sw.Stop();
Console.WriteLine(" time: {0}", sw.Elapsed);
}

Et l'enum est:

    internal enum QualityMode
{
///<summary>
///Process images quickly but
///produces bigger PDFs
///</summary>
Fast,
///<summary>
///Process images slower but
///produces smaller PDFs
///</summary>
Slow
}

InformationsquelleAutor coloboxp

Vous devez vous connecter pour publier un commentaire.