Discussion :

[bug38]

Je cherche à réaliser des impressions et leur aperçus en respectant la résolution de l'imprimante.
Pour l'instant, j'arrive à sauvegarder des fichiers images suivant une résolution donnée. J'envisage pour l'instant d'écrire une API C pour imprimer ses fichiers car je n'ai pas réussi à trouver la méthode en java pour pouvoir imprimer ses fichiers à la bonne résolution. Je me suis attaqué ensuite au problème de l'aperçu avant impression. J'ai un objet de rendu qui implémente une méthode draw(Graphics2D graphics, int width, int height) qui fait un rendu en fonction des dimensions du rectangle. Ainsi pour le preview, j'applique un scale sur le graphics que je transmet à cette méthode. Tout marche bien sauf pour l'affichage du texte qui n'est pas du tout à l'échelle.

La méthode la plus facile est d'introduire un paramètre fontScale qui permet de corriger la taille de police. Mais on se retrouve avec une taille de police modulo point (1/72 d'inches).

J'ai donc tenté d'émuler dans l'objet Graphics une résolution autre que du 72 DPI.

J'ai essayé de redéfinir un FontRenderContext avec une transformation personnalisée mais apparemment cette transformation est systématiquement ignorée par les API utilisant un FontRenderContext (comme les TextLayout par exemple).


Finalement, j'en suis arrivé à écrire une méthode :

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
 
public static void drawText(Graphics2D g, Font font, FontRenderContext frc, String text, int x, int y){
            TextLayout textLayout = new TextLayout(text, g.getFont(), frc);
            Rectangle rect = textLayout.getBounds().getBounds();
 
           int offset = x;
 
           char [] car = new char[1];
           for (int i = 0; i < text.length(); i++){
               text.getChars(i, i+1, car, 0);
               GlyphVector vector = font.createGlyphVector(frc, car);
               int w = vector.getGlyphMetrics(0).getBounds2D().getBounds().width;
 
 
               Shape temp;
               int avance = 0;
               if (frc.isTransformed()){
                   temp = vector.getGlyphOutline(0);
                   AffineTransform tr = frc.getTransform();
                   PathIterator iter = temp.getPathIterator(tr);
                   Path2D.Double path = new Path2D.Double();
                   path.append(iter, false);
                   g.translate(offset, y);
                   g.fill(path);
                   g.translate(-offset, -y);
                   Point2D.Float pt = new Point2D.Float(vector.getGlyphMetrics(0).getAdvanceX(), 0.0f);
                   Point2D.Float res = new Point2D.Float();
                   tr.transform(pt, res);
                   avance = (int)res.x;
 
 
               }
               else {
                   temp = vector.getGlyphOutline(0, offset, y);
                   avance = (int)vector.getGlyphMetrics(0).getAdvanceX();
               }
               offset += avance;
               g.fill(temp);
           }
        }

Existe-t'il une méthode plus facile pour émuler l'affichage du texte dans une résolution autre qu'en 72 DPI (la seule résolution qui me semble possible sur les objets Graphics) ?
Existe-t'il une API pour réaliser des impressions et des aperçus à des résolutions conforme aux imprimantes actuelles (ex 1200 DPI, etc...)?

[bouye]

