Leggi le informazioni su glifi e metriche

Soluzione API C++ per calcolare la larghezza della stringa, calcolare 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 caratteri, tra cui conversione, manipolazione di glifi, rilevamento di simboli latini e altro ancora. Alcune di queste caratteristiche riguardano la manipolazione dei glifi, che sono singoli caratteri di un carattere tipografico o rappresentazioni grafiche di simboli/caratteri. Per saperne di più su queste unità di un font, fai riferimento all’articolo Introduzione a Glyph .

Questa pagina delinea l’opzione per leggere le informazioni su glifi e metriche, ma per una comprensione completa della funzionalità, fare riferimento all’articolo Utilizzo di oggetti glifi . Qui troverai numerosi esempi di codice C++ e imparerai le funzionalità di Aspose.Font per lavorare con i glifi e gli oggetti Glyph. Altri esempi di codice che dimostrano l’uso di Aspose.Font per la manipolazione dei glifi possono essere trovati in Aspose Github Project .

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

Per lavorare con i glifi abbiamo bisogno di:

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

  • Apri il gestore pacchetti NuGet e cerca Aspose.Font e installa. È inoltre possibile utilizzare il seguente comando dalla console di Package Manager.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Passaggi per calcolare la larghezza della stringa utilizzando C++:

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

  1. Determina il carattere e la dimensione che desideri utilizzare per calcolare la larghezza della stringa.
  2. Per ogni carattere nella stringa, determina il glifo corrispondente nel font. Usa la mappa dei caratteri, che ti darà l’indice del glifo corrispondente.
  3. Utilizzando l’indice del glifo, cerca le metriche per il glifo nella tabella delle metriche del font. Le metriche per un glifo in genere includono la larghezza, l’altezza e la larghezza di avanzamento.
  4. Somma le larghezze avanzate di tutti i glifi nella stringa per ottenere la larghezza totale della stringa. Nota per prestare attenzione alle informazioni sulla crenatura.

Se si descrive un processo simile con il codice C++, sembrerebbe il modo successivo.

Codice C++ per scoprire 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 di glifo con le coordinate usando C++:

  1. Dichiara l’elenco points di tipo System::Drawing::Point: questo elenco memorizzerà i punti di un segmento del percorso del glifo..
  2. Specificare il riferimento al servizio Init sull’interfaccia IPathSegment .
  3. Iterare tutti i segmenti del percorso del glifo e sommare i punti.

Codice C++ per scoprire i punti glifo

    //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.