Discussion :

[JoSii]

Bonjour,

Pour réaliser une fonction d'impression avec DotNET c'est très simple.
Mais je rencontre un souci lors de l'impression vers une imprimante virtuelle PDF (type Adobe, CutePDF...) lorsque je veux imprimer une grosse image.
Le temps de conversion est trèèèèèèès long... (de l'ordre de plusieurs minutes)

Voila le code qui réalise l'impression :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/// <summary>
        /// Dessine l'image contenue dans le cadre si il y en a.
        /// Sinon affiche une information textuelle pour ouvrir une image
        /// </summary>
        /// <param name="g">Graphics sur lequel dessiner</param>
        public override void Draw(ISGGraphics g)
        {
            base.Draw(g);
            //Dessin de l'image contenue dans le calque
            if (imgLayerContent != null)
                g.DrawImage(imgLayerContent,0,0, imgLayerContent.Width, imgLayerContent.Height);
            else //Dessin de l'information textuelle si le calque est sélectionné et si ce n'est pas une impression
            {
                if (Selected && !bPrinting)
                {
                    string sText = "Dessinez un cercle ici pour sélectionner une image à afficher";
                    Size sizePage = Mediator.get().getCurrentPage().PageSize;
                    using (Font font = new Font("Tahoma", 30))
                    {
                        SizeF sizeString = g.MeasureString(sText, font);
                        g.DrawString(sText, font, Brushes.Gray, (sizePage.Width - sizeString.Width) / 2, (sizePage.Height - sizeString.Height) / 2, StringFormat.GenericDefault);
                    }
                }
 
            }
        }

Connaitriez vous un moyen d'optimiser l'impression afin que la conversion vers un fichier PDF (lorsque l'on imprime sur une imprimante virtuelle PDF) devienne raisonnable ?

Merci pour votre aide.

JoSii

[olibara]

Ca me semble bizarre, personnelement j'utilise pdf995 et j'ai aujourd'hui "imprimé" un DGV de 58 pages en moins de 15 secondes

Maintenant si ton image fait 2 GB ca rique de peiner un peu

[JoSii]

Ce sont des images qui pèsent plusieurs Mo (>= 2Mo)
Je trouve ça étonnant que ça prenne autant de temps pour ma fonction d'impression... :/

[olibara]

Et quelle est la taille Hauteur Largeur ?

Pas impossible que ton PDF rame a faire le sizing ?

[JoSii]

Tu as peut-être mis le doigt là ou ça pose problème en effet.
Pour répondre à ta question mon image test est une image jpg de taille 3928 x 2810 pixel avec une résolution de 96 dpi.
Lorsque j'imprime je fais tout un tas de transformation de Graphics... je mets le code au cas ou il serait possible de l'optimiser afin que l'impression vers un PDF en soit grandement accélérée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/// <summary>
        /// Réalise l'impression d'une page
        /// </summary>
        /// <param name="pageNumber">le numéro de la page à imprimer</param>
        /// <param name="e">les arguments d'impression</param>
        public void printPage(int pageNumber, PrintPageEventArgs e)
        {
            if (document == null)
                return;
 
            Page currentPage = document.getPage(pageNumber);
            //On récupère la taille de la page
            Size currentPageSize = currentPage.PageSize;
            //On vérifie si la page a plutôt intérêt à être affichée en Portrait ou Paysage
            bool bLandscape = currentPageSize.Width > currentPageSize.Height;
            Matrix mG = e.Graphics.Transform;
            e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
            //On récupère le point origine dans la feuille
            Point pOrigine = e.MarginBounds.Location;
            //On translate le graphics sur l'origine de la feuille en portait ou paysage
            if (bLandscape)
            {
                e.Graphics.TranslateTransform(pOrigine.X, pOrigine.Y + e.MarginBounds.Height);
                e.Graphics.RotateTransform(-90);
            }
            else
                e.Graphics.TranslateTransform(pOrigine.X, pOrigine.Y);
            //On calcul le facteur de zoom sur les X et les Y pour que la page prenne la taille de la feuille en portrait ou paysage 
            //en fonction de la forme de la page
            float zoomX, zoomY, zoomFactor;
            if (!bLandscape)
            {
                zoomX = (float)(e.MarginBounds.Width) / (float)(currentPageSize.Width);
                zoomY = (float)(e.MarginBounds.Height) / (float)(currentPageSize.Height);
            }
            else
            {
                zoomX = (float)(e.MarginBounds.Width) / (float)(currentPageSize.Height);
                zoomY = (float)(e.MarginBounds.Height) / (float)(currentPageSize.Width);
            }
            zoomFactor = Math.Min(zoomX, zoomY);
 
            GdiGraphics gg = new GdiGraphics(e.Graphics);
 
            //Cas n°1 : La page est plus petite que la feuille
            //Dans ce cas les deux facteur de zoom sont supérieurs à 1
            if (zoomX >= 1 && zoomY >= 1)
            {
                //La page est centrée dans la feuille
 
                if (bLandscape)
                    gg.TranslateTransform((e.MarginBounds.Height - currentPageSize.Width) / 2, (e.MarginBounds.Width - currentPageSize.Height) / 2);
                else
                    gg.TranslateTransform((e.MarginBounds.Width - currentPageSize.Width) / 2, (e.MarginBounds.Height - currentPageSize.Height) / 2);
 
            }
            //Cas n°2 : La page est plus grande que la feuille
            //Dans ce cas on la redimensionne pour qu'elle tienne dans la feuille et on la centre
            else 
            {
                if (bLandscape)
                    gg.TranslateTransform((e.MarginBounds.Height - currentPageSize.Width * zoomFactor) / 2, 0);
                else
                    gg.TranslateTransform(0, (e.MarginBounds.Height - currentPageSize.Height * zoomFactor) / 2);
 
                gg.ScaleTransform(zoomFactor, zoomFactor);
 
            }
 
            pageRenderer.Draw(gg, currentPage);
 
            e.Graphics.Transform = mG;
        }

pageRenderer.Draw(gg, currentPage); appelle la fonction donnée ci dessus dans mon premier post.

Est-il possible que ce soit toutes ces transformations qui posent porbleme lors de l'impression vers une imprimante virtuelle pdf ?

[arasium]

Sinon, pourquoi n'essai tu pas d'enregistrer l'image sur le disque et de tenter l'impression à la main, tu pourras ainsi savoir si ton traitement est déja lent. Car en théorie, ce n'est pas ton C# qui fait ralentir le process mais ce serai plutot ton imprimante virtuelle. Si c'est bel et bien ton imprimante, je ne pense pas que tu puisse y faire grand chose.

[olibara]

Je partage cet avis !
Et si c'est le cas tu peux essayer de reduire son image avant de l'imprimer

[JoSii]

Sinon, pourquoi n'essai tu pas d'enregistrer l'image sur le disque et de tenter l'impression à la main, tu pourras ainsi savoir si ton traitement est déja lent. Car en théorie, ce n'est pas ton C# qui fait ralentir le process mais ce serai plutot ton imprimante virtuelle. Si c'est bel et bien ton imprimante, je ne pense pas que tu puisse y faire grand chose.

J'ai essayé d'imprimer l'image à la main sur l'imprimante virtuelle PDF et l'impression se fait instantanément...
Je vais traiter de réduire la taille de l'image avant de lancer l'impression voir si ça corrigerais le problème.
Merci pour votre aide.