72 ? Euh il me semble que cela fait deja un certain temps que la plupart des Windows sont en 96 ou 120 (suivant le reglage de la taille des polices dans les options d'affichage).

En fouillant un peu j'ai trouve ca, en esperant que cela puisse t'aider :

DPI et affichage dans Java 6 :
http://weblogs.java.net/blog/kirillc...n_the_des.html

Impression :
http://www.velocityreviews.com/forum...-printing.html

Sauvegarde d'image en specifiant le DPI :
http://www.tracemodeler.com/blog/200...java-image-io/
http://forum.java.sun.com/thread.jsp...sageID=3071109

[bug38]

Bonjour et merci pour les liens.. Cela m'a bien aidé.

Par contre, même si le système est en 96 DPI, il semblerait que Java2D soit toujours en 72 DPI pour les polices de caractères si j'en crois la FAQ SUN :
http://java.sun.com/products/java-me...ferent_ways_th

Q: Why does (eg) a 10 pt font in Java applications appear to have a different size from the same font at 10pt in a native application?

A: Conversion from the size in points into device pixels depends on device resolution as reported by the platform APIs. Java 2D defaults to assuming 72 dpi. Platform defaults vary. Mac OS also uses 72 dpi. Linux desktops based on GTK (Gnome) or Qt (KDE) typically default to 96 dpi and let the end-user customise what they want to use. Windows defaults to 96 dpi (VGA resolution) and also offers 120 dpi (large fonts size) and lets users further specify a custom resolution. So a couple of things can now be seen

* The DPI reported by platform APIs likely has no correspondence to the true DPI

of the display device

* Its unlikely that Java 2D's default matches the platform default.

So a typical results is that for Window's default 96 DPI that a 10 pt font in a Java application is 72/96 of the size of the native counterpart.

Note that Swing's Windows and GTK L&Fs do scale fonts based on the system DPI to match the desktop. If you want to do the same in your application you can call java.awt.Toolkit.getScreenResolution() and use this to apply a simple scale to the size you specify for fonts.

(Le premier lien parle d'un Look&Feel qui visiblement prend en compte cette différence mais ce n'est pas un comportement standard )

Pour la sortie dans un fichier à des résolutions choisie, j'ai écrit une classe implémentant RenderedImage dont la méthode getData effectue un rendu dans le rectangle demandé. L'avantage de cette méthode est l'économie en mémoire (pas en temps certes) mais je génère un fichier pret à imprimer pour du A4 en 1200 DPI ou plus avec un -Xmx20m.

Pour l'impression, une résolution donnée (PrinterResolution) ajoutée dans les requêtes du printjob marche bien. Par contre, le Graphics de la méthode print est toujours configurer en 72 DPI par défaut :

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
 
public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws PrinterException {
int retValue = NO_SUCH_PAGE;
         if (pageIndex == 0){
            Graphics2D g2d = (Graphics2D)graphics;
            // La résolution de la page en pixels est dans
           // g2d.getDeviceConfiguration().getBounds()
            String text = g2d.getDeviceConfiguration().getBounds().toString();
            graphics.drawString(text, (int)(pageFormat.getImageableX()), (int)(pageFormat.getImageableY()+pageFormat.getImageableHeight()/2.0));
            retValue = PAGE_EXISTS;
            //  72 DPI => java.awt.Rectangle[x=0,y=0,width=595,height=841]
            // 4000DPI => java.awt.Rectangle[x=0,y=0,width=33070,height=46771]
           // Retourne le clipping du g2d
           text = g2d.getClipBounds();
           graphics.drawString(text, (int)(pageFormat.getImageableX()), (int)(pageFormat.getImageableY()+pageFormat.getImageableHeight()/3.0));
           // 72 DPI => 72, 72, 452, 698 (taille exprimée en 1/72 de pouces voir PageFormat)
           // 4000 DPI = > 72, 72, 452, 698 (taille exprimée en 1/72 de pouces voir PageFormat)
         }
         return retValue;
}

Donc c'est au développeur de modifier la transformation à partir de g2d.getDeviceConfiguration().getBounds() pour être dans la bonne résolution (surtout pour l'impression d'une image (rendu OpenGL dans mon cas)).

Ensuite pour l'aperçu avant impression, il faut émuler un affichage en 33070, 46771 4000 DPI sur un affichage 200, 300 72 DPI et là se pose le problème de la taille de police.... Mais en faisant une méthode perso utilisant le GlyphVector de la font et la scale appropriée on arrive à s'en sortir et obtenir une police au pixel pres et non plus au point pret. Sur ce point, je regrette que l'AffineTransform contenue dans le FontRenderContext soit apparement ignorée ce qui nous oblige à effectuer nous même le rendu de la shape (d'après mes différents essais effectués).

Bon me reste plus qu'a mettre tout cela au propre.

[bouye]

Ok, ceci expliquerait donc cela (il faut dire aussi que ses problemes de DPI me depassent un peu ). Attention cependant ils sont entrain de tester un renderer "natif" des polices pour une future mise a jour/bugfix de Java6 ou pour integration a Java7. Il est donc possible que cela soit finallement corrige avec le temps.

[bug38]

Bon finalement, en reconfigurant la transformation du graphics de la méthode print à partir des données extraites de la configuration graphique, je suis arrivé à imprimer en hautes résolutions en découpant la zone imprimable en petit rectangle. J'ai même fait un test à 4000 DPI qui tourne sans problème et sans consommations excessives de mémoire java : -Xmx70m et je peux descendre largement en dessous à mon avis.

Par contre, pour information il faut éviter certains rendus comme la transparence (pour une impression ce n'est pas très génant) car à ce moment là, le graphics décide de passer en mode Bitmap (et plus postscript) et se reconfigure automatiquement sur une image allouée pour du 72 DPI... et là on a quelques problèmes. Enfin je l'ai analysé comme cela car dans ce cas on obtient une jolie mosaïque d'une portion en haut à gauche du rendu que l'on souhaiterait avoir.

A l'occasion, en fonction de mon temps libre, je pourrais rédiger un petit document présentant tout ça si ça intéresse du monde.

PS : Bouye si par hasard tu avais un lien sur ce renderer "natif", j'ai cherché briévement et pas réussi à trouver. Merci

[divxdede]

Ce document peut m'interresser.
Peut de document existe concernant l'impression java en haute definition.

[sinok]

PS : Bouye si par hasard tu avais un lien sur ce renderer "natif", j'ai cherché briévement et pas réussi à trouver. Merci

http://www.pushing-pixels.org/?p=270



Sinon tu peux également utiliser le projet de Kirill qui s'appelle Bramble, qui utilise le font rasterizer de SWT (qui est natif) pour obtenir un rendu natif des polices dans Swing (java 5 au min) https://substance-bramble.dev.java.net/