IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

2D Java Discussion :

[DPI]Taille de font et aperçu avant impression


Sujet :

2D Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé

    Profil pro
    Inscrit en
    Avril 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Âge : 53
    Localisation : France, Isère (Rhône Alpes)

    Informations forums :
    Inscription : Avril 2007
    Messages : 17
    Par défaut [DPI]Taille de font et aperçu avant impression
    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...)?

  2. #2
    Rédacteur/Modérateur

    Avatar de bouye
    Homme Profil pro
    Information Technologies Specialist (Scientific Computing)
    Inscrit en
    Août 2005
    Messages
    6 904
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Information Technologies Specialist (Scientific Computing)
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : Août 2005
    Messages : 6 904
    Billets dans le blog
    54
    Par défaut
    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
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  3. #3
    Membre éclairé

    Profil pro
    Inscrit en
    Avril 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Âge : 53
    Localisation : France, Isère (Rhône Alpes)

    Informations forums :
    Inscription : Avril 2007
    Messages : 17
    Par défaut Ca va mieux
    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.

  4. #4
    Rédacteur/Modérateur

    Avatar de bouye
    Homme Profil pro
    Information Technologies Specialist (Scientific Computing)
    Inscrit en
    Août 2005
    Messages
    6 904
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Information Technologies Specialist (Scientific Computing)
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : Août 2005
    Messages : 6 904
    Billets dans le blog
    54
    Par défaut
    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.
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  5. #5
    Membre éclairé

    Profil pro
    Inscrit en
    Avril 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Âge : 53
    Localisation : France, Isère (Rhône Alpes)

    Informations forums :
    Inscription : Avril 2007
    Messages : 17
    Par défaut Des précisions
    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

  6. #6
    Membre émérite
    Avatar de divxdede
    Profil pro
    Inscrit en
    Avril 2004
    Messages
    525
    Détails du profil
    Informations personnelles :
    Âge : 47
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Avril 2004
    Messages : 525
    Par défaut
    Ce document peut m'interresser.
    Peut de document existe concernant l'impression java en haute definition.

  7. #7
    Expert confirmé
    Avatar de sinok
    Profil pro
    Inscrit en
    Août 2004
    Messages
    8 765
    Détails du profil
    Informations personnelles :
    Âge : 45
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Août 2004
    Messages : 8 765
    Par défaut
    Citation Envoyé par bug38 Voir le message

    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/

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Concepteur RAVE sous DELPHI 7 : aperçu avant impression
    Par tarbala dans le forum Composants VCL
    Réponses: 4
    Dernier message: 01/06/2020, 00h37
  2. Aperçu avant impression d'un TRichEdit
    Par PoOky dans le forum Composants VCL
    Réponses: 2
    Dernier message: 31/01/2016, 23h19
  3. Réponses: 5
    Dernier message: 25/01/2013, 20h39
  4. Aperçu avant impression
    Par Zebulon777 dans le forum Access
    Réponses: 18
    Dernier message: 15/09/2005, 10h46
  5. [Débutante] Aperçu avant impression d'un composant
    Par gwendo dans le forum AWT/Swing
    Réponses: 4
    Dernier message: 09/07/2004, 09h52

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo