Leer información de glifos y métricas

Solución API .NET para calcular el ancho de la cadena, calcular las coordenadas de glifos y otras manipulaciones con glifos.

 

Aspose.Font for .NET Aspose.Font for .NET

  Nuget   Pricing Buy
 

Aspose.Font API Solution tiene una rica funcionalidad para trabajar con fuentes. Conversión, manipulaciones con glifos, detección de símbolos latinos y muchos más. Algunas de las características están vinculadas a manipulaciones con glifos.

Glyph es un carácter diseñado individualmente de un tipo de letra, o es una representación gráfica de un símbolo/carácter. Para obtener más información sobre esta unidad de fuente, lea el artículo Introducción a Glyph .

Esta página describe la opción sobre cómo leer la información de glifos y métricas, pero toda la funcionalidad se describe cuidadosamente en Uso de objetos Glyph artículo. Allí encontrará muchos más ejemplos de código C# y aprenderá la funcionalidad de Aspose.Font para trabajar con glifos y los objetos Glyph en particular. Más ejemplos de código del uso de Aspose.Font para manipular glifos se almacenan en Aspose.Font.Examples.sln solución.

Para trabajar con glifos necesitamos:

  • Aspose.Font para .NET API, que es una API de conversión y manipulación de documentos rica en funciones, potente y fácil de usar para la plataforma C#.

  • Abra el administrador de paquetes NuGet y busque Aspose.Font e instálelo. También puede usar el siguiente comando desde la Consola del administrador de paquetes.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Pasos para calcular el ancho de la cadena usando C#:

  1. Declarar el texto y otras constantes. Aquí como ejemplo se utiliza la frase «Hola mundo».
  2. Declare una variable para el ancho de la cadena.
  3. Obtenga un glifo para cada letra del texto usando la clase GlyphId . Calcular el ancho de todo el texto.
  4. Se puede lograr el mismo resultado utilizando el método MeasureString() .
  5. Imprima los resultados de salida.

Código C# para averiguar el ancho de la cadena

    using System;
    using System.IO;
    using System.Drawing;
    using System.Collections.Generic;
    using Aspose.Font.Sources;
    using Aspose.Font.Glyphs;
    using Aspose.Font.RenderingPath;
    //Declare the text and other constants
    const string text = "Hello world";
    const int fontSize = 10;

    //Declare a variable for string width
    double width = 0;

    //Get a glyph for each letter in text and calculate width for whole text.
    //The same result can be achieved using the method font.Metrics.MeasureString(text, fontSize).
    foreach (char symbol in text)
    {
        GlyphId gid = this._font.Encoding.DecodeToGid(symbol);
        Glyph glyph = this._font.GetGlyphById(gid);
        width += (glyph.WidthVectorX / this._font.Metrics.UnitsPerEM) * fontSize;
    }            

    //Print output results
    Console.WriteLine(string.Format("Width for text \"{0}\" with font size {2} is equal {3}." , 
        text, FontName, fontSize, width));

Pasos para calcular todos los puntos de glifo con coordenadas usando C#:

  1. Declare la lista resultante con puntos .
  2. Especifique la referencia del servicio Init en la interfaz IPathSegment .
  3. Repita todos los segmentos de ruta de glifo y sume los puntos.

Código C# para encontrar puntos de glifo

    Glyph glyph;

    //Declare the resultant list with points
    List<Point> points = new List<Point>();

    //Init service reference on IPathSegment
    IPathSegment prevSegment = null;

    //Iterate all the glyph path segments and collect points
    foreach (IPathSegment segment in glyph.Path.Segments)
    {
        if ((segment is LineTo)
            || (segment is CurveTo))
        {
            if (prevSegment is MoveTo)
            {
                MoveTo moveTo = prevSegment as MoveTo;
                AddPoint((int)moveTo.X, (int)moveTo.Y, points);
            }
            if (segment is LineTo)
            {
                LineTo line = segment as LineTo;
                AddPoint((int)line.X, (int)line.Y, points);
            }
            else if (segment is CurveTo)
            {
                CurveTo curve = segment as CurveTo;
                AddPoint((int)curve.X1, (int)curve.Y1, points);
                AddPoint((int)curve.X2, (int)curve.Y2, points);
                AddPoint((int)curve.X3, (int)curve.Y3, points);
            }
        }
        prevSegment = segment;
    }	

    void AddPoint(int x, int y, List<Point> points)
    {
        Point p = new Point();
        p.X = x;
        p.Y = y;
        points.Add(p);
    }



Preguntas más frecuentes

1. ¿Qué es una métrica de glifo?

Glyph metrics son los parámetros que influyen en cómo se coloca el glifo cuando se crea el diseño del texto.

2. ¿Qué son las métricas de glifos?

Las métricas de glifo más utilizadas son el ancho de avance, el origen, los rumbos laterales, la línea de base, el ascenso, el ascendente, el descendente, el descendente, el cuadro delimitador, la altura, el ancho y el interletraje.

3. ¿Cómo administrar Glyphs con esta solución API?

Para codificar glifos en C#, use las entidades del espacio de nombres Aspose.Font.Glyphs .

4. ¿Qué es un glifo?

Glyph es un carácter diseñado individualmente de un tipo de letra. También se puede definir como una representación gráfica de un símbolo/carácter.