webentwicklung-frage-antwort-db.com.de

So generieren Sie zur Laufzeit ein Bild aus Text im Handumdrehen

Kann irgendjemand eine Anleitung geben, wie man ein Bild aus einem eingegebenen Text erzeugt. Das Bild kann eine beliebige Erweiterung haben, spielt keine Rolle.

59
Ravia

Angenommen, Sie möchten in C # eine Zeichenfolge auf ein Bild zeichnen, müssen Sie den System.Drawing-Namespace hier verwenden:

private Image DrawText(String text, Font font, Color textColor, Color backColor)
{
    //first, create a dummy bitmap just to get a graphics object
    Image img = new Bitmap(1, 1);
    Graphics drawing = Graphics.FromImage(img);

    //measure the string to see how big the image needs to be
    SizeF textSize = drawing.MeasureString(text, font);

    //free up the dummy image and old graphics object
    img.Dispose();
    drawing.Dispose();

    //create a new image of the right size
    img = new Bitmap((int) textSize.Width, (int)textSize.Height);

    drawing = Graphics.FromImage(img);

    //Paint the background
    drawing.Clear(backColor);

    //create a brush for the text
    Brush textBrush = new SolidBrush(textColor);

    drawing.DrawString(text, font, textBrush, 0, 0);

    drawing.Save();

    textBrush.Dispose();
    drawing.Dispose();

    return img;

}

Dieser Code misst zuerst die Zeichenfolge und erstellt dann ein Bild mit der richtigen Größe.

Wenn Sie die Rückkehr dieser Funktion speichern möchten, rufen Sie einfach die Save-Methode des zurückgegebenen Bildes auf.

148
Kazar

Vielen Dank, Kazar. Eine geringfügige Verbesserung der vorherigen Antwort zur Verwendung von USING für die Entsorgung von Bild-/Grafikobjekten nach der Verwendung und die Einführung des Parameters für die minimale Größe

    private Image DrawTextImage(String currencyCode, Font font, Color textColor, Color backColor) {
        return DrawTextImage(currencyCode, font, textColor, backColor, Size.Empty);
    }
    private Image DrawTextImage(String currencyCode, Font font, Color textColor, Color backColor, Size minSize) {
        //first, create a dummy bitmap just to get a graphics object
        SizeF textSize;
        using (Image img = new Bitmap(1, 1)) {
            using (Graphics drawing = Graphics.FromImage(img)) {
                //measure the string to see how big the image needs to be
                textSize = drawing.MeasureString(currencyCode, font);
                if (!minSize.IsEmpty) {
                    textSize.Width = textSize.Width > minSize.Width ? textSize.Width : minSize.Width;
                    textSize.Height = textSize.Height > minSize.Height ? textSize.Height : minSize.Height;
                }
            }
        }

        //create a new image of the right size
        Image retImg = new Bitmap((int)textSize.Width, (int)textSize.Height);
        using (var drawing = Graphics.FromImage(retImg)) {
            //Paint the background
            drawing.Clear(backColor);

            //create a brush for the text
            using (Brush textBrush = new SolidBrush(textColor)) {
                drawing.DrawString(currencyCode, font, textBrush, 0, 0);
                drawing.Save();
            }
        }
        return retImg;
    }

benutze imagemagick um Text auf Bildern (auf dem Server) zu rendern

Da Sie sich in C # befinden, können Sie die .Net-Klassen auch direkt für die Bearbeitung von Bitmaps und Schriftarten verwenden (mit Klassen wie: System.Drawing.Bitmap und System.Drawing.Graphics)

3
Toad

Ich habe diese in dieser Antwort erwähnte Methode gerade in eine VB.NET-Methode übersetzt. Vielleicht hilft das jemandem.

