Java: Umwandeln von Glyphs fehlerhaft

[Robert S. (razer)]

Hallo an alle,

Ich schreibe gerade ein Tool, das mir einen Zeichensatz mit einer 
bestimmten Font in ein "Pixel-Array" umwandelt, um es für ein LCD zu 
nutzen.

Dazu habe ich eine Klasse, die mir genau ein Zeichen Umwandelt. Ich gebe 
das konvertierte Zeichen per Ascii-Art auf der Konsole aus. Leider 
werden manche Zeichen unvollständig erzeugt:

H:

        
 #      
 #      
 #      
 #      
 #######
 ##    #
 #      
 #      
 #      
 #

N:

        
 ##     
 ##     
 ###    
 # ##   
 #  #   
 #   #  
 #   ## 
 #    ##
 #     #
 #     #

Die beiden Zeichen sind Arial, 14.

Hierzu der Konstruktor der Klasse:

public LcdGlyph(String c, Font f)
    {
        this.c = c;
        this.f = f;

        FontRenderContext fontRendContext = new FontRenderContext(null, true, true);
        GlyphVector glyphVector = f.createGlyphVector(fontRendContext, c);

        Rectangle2D bounds = glyphVector.getPixelBounds(fontRendContext, 0, 0);
        int width = (int)bounds.getWidth();
        int height = (int)bounds.getHeight();

        BufferedImage bn = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
        Graphics2D g2d = bn.createGraphics();
        g2d.drawGlyphVector(glyphVector, 0,(float)height);

        WritableRaster raster = bn.getRaster();
        DataBuffer buffer = raster.getDataBuffer();
        SampleModel model = bn.getSampleModel();

        for(int i=0; i<raster.getHeight(); i++)
        {
            for(int j=0; j<raster.getWidth(); j++)
            {
                int pixel[] = model.getPixel(j, i, (int[])null, buffer);

                if(pixel[0]>0)
                {
                    System.out.print("#");
                }
                else
                {
                    System.out.print(" ");
                }

            }
            System.out.println();
        }
    }

Andere Zeichen werden richtig erzeugt.

Kann mir jemand Tipps dazu geben?

lg Robert

[Marvin (Gast)]

Es sieht ganz so aus, als ob irgendwo in deinem Programm deine Grafik in 
der Breite abgeschnitten wird. Kann es evtl hier sein:

Robert S. schrieb:

g2d.drawGlyphVector(glyphVector, 0,(float)height);

(Ich habe keine Ahnung... aber der Aufruf sieht mir irgendwie 
unsymmetrisch aus ;) )

Gruesse

Marvin

[Robert S. (razer)]

Das denke ich nicht.
Es wird dabei die Y-Startposition um die Höhe nach unten verschoben, 
denn drawGlyphVector() schreibt von unten nach oben.

Es geht um die X-Achse. In Y werden alle richtig gezeichnet.

[Reinhard Kern (Gast)]

Hallo,

warum zeichnest du das Zeichen nicht einfach auf den Windows-Bildschirm 
und fragst die Pixel ab? Das heisst du benutzt den Renderer von Windows 
und nicht etwas Unbekanntes.

Gruss Reinhard

[Robert S. (razer)]

Wie würdest du das lösen?
Mit der Klasse Canvas komme ich erstmal nicht zurecht, denn die muss 
einem Frame zugeordnet werden, bevor darauf gezwichnet werden kann.

Irgendwie mit JPanel??

[Läubi .. (laeubi)]

Also....
Ein Buffered Image ist hierfür erstmal völlig korrekt!
Das ganze auf den Bildschirm zu zeichnen macht nur mehr Probleme als das 
es hilft.

Du solltest aber den Fontrenderkontext des BI nutzen und nicht einen 
eigenen erstellen!
Unter Umständen solltest du außerdem mal vom GV die getVisualBounds() 
Methode nutzen, sowie das BI mal auf einem Label zur Anzeige bringen ob 
das ganze ein Zeichenproblem ist oder ob deine Konvertierung BI --> 
ASCII irgendwie spinnt.

In diesem Falle läßt sich der Pixelwert auch viel einfacher direkt über 
das BI mittels getRGB(intx int y) abfragen.

[Robert S. (razer)]

Läubi .. schrieb:
> Du solltest aber den Fontrenderkontext des BI nutzen und nicht einen
> eigenen erstellen!
> Unter Umständen solltest du außerdem mal vom GV die getVisualBounds()
> Methode nutzen, sowie das BI mal auf einem Label zur Anzeige bringen ob
> das ganze ein Zeichenproblem ist oder ob deine Konvertierung BI -->
> ASCII irgendwie spinnt.

Danke für die Tipps. Dazu habe ich noch Fragen. Um ein BufferedImage zu 
erzeugen, benötige ich deren Größe. Wenn ich daraus den FontRenderer 
erzeuge weiß ich vorher noch nicht wie groß das Glyph sein wird:

BufferedImage bn = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
GlyphVector glyphVector = f.createGlyphVector(g2d.getFontRenderContext(), c);
g2d.drawGlyphVector(glyphVector, 0,(float)height);

lg Robert

[Claudio H. (bastelfinger)]

GlyphVector.getGlyphOutline().getPathIterator(),

dann mit currentSegment() und next() die Koordinaten abfragen.

EDIT: Das geht dann ohne zu zeichnen. Aber du kannst dir auch einen 
eigenen Graphic-Context für die Konsole schreiben. Wäre dann natürlich 
eleganter. Aber wie oben beschrieben ist auf jeden Fall eine gute Lösung 
ohne den Aufwand beim Zeichnen auf ein Control!

[Claudio H. (bastelfinger)]

Noch etwas:
Beim KKonstruktor vom FontRenderContext schaltest du AntiAliasing ein. 
Willst du das wirklich so haben?

[Claudio H. (bastelfinger)]

>Rectangle2D bounds

hier solltest du nicht mit bounds.getHeight() weitermachen, und auf int 
casten, sondern gleich bounds.getSize().getHeight verwenden. Generell 
solltest du die vielen Casts vermeiden.