Leggi le informazioni sui Glifi e le Metriche

Soluzione API C++ per calcolare la larghezza di una stringa, le coordinate dei glifi e altre manipolazioni con i glifi.

 

Aspose.Font for C++ Aspose.Font for C++

  Nuget   Pricing Buy
 

L’API Aspose.Font offre una gamma completa di funzioni relative ai font, tra cui conversione, manipolazione dei glifi, rilevamento di simboli latini e altro. Alcune di queste funzionalità riguardano la manipolazione dei glifi, che sono caratteri individuali di un tipo di carattere o rappresentazioni grafiche di simboli/caratteri. Per comprendere meglio queste unità di un font, consulta l’articolo Introduzione ai Glifi .

Questa pagina descrive l’opzione per leggere le informazioni sui Glifi e le Metriche, ma per una comprensione completa della funzionalità, consulta l’articolo Utilizzo degli Oggetti Glifo . Qui troverai numerosi esempi di codice C++ e imparerai le capacità di Aspose.Font per lavorare con i glifi e gli oggetti Glifo. Ulteriori esempi di codice che mostrano l’uso di Aspose.Font per manipolare i Glifi sono disponibili nel progetto Aspose Progetto Github .

Le metriche dei glifi, termine usato qui, si riferiscono alle informazioni e alle misurazioni di un particolare glifo in un font. Possono includere dati come altezza, larghezza, larghezza di avanzamento e altre dimensioni, importanti per il corretto posizionamento e spaziatura dei caratteri in un font. Queste metriche sono utilizzate da sistemi di layout e rendering del testo per garantire una visualizzazione coerente e accurata del testo.

Per lavorare con i glifi è necessario:

  • L'API Aspose.Font per C++ che è ricca di funzionalità, potente e facile da usare per la manipolazione e conversione di documenti.

  • Apri il gestore di pacchetti NuGet, cerca Aspose.Font e installalo. Puoi anche utilizzare il seguente comando dalla console del Package Manager.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Passaggi per calcolare la larghezza di una stringa usando C++:

Per calcolare la larghezza di una stringa usando i glifi, è necessario prima determinare la larghezza di ogni glifo individuale nella stringa, quindi sommare queste larghezze per ottenere il numero totale. Se lo spieghi con passaggi, l’ordine è il seguente:

  1. Determina il font e la dimensione che vuoi usare per calcolare la larghezza della stringa.
  2. Per ogni carattere nella stringa, determina il glifo corrispondente nel font. Usa la mappa dei caratteri, che fornisce l’indice del glifo corrispondente.
  3. Utilizzando l’indice del glifo, cerca le metriche del glifo nella tabella delle metriche del font. Le metriche di un glifo includono tipicamente larghezza, altezza e larghezza di avanzamento.
  4. Somma le larghezze avanzate di tutti i glifi nella stringa per ottenere la larghezza totale. Presta attenzione alle informazioni di kern.

Se descrivi un processo simile con il codice C++, apparirà nel modo seguente.

Codice C++ per determinare la larghezza della stringa

    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 System::String text = u"Hello world";
        const int32_t fontSize = 10;
    
        //Declare the variable for string width
        double width = 0;
    
        //Get glyph for each letter in text and calculate width for whole text.
        //The same result can be achieved using method font.Metrics.MeasureString(text, fontSize).
        for (char16_t symbol : text)
        {
            System::SharedPtr<GlyphId> gid = this->_font->get_Encoding()->DecodeToGid(symbol);
            System::SharedPtr<Glyph> glyph = this->_font->GetGlyphById(gid);
            width += (glyph->get_WidthVectorX() / this->_font->get_Metrics()->get_UnitsPerEM()) * fontSize;
        }
	    font->get_Metrics()->MeasureString(text, width);

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

Passaggi per calcolare tutti i punti dei glifi con coordinate usando C++:

  1. Dichiara la lista punti di tipo System::Drawing::Point: questa lista memorizzerà i punti di un segmento del percorso di un glifo.
  2. Specifica il riferimento al servizio Init sull’interfaccia IPathSegment .
  3. Itera tutti i segmenti del percorso del glifo e somma i punti.

Codice C++ per trovare i punti dei glifi

    //Declare the resultant list with points
    System::SharedPtr<System::Collections::Generic::List<System::Drawing::Point>> points =
    System::MakeObject<System::Collections::Generic::List<System::Drawing::Point>>();
    
    //Init the service reference on IPathSegment
    System::SharedPtr<IPathSegment> prevSegment;
    
    //Iterate all the glyph path segments and collect points
    for (auto&& segment : glyph->get_Path()->get_Segments())
    {
        if ((System::ObjectExt::Is<LineTo>(segment)) || (System::ObjectExt::Is<CurveTo>(segment)))
        {
            if (System::ObjectExt::Is<MoveTo>(prevSegment))
            {
                System::SharedPtr<MoveTo> moveTo = System::DynamicCast_noexcept<Aspose::Font::RenderingPath::MoveTo>(prevSegment);
                AddPoint((int32_t)moveTo->get_X(), (int32_t)moveTo->get_Y(), points);
            }
            if (System::ObjectExt::Is<LineTo>(segment))
            {
                System::SharedPtr<LineTo> line = System::DynamicCast_noexcept<Aspose::Font::RenderingPath::LineTo>(segment);
                AddPoint((int32_t)line->get_X(), (int32_t)line->get_Y(), points);
            }
            else if (System::ObjectExt::Is<CurveTo>(segment))
            {
                System::SharedPtr<CurveTo> curve = System::DynamicCast_noexcept<Aspose::Font::RenderingPath::CurveTo>(segment);
                AddPoint((int32_t)curve->get_X1(), (int32_t)curve->get_Y1(), points);
                AddPoint((int32_t)curve->get_X2(), (int32_t)curve->get_Y2(), points);
                AddPoint((int32_t)curve->get_X3(), (int32_t)curve->get_Y3(), points);
            }
        }
        prevSegment = segment;
    }



FAQ

1. Cos’è una metrica glifo?

Glyph metrics sono i parametri che influenzano il posizionamento del glifo quando viene creato il layout del testo.

2. Cosa sono le metriche dei glifi?

Le metriche dei glifi più utilizzate sono la larghezza avanzata, l’origine, i cuscinetti laterali, la linea di base, l’ascesa, l’ascendente, la discesa, il discendente, il riquadro di delimitazione, l’altezza, la larghezza e la crenatura.

3. Come gestire i glifi con questa soluzione API?

Per codificare i glifi in C#, usa le entità dello spazio dei nomi Aspose.Font.Glyphs .

4. Qual è l’importanza delle metriche dei glifi?

Comprendendo e regolando adeguatamente la metrica dei glifi, tipografi e designer possono garantire spaziatura, allineamento e leggibilità ottimali del testo nei materiali stampati, nelle interfacce digitali o nelle pagine web.