Public Function DrawText(ByVal text As String, ByRef font As   Font, ByRef textColor As Color, ByRef backColor As Color) As Image
    ' first, create a dummy bitmap just to get a graphics object
    Dim img As Image = New Bitmap(1, 1)
    Dim drawing As Graphics = Graphics.FromImage(img)

    ' measure the string to see how big the image needs to be
    Dim textSize As SizeF = drawing.MeasureString(Text, Font)

    ' free up the dummy image and old graphics object
    img.Dispose()
    drawing.Dispose()

    ' create a new image of the right size
    img = New Bitmap(CType(textSize.Width, Integer), CType(textSize.Height, Integer))

    drawing = Graphics.FromImage(img)

    ' Paint the background
    drawing.Clear(BackColor)

    ' create a brush for the text
    Dim textBrush As Brush = New SolidBrush(textColor)

    drawing.DrawString(text, font, textBrush, 0, 0)

    drawing.Save()

    textBrush.Dispose()
    drawing.Dispose()

    Return img

End Function

Bearbeiten : Tippfehler behoben.

3
Freddy

Hier ist Panayiotis 'Version von Kazars Antwort mit optionalen Parametern und Dokumentation, die zum Hinzufügen zu einer Bibliotheksklasse geeignet sind.

/// <summary>
/// Creates an image containing the given text.
/// NOTE: the image should be disposed after use.
/// </summary>
/// <param name="text">Text to draw</param>
/// <param name="fontOptional">Font to use, defaults to Control.DefaultFont</param>
/// <param name="textColorOptional">Text color, defaults to Black</param>
/// <param name="backColorOptional">Background color, defaults to white</param>
/// <param name="minSizeOptional">Minimum image size, defaults the size required to display the text</param>
/// <returns>The image containing the text, which should be disposed after use</returns>
public static Image DrawText(string text, Font fontOptional=null, Color? textColorOptional=null, Color? backColorOptional=null, Size? minSizeOptional=null)
{
    Font font = Control.DefaultFont;
    if (fontOptional != null)
        font = fontOptional;

    Color textColor = Color.Black;
    if (textColorOptional != null)
        textColor = (Color)textColorOptional;

    Color backColor = Color.White;
    if (backColorOptional != null)
        backColor = (Color)backColorOptional;

    Size minSize = Size.Empty;
    if (minSizeOptional != null)
        minSize = (Size)minSizeOptional;

    //first, create a dummy bitmap just to get a graphics object
    SizeF textSize;
    using (Image img = new Bitmap(1, 1))
    {
        using (Graphics drawing = Graphics.FromImage(img))
        {
            //measure the string to see how big the image needs to be
            textSize = drawing.MeasureString(text, font);
            if (!minSize.IsEmpty)
            {
                textSize.Width = textSize.Width > minSize.Width ? textSize.Width : minSize.Width;
                textSize.Height = textSize.Height > minSize.Height ? textSize.Height : minSize.Height;
            }
        }
    }

    //create a new image of the right size
    Image retImg = new Bitmap((int)textSize.Width, (int)textSize.Height);
    using (var drawing = Graphics.FromImage(retImg))
    {
        //Paint the background
        drawing.Clear(backColor);

        //create a brush for the text
        using (Brush textBrush = new SolidBrush(textColor))
        {
            drawing.DrawString(text, font, textBrush, 0, 0);
            drawing.Save();
        }
    }
    return retImg;
}
1
Andrew Taylor

F# Ausführung:


open System.Drawing

let drawText text font textColor backColor =
    let size =
      use dummyImg = new Bitmap(1, 1)
      use drawing = Graphics.FromImage(dummyImg)
      drawing.MeasureString(text, font)
    let img = new Bitmap((int size.Width), (int size.Height))
    use drawing = Graphics.FromImage(img)
    use textBrush = new SolidBrush(textColor)
    do 
      drawing.Clear(backColor)
      drawing.DrawString(text, font, textBrush, PointF())
      drawing.Save() |> ignore
    img
1
Dzmitry Lahoda