Textwiedergabe mithilfe der Schriftartenbibliothek | .NETTO

Überblick

Wenn Sie jemals die Funktion zum Rendern von Text in ein Bild nutzen wollten, erfahren Sie in diesem Artikel, wie Sie dies mit Schriftarten in jedem Format tun können, die von der Schriftartenbibliothek mithilfe der Aspose.Font-API-Lösung unterstützt werden. Mit der Bibliothek können Sie problemlos Text in Bilder umwandeln und jedem Bild Text hinzufügen.

Text rendern

Um Text in ein Bild einzufügen, müssen Sie die Methode DrawText der Klasse RenderingUtils verwenden. Der folgende Code zeigt, wie man den in der Schriftart Arial geschriebenen Text „Hello world“ zu einem Bild mit dem Namen „arial.png“ hinzufügt.

    var dataDir = @"C:\Temp\";
    var fileName = dataDir + "arial.ttf"; //Font file name with full path
    var outFile = dataDir + "arial.png";
    var fontDefinition = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName)));
    var ttfFont = Font.Open(fontDefinition) as TtfFont;

    var stream = Aspose.Font.Renderers.RenderingUtils.DrawText(ttfFont, "Hello world", 18);

    var bitmap = new Bitmap(stream);
    bitmap.Save(outFile);

Das Implementierungsergebnis:

Mit der Methode DrawText können Sie den Zeilenabstand festlegen und einen automatischen wortweisen Textumbruch durchführen.

Im folgenden Codebeispiel haben wir den Zeilenabstandstyp LineSpacingType.Pixels angegeben und auf 10 festgelegt, und wir haben die maximale Breite des Bildes auf 450 festgelegt.

Der gesamte Text, der im angegebenen Bereich (in unserem Fall 450) nicht korrekt angezeigt werden kann, wird in eine neue Zeile umgebrochen.

Der ausgeschnittene Code zeigt, wie der Text „Hallo Welt“ in der Schriftart Arial mit Umbruch in die nächste Zeile gerendert wird:

    var dataDir = @"C:\Temp\";
    var fileName = dataDir + "arial.ttf"; //Font file name with full path
    var outFile = dataDir + "arial.png";
    var fontDefinition = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName)));
    var ttfFont = Font.Open(fontDefinition) as TtfFont;
    var lineSpacingType = LineSpacingType.Pixels;

    var stream = DrawText(ttfFont, "Hello world", 22, lineSpacingType, 10, 450);

    var bitmap = new Bitmap(stream);

    bitmap.Save(outFile);

Das Implementierungsergebnis:

In diesem Beispiel haben Sie gesehen, wie Sie mit nur einer Codezeile Text in ein Bild umwandeln können.

Die Funktionsfamilie für die Methode „DrawText()“ deckt die Ausgabe von Standardtext oder mehrzeiligem Text ab. In einigen Fällen benötigen Sie jedoch möglicherweise eine benutzerdefinierte Ausgabe des Texts, beispielsweise wenn Sie den Text komprimieren, strecken, in einem Winkel drehen oder etwas anderes möchten. In diesem Fall müssen Sie die Ausgabe an Ihre Bedürfnisse anpassen.

Benutzerdefinierte Textwiedergabe

Das nächste Beispiel zeigt eine erweiterte (benutzerdefinierte) Methode zum Konvertieren von Text in ein Bild.

Zum Zeichnen von Glyphen in Aspose.Font wird eine der „RenderGlyph()“-Methoden der Klasse GlyphOutlineRenderer verwendet. Alle diese überladenen Methoden werden in der Schnittstelle IGlyphRenderer deklariert.

Als Parameter müssen wir diesen Methoden einen Verweis auf die Schriftart, die Glyphen-ID oder den Glyphenindex und die Glyphen-Ausgabekoordinaten übergeben. Zur Übergabe des letzten Parameters wird eine spezielle Matrix verwendet, die durch das Objekt Aspose.Font TransformationMatrix repräsentiert wird.

Im Folgenden zeigen wir, wie Sie Objekte vom Typ TransformationMatrix verwenden, um Glyphen-Ausgabekoordinaten an Methoden der Familie „RenderGlyph()“ zu übergeben.

Um also eine Glyphe zu zeichnen, müssen wir ein Objekt vom Typ GlyphOutlineRenderer erstellen. Ein solches Objekt kann jedoch nicht alleine eine Glyphe zeichnen. Es erfordert externe Funktionalität, die durch die Schnittstelle IGlyphOutlinePainter beschrieben wird. Um das Objekt GlyphOutlineRenderer verwenden zu können, muss eine Implementierung von IGlyphOutlinePainter bereitgestellt werden.

Unten sehen Sie eine einfache Implementierung dieser Schnittstelle. Erstellen wir die Klasse GlyphOutlinePainter, die ein Objekt vom Typ System.Drawing.Drawing2D.GraphicsPath für grafische Zeichnungsziele erfordert.

Die Umsetzung ist unten dargestellt.

    public class GlyphOutlinePainter : IGlyphOutlinePainter
    {
        private GraphicsPath _path;
        private PointF _currentPoint;

        public GlyphOutlinePainter(GraphicsPath path)
        {
            _path = path;
        }

        public void MoveTo(MoveTo moveTo)
        {
            _path.CloseFigure();
            _currentPoint.X = (float)moveTo.X;
            _currentPoint.Y = (float)moveTo.Y;
        }

        public void LineTo(LineTo lineTo)
        {
            float x = (float)lineTo.X;
            float y = (float)lineTo.Y;
            _path.AddLine(_currentPoint.X, _currentPoint.Y, x, y);
            _currentPoint.X = x;
            _currentPoint.Y = y;
        }

        public void CurveTo(CurveTo curveTo)
        {
            float x3 = (float)curveTo.X3;
            float y3 = (float)curveTo.Y3;

            _path.AddBezier(
                _currentPoint.X,
                _currentPoint.Y,
                (float)curveTo.X1,
                (float)curveTo.Y1,
                (float)curveTo.X2,
                (float)curveTo.Y2,
                x3,
                y3);

            _currentPoint.X = x3;
            _currentPoint.Y = y3;
        }

        public void ClosePath()
        {
            _path.CloseFigure();
        }
    }

Nach der IGlyphOutlinePainter-Implementierung können wir Objekte dieses Typs verwenden, um eine einzelne Glyphe zu rendern, indem wir sie an den GlyphOutlineRenderer übergeben und die entsprechenden überladenen Methoden von „RenderGlyph()“ aufrufen Familie.

Um eine Textzeichenfolge zu rendern, müssen wir die glyphId für jedes Zeichen abrufen und dann mit einem Objekt vom Typ GlyphOutlineRenderer eine der Methoden der Familie „RenderGlyph()“ aufrufen. Übergabe der Koordinaten des entsprechenden Glyphen. Schauen wir uns ein Beispiel für die Ausgabe einer Textzeile mithilfe der Aspose.Font-Bibliothek an. Es wird in Form der Methode „CustomDrawText()“ erstellt, die Parameter akzeptiert: CustomDrawText(String Text, IFont Font, Double FontSize, Brush BackgroundBrush, Brush TextBrush, String OutFile).

Erstellen Sie die Methode „CustomDrawText()“, die den angegebenen Text in das Objekt System.Drawing.Bitmap zeichnet und die resultierende Bitmap auf der Disc speichert.

Dies umfasst die folgenden Schritte:

• Iterieren Sie alle Symbole in einer Textzeichenfolge.
• Holen Sie sich die Glyphen-ID für jedes verarbeitete Symbol – gid.
• Erstellen Sie ein Objekt vom Typ GlyphOutlinePainter, das vom Rendering-Subsystem zum Zeichnen der aktuellen Glyphe benötigt wird.
• Erstellen Sie ein Objekt vom Typ Aspose.Font.Renderers.GlyphOutlineRenderer und übergeben Sie das gerade erstellte Objekt vom Typ GlyphOutlinePainter an den Konstruktor für GlyphOutlineRenderer. Dieses GlyphOutlineRenderer-Objekt soll bestimmte Glyphen rendern.
• Rendern Sie das aktuell verarbeitete Glyph mit der Methode GlyphOutlineRenderer.RenderGlyph(). Das Objekt Aspose.Fonts.Matrix wird zur Angabe von Glyphenkoordinaten verwendet. Die darzustellende Glyphe wird durch den Parameter gid angegeben.

Hilfsschritte für diese Strategie

• Die Glyphenkoordinaten für die Y-Achse sind für dieses Codefragment konstant.
• Glyphenkoordinaten für die X-Achse werden für jede verarbeitete Glyphe berechnet.
• Sowohl „X“- als auch „Y“-Koordinaten werden an das Aspose.Fonts.Matrix-Objekt übergeben, das von GlyphOutlineRenderer zum Zeichnen von Glyphen verwendet wird.
• Der Abstand zwischen gerade und zuvor verarbeiteten Glyphen wird bei jedem Iterationsschritt berechnet. Es wirkt sich auf jede Glyphen-X-Koordinate aus.
• Ein Objekt vom Typ GlyphOutlineRenderer zeichnet Glyphen mit Hilfe von GlyphOutlinePainter nicht direkt in Bitmap, sondern in das GraphicsPath-Objekt, das an den Konstruktor für GlyphOutlinePainter übergeben wurde, also wir Verwenden Sie das Objekt vom Typ System.Drawing.Graphics, um GraphicsPath in Bitmap zu zeichnen.
• Die Methode FontWidthToImageWith() berechnet die Glyphenbreite für das Bitmap-Koordinatensystem.

Die Implementierung der CustomDrawText()-Methode ist unten dargestellt.

    public static void CustomDrawText(string text, IFont font, double fontSize, Brush backgroundBrush, Brush textBrush, string outFile)
    {
        //Get glyph identifiers for every symbol in the text line
        GlyphId[] gids = new GlyphId[text.Length];

        for (int i = 0; i < text.Length; i++)
            gids[i] = font.Encoding.DecodeToGid(text[i]);

        // Set common drawing settings
        double dpi = 300;
        double resolutionCorrection = dpi / 72; // 72 is font's internal dpi

        // Prepare output bitmap                
        Bitmap outBitmap = new Bitmap(960, 720);


        outBitmap.SetResolution((float)dpi, (float)dpi);

        Graphics outGraphics = Graphics.FromImage(outBitmap);
        outGraphics.FillRectangle(backgroundBrush, 0, 0, outBitmap.Width, outBitmap.Height);
        outGraphics.SmoothingMode = SmoothingMode.HighQuality;

        //Declare coordinate variables and a previous gid
        GlyphId previousGid = null;
        double glyphXCoordinate = 0;
        double glyphYCoordinate = fontSize * resolutionCorrection;

        // The loop paints every glyph in gids
        foreach (GlyphId gid in gids)
        {
            // if the font contains the gid
            if (gid != null)
            {
                Glyph glyph = font.GlyphAccessor.GetGlyphById(gid);
                if (glyph == null)
                    continue;

                // The path that accepts drawing instructions
                GraphicsPath path = new GraphicsPath();

                // Create IGlyphOutlinePainter implementation
                GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);

                // Create the renderer
                Aspose.Font.Renderers.IGlyphRenderer renderer = new Aspose.Font.Renderers.GlyphOutlineRenderer(outlinePainter);

                // Get common glyph properties
                double kerning = 0;

                // Get kerning value

                if (previousGid != null)
                {
                    kerning = (font.Metrics.GetKerningValue(previousGid, gid) / glyph.SourceResolution) * fontSize * resolutionCorrection;
                    kerning += FontWidthToImageWith(font.Metrics.GetGlyphWidth(previousGid), glyph.SourceResolution, fontSize);
                }

                // Glyph positioning - increase glyph X coordinate according to kerning distance
                glyphXCoordinate += kerning;

                // Glyph placement matrix
                TransformationMatrix glyphMatrix = new TransformationMatrix(
                        new double[]
                                { fontSize * resolutionCorrection,
                            0,
                            0,
                        // negative because of the bitmap coordinate system begins from the top
                            - fontSize*resolutionCorrection,
                            glyphXCoordinate,
                            glyphYCoordinate
                                });

                // Render the current glyph
                renderer.RenderGlyph(font, gid, glyphMatrix);

                // Fill the path
                path.FillMode = FillMode.Winding;

                outGraphics.FillPath(textBrush, path);
            }

            //Set current gid as previous to get correct kerning for next glyph
            previousGid = gid;
        }

        //Save the results
        outBitmap.Save(outFile);
    }

Utility-Methode zum Konvertieren der Schriftbreite in Bildbreite

    static double FontWidthToImageWith(double width, int fontSourceResulution, double fontSize, double dpi = 300)
    {
        double resolutionCorrection = dpi / 72; // 72 is font's internal dpi

        return (width / fontSourceResulution) * fontSize * resolutionCorrection;
    }

Der nächste Codeausschnitt zeigt, wie der Text „Hallo Welt“ mit der Methode „CustomDrawText()“ gerendert wird.

    var dataDir = @"C:\Temp\";
    var fileName1 = dataDir + "arial.ttf"; //Font file name with full path
    var fileName2 = dataDir + "calibrii.ttf"; //Font file name with full path

    var fontDefinition1 = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName1)));
    var ttfFont1 = Font.Open(fontDefinition1) as TtfFont;

    var fontDefinition2 = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName2)));
    var ttfFont2 = Font.Open(fontDefinition2) as TtfFont;

    GlyphOutlinePainter.CustomDrawText("Hello world", ttfFont1, 24, Brushes.White, Brushes.Black, dataDir + "Hello_Arial_out.png");
    GlyphOutlinePainter.CustomDrawText("Hello world", ttfFont2, 24, Brushes.Yellow, Brushes.Blue, dataDir + "Hello_Calibri_out.png");

Durch die Implementierung des Codes erhalten wir das folgende Ergebnis:

Das Implementierungsergebnis:

Arial

Calibri

Kerning

Mit dem Wert der Variablen Kerning können Sie den Abstand zwischen Glyphen ändern. Schreiben wir nun den Code wie folgt um:

 
    //Glyph positioning - increase glyph X coordinate according to the kerning distance
    kerning *= 1.25;
    glyphXCoordinate += kerning;

Das nächste Ergebnis wird erhalten:

Das Implementierungsergebnis:

Arial Kernint

Calibri Kerning

Text anhand von Koordinaten rendern

Die Variablen glyphXCoordinate und glyphYCoordinate sind für die Koordinaten der Textausgabe verantwortlich. Indem Sie den Code wie folgt ändern:

    //Declare coordinate variables and the previous gid
    GlyphId previousGid = null;
    double glyphXCoordinate = 300;
    double glyphYCoordinate = 300;

Das nächste Ergebnis wird erhalten:

Das Implementierungsergebnis:

Arial x=300 y=300

Kalibri x=300 y=300

So fügen Sie den Text zu einem Bild hinzu

Sie können auch Text auf einem vorhandenen Bild anzeigen. Dazu schreiben wir den Code wie folgt um:

 
    public static void CustomDrawText(string text, IFont font, double fontSize, Brush backgroundBrush, Brush textBrush, string outFile, Bitmap bitmap, double kerningCoefficient = 1, double coordinateX = 0, double coordinateY = 0)
    {
        //Get glyph identifiers for every symbol in the text line
        GlyphId[] gids = new GlyphId[text.Length];

        for (int i = 0; i < text.Length; i++)
            gids[i] = font.Encoding.DecodeToGid(text[i]);

        // Set common drawing settings
        double dpi = 300;
        double resolutionCorrection = dpi / 72; // 72 is font's internal dpi

        // Prepare the output bitmap                
        Bitmap outBitmap = bitmap;

        outBitmap.SetResolution((float)dpi, (float)dpi);

        Graphics outGraphics = Graphics.FromImage(outBitmap);
        outGraphics.FillRectangle(backgroundBrush, 0, 0, outBitmap.Width, outBitmap.Height);
        outGraphics.SmoothingMode = SmoothingMode.HighQuality;

        //Declare coordinate variables and the previous gid
        GlyphId previousGid = null;
        double glyphXCoordinate = coordinateX;
        double glyphYCoordinate = coordinateY;

        glyphYCoordinate += fontSize * resolutionCorrection;

        //The loop paints every glyph in gids
        foreach (GlyphId gid in gids)
        {
            // if the font contains the gid
            if (gid != null)
            {
                Glyph glyph = font.GlyphAccessor.GetGlyphById(gid);
                if (glyph == null)
                    continue;

                // The path that accepts drawing instructions
                GraphicsPath path = new GraphicsPath();

                // Create the IGlyphOutlinePainter implementation
                GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);

                // Create the renderer
                Aspose.Font.Renderers.IGlyphRenderer renderer = new Aspose.Font.Renderers.GlyphOutlineRenderer(outlinePainter);

                // Get common glyph properties
                double kerning = 0;

                // Get the kerning value

                if (previousGid != null)
                {
                    kerning = (font.Metrics.GetKerningValue(previousGid, gid) / glyph.SourceResolution) * fontSize * resolutionCorrection;
                    kerning += FontWidthToImageWith(font.Metrics.GetGlyphWidth(previousGid), glyph.SourceResolution, fontSize);
                }

                // Glyph positioning - increase the glyph X coordinate according to the kerning distance
                glyphXCoordinate += kerning * kerningCoefficient;

                // Glyph placement matrix
                TransformationMatrix glyphMatrix = new TransformationMatrix(
                        new double[]
                                { fontSize * resolutionCorrection,
                            0,
                            0,
                        // negative because of the bitmap coordinate system begins from the top
                            - fontSize*resolutionCorrection,
                            glyphXCoordinate,
                            glyphYCoordinate
                                });

                // Render the current glyph
                renderer.RenderGlyph(font, gid, glyphMatrix);

                // Fill the path
                path.FillMode = FillMode.Winding;

                outGraphics.FillPath(textBrush, path);
            }

            //Set the current gid as previous to get the correct kerning for the next glyph
            previousGid = gid;
        }

        //Save the results
        outBitmap.Save(outFile);
    }

Ändern wir die Art und Weise, wie die Methode aufgerufen wird:

    var dataDir = @"C:\Temp\";
    var fileName1 = dataDir + "arial.ttf"; //Font file name with full path

    var fontDefinition1 = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName1)));
    var ttfFont1 = Font.Open(fontDefinition1) as TtfFont;

    var bitmap = new Bitmap(960, 720);

    GlyphOutlinePainter.CustomDrawText("Hello world", ttfFont1, 17, Brushes.White, Brushes.Black, dataDir + "Hello_Arial_out.png", bitmap);

    var inputImagePath = dataDir + "Hello_Arial_out.png";
    var bitmapAddText = new Bitmap(inputImagePath);

    GlyphOutlinePainter.CustomDrawText("Hello world", ttfFont1, 17, Brushes.Transparent, Brushes.Gray, dataDir + "Hello_Arial_Shadow_out.png", bitmapAddText, 1, -3);

    GlyphOutlinePainter.CustomDrawText("<= Shadow effect", ttfFont1, 17, Brushes.Transparent, Brushes.Brown, dataDir + "Hello_Arial_Shadow_out.png", bitmapAddText, 1, 400);

Das Implementierungsergebnis:

Luftschatteneffekt

Ausgabe des Textes von oben nach unten

Um den Text von oben nach unten anzuzeigen, nehmen wir die folgenden Änderungen in der Methode „CustomDrawText()“ vor.

    public static void CustomDrawText(string text, IFont font, double fontSize, Brush backgroundBrush, Brush textBrush, string outFile, Bitmap bitmap, double kerningCoefficient = 1, double coordinateX = 0, double coordinateY = 0, bool topDown = false)
    {
        //Get glyph identifiers for every symbol in the text line
        GlyphId[] gids = new GlyphId[text.Length];

        for (int i = 0; i < text.Length; i++)
            gids[i] = font.Encoding.DecodeToGid(text[i]);

        // Set common drawing settings
        double dpi = 300;
        double resolutionCorrection = dpi / 72; // 72 is font's internal dpi

        // Prepare the output bitmap                
        Bitmap outBitmap = bitmap;

        outBitmap.SetResolution((float)dpi, (float)dpi);

        Graphics outGraphics = Graphics.FromImage(outBitmap);
        outGraphics.FillRectangle(backgroundBrush, 0, 0, outBitmap.Width, outBitmap.Height);
        outGraphics.SmoothingMode = SmoothingMode.HighQuality;

        //Declare coordinate variables and the previous gid
        GlyphId previousGid = null;
        double glyphXCoordinate = coordinateX;
        double glyphYCoordinate = coordinateY;

        glyphYCoordinate += fontSize * resolutionCorrection;

        //The loop paints every glyph in gids
        foreach (GlyphId gid in gids)
        {
            // if the font contains the gid
            if (gid != null)
            {
                Glyph glyph = font.GlyphAccessor.GetGlyphById(gid);
                if (glyph == null)
                    continue;

                // The path that accepts drawing instructions
                GraphicsPath path = new GraphicsPath();

                // Create IGlyphOutlinePainter implementation
                GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);

                // Create the renderer
                Aspose.Font.Renderers.IGlyphRenderer renderer = new Aspose.Font.Renderers.GlyphOutlineRenderer(outlinePainter);

                // Get common glyph properties
                double kerning = 0;

                // Get kerning value                        
                if (previousGid != null && !topDown)
                {
                    kerning = (font.Metrics.GetKerningValue(previousGid, gid) / glyph.SourceResolution) * fontSize * resolutionCorrection;
                    kerning += FontWidthToImageWith(font.Metrics.GetGlyphWidth(previousGid), glyph.SourceResolution, fontSize);
                }

                if (topDown)
                {
                    glyphYCoordinate += fontSize * resolutionCorrection;
                }
                else
                {
                    // Glyph positioning - increase the glyph X coordinate according to kerning distance                       
                    glyphXCoordinate += kerning * kerningCoefficient;
                }

                // Glyph placement matrix
                TransformationMatrix glyphMatrix = new TransformationMatrix(
                        new double[]
                                { fontSize * resolutionCorrection,
                            0,
                            0,
                        // negative because the bitmap coordinate system begins from the top
                            - fontSize*resolutionCorrection,
                            glyphXCoordinate,
                            glyphYCoordinate
                                });

                // Render the current glyph
                renderer.RenderGlyph(font, gid, glyphMatrix);

                // Fill the path
                path.FillMode = FillMode.Winding;

                outGraphics.FillPath(textBrush, path);
            }

            //Set the current gid as previous to get correct kerning for the next glyph
            previousGid = gid;
        }

        //Save the results
        outBitmap.Save(outFile);
    }

Der Code für den Methodenaufruf wird wie folgt aussehen:

    var dataDir = @"C:\Temp\";
    var fileName1 = dataDir + "arial.ttf"; //Font file name with full path
    var fontDefinition1 = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName1)));
    var ttfFont1 = Font.Open(fontDefinition1) as TtfFont;
    var bitmap = new Bitmap(960, 720);

    GlyphOutlinePainter.CustomDrawText("Top down", ttfFont1, 18, Brushes.White, Brushes.Black, dataDir + "Hello_Arial_TopDown.png", bitmap, 1, 400, 00, true);

Das Implementierungsergebnis:

Arial von oben nach unten

Weitere Informationen

    double dpi; // dots per inch
    double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
    // Coordinate variables
    double glyphXCoordinate; // X
    double glyphYCoordinate; // Y;
    // Kerning - horizontal spacing between two letters
    double kerning = 0;