Rendering di testo utilizzando il carattere Type1 | C ++

Rendering Testo

Al fine di rendere il testo, il sottosistema di rendering richiede l’implementazione di Aspose.Font.Rendering.IGlyphOutlinePainter Interfaccia per disegnare glifo. Questo può essere ottenuto utilizzando i seguenti passaggi.

1. Implementa i metodi IglyphoutLinePainter creando un GlyphOutlinePainter di classe che richiede oggetto di tipo System.Drawing.Drawing2d.Graphicspath per obiettivi di disegno grafico. L’implementazione è come illustrata di seguito.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
RenderingText::GlyphOutlinePainter::GlyphOutlinePainter(System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path)
{
    _path = path;
}

void RenderingText::GlyphOutlinePainter::MoveTo(System::SharedPtr<Aspose::Font::RenderingPath::MoveTo> moveTo)
{
    _path->CloseFigure();
    _currentPoint.set_X((float)moveTo->get_X());
    _currentPoint.set_Y((float)moveTo->get_Y());
}

void RenderingText::GlyphOutlinePainter::LineTo(System::SharedPtr<Aspose::Font::RenderingPath::LineTo> lineTo)
{
    float x = (float)lineTo->get_X();
    float y = (float)lineTo->get_Y();
    _path->AddLine(_currentPoint.get_X(), _currentPoint.get_Y(), x, y);
    _currentPoint.set_X(x);
    _currentPoint.set_Y(y);
}

void RenderingText::GlyphOutlinePainter::CurveTo(System::SharedPtr<Aspose::Font::RenderingPath::CurveTo> curveTo)
{
    float x3 = (float)curveTo->get_X3();
    float y3 = (float)curveTo->get_Y3();
    
    _path->AddBezier(_currentPoint.get_X(), _currentPoint.get_Y(), (float)curveTo->get_X1(), (float)curveTo->get_Y1(), (float)curveTo->get_X2(), (float)curveTo->get_Y2(), x3, y3);
    
    _currentPoint.set_X(x3);
    _currentPoint.set_Y(y3);
}

void RenderingText::GlyphOutlinePainter::ClosePath()
{
    _path->CloseFigure();
}

System::Object::shared_members_type Aspose::Font::Examples::WorkingWithType1Fonts::RenderingText::GlyphOutlinePainter::GetSharedMembers()
{
    auto result = System::Object::GetSharedMembers();
    
    result.Add("Aspose::Font::Examples::WorkingWithType1Fonts::RenderingText::GlyphOutlinePainter::_path", this->_path);
    result.Add("Aspose::Font::Examples::WorkingWithType1Fonts::RenderingText::GlyphOutlinePainter::_currentPoint", this->_currentPoint);
    
    return result;
}

2. Crea metodo DrawText() che disegna il testo specificato in System.Drawing.Bitmap e salva la bitmap risultante sul disco. Ciò includerà i seguenti passaggi:

• Iterare tutti i simboli nella stringa di testo.
• Ottieni l’identificatore di glifi per ogni simbolo elaborato - GID.
• Crea oggetto di tipo GlyphoutLinePainter che è richiesto rendendo il sottosistema per disegnare il glifo di corrente.
• Crea oggetto di tipo Aspose.Font.Renderers.GlyphOutlineRenderer e passa l’oggetto appena creato di tipo GlyphoutLinePainter in costruttore per GlyphoutLinerender. Questo oggetto Glyphoutlinerender intendeva rendere il glifo specificato.
• Render la corrente elaborata Glyph utilizzando il metodo GlyphOutlineRenderer.RenderGlyph(). Aspose.Fonts.Matrix L’oggetto viene utilizzato per specificare le coordinate glifi. Il glifo da rendering è specificato dal parametro GID.

Passaggi ausiliari per questa strategia

• La coordinata glifo per l’asse ‘y’ è costante per questo frammento di codice.
• La coordinata glifo per l’asse ‘x’ viene calcolata per ogni glifo elaborato.
• Entrambe le coordinate “X” e “Y” vengono passate in oggetto Aspose.fonts.Matrix che viene utilizzata da Glyphoutlinerender per disegnare il loro glifo.
• La distanza tra glifi appena elaborati e precedenti viene calcolata in ogni fase di iterazione. Questa distanza influisce su ogni coordinata di glifi ‘x’.
• L’oggetto di tipo GlyphoutLinePainter disegna glifo con l’aiuto di GlyphoutLinePainter non direttamente in Bitmap, ma in Object GraphicsPath, che è stato passato al costruttore per GlyphoutLinePainter, quindi utilizziamo oggetto di tipo System.Drawing.Graphics per attirare graphicspath in BitMap.
• Metodo FontWidthToImageWith() che calcola la larghezza del glifo per il sistema di coordinate BitMap.

L’implementazione del metodo “DrawText” è come mostrato di seguito.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
void RenderingText::DrawText(System::String text, System::SharedPtr<IFont> font, double fontSize, System::SharedPtr<System::Drawing::Brush> backgroundBrush, System::SharedPtr<System::Drawing::Brush> textBrush, System::String outFile)
{
    //Get glyph identifiers for every symbol in text line
    System::ArrayPtr<System::SharedPtr<GlyphId>> gids = System::MakeArray<System::SharedPtr<Aspose::Font::Glyphs::GlyphId>>(text.get_Length());
    for (int32_t i = 0; i < text.get_Length(); i++)
    {
        gids[i] = font->get_Encoding()->DecodeToGid(text[i]);
    }
    // set common drawing settings
    double dpi = 300;
    
    double resolutionCorrection = dpi / 72;
    // 72 is font's internal dpi
    // prepare output bitmap
    System::SharedPtr<System::Drawing::Bitmap> outBitmap = System::MakeObject<System::Drawing::Bitmap>(960, 720);
    outBitmap->SetResolution((float)dpi, (float)dpi);
    System::SharedPtr<System::Drawing::Graphics> outGraphics = System::Drawing::Graphics::FromImage(outBitmap);
    outGraphics->FillRectangle(backgroundBrush, 0, 0, outBitmap->get_Width(), outBitmap->get_Height());
    outGraphics->set_SmoothingMode(System::Drawing::Drawing2D::SmoothingMode::HighQuality);
    //declare coordinate variables and previous gid
    System::SharedPtr<GlyphId> previousGid;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //loop which paints every glyph in gids
    
    {
        for (System::SharedPtr<GlyphId> gid : gids)
        {
            // if the font contains the gid
            if (gid != nullptr)
            {
                System::SharedPtr<Glyph> glyph = font->get_GlyphAccessor()->GetGlyphById(gid);
                if (glyph == nullptr)
                {
                    continue;
                }
                
                // path that accepts drawing instructions
                System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
                
                // Create IGlyphOutlinePainter implementation
                System::SharedPtr<RenderingText::GlyphOutlinePainter> outlinePainter = System::MakeObject<RenderingText::GlyphOutlinePainter>(path);
                
                // Create the renderer
                System::SharedPtr<Aspose::Font::Renderers::IGlyphRenderer> renderer = System::MakeObject<Aspose::Font::Renderers::GlyphOutlineRenderer>(outlinePainter);
                
                // get common glyph properties
                double kerning = 0;
                
                // get kerning value
                if (previousGid != nullptr)
                {
                    kerning = (font->get_Metrics()->GetKerningValue(previousGid, gid) / glyph->get_SourceResolution()) * fontSize * resolutionCorrection;
                    kerning += FontWidthToImageWith(font->get_Metrics()->GetGlyphWidth(previousGid), glyph->get_SourceResolution(), fontSize);
                }
                
                // glyph positioning - increase glyph X coordinate according to kerning distance
                glyphXCoordinate += kerning;
                
                // Glyph placement matrix
                System::SharedPtr<TransformationMatrix> glyphMatrix = System::MakeObject<TransformationMatrix>(System::MakeArray<double>({fontSize * resolutionCorrection, 0, 0, -fontSize * resolutionCorrection, glyphXCoordinate, glyphYCoordinate}));
                
                // render current glyph
                renderer->RenderGlyph(font, gid, glyphMatrix);
                // fill the path
                path->set_FillMode(System::Drawing::Drawing2D::FillMode::Winding);
                outGraphics->FillPath(textBrush, path);
            }
            //set current gid as previous to get correct kerning for next glyph
            previousGid = gid;
        }
        
    }
    //Save results
    outBitmap->Save(outFile);
}

3. Crea metodo di utilità per calcolare la larghezza del carattere alla larghezza dell’immagine come mostrato nel campione di codice seguente.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
double RenderingText::FontWidthToImageWith(double width, int32_t fontSourceResulution, double fontSize, double dpi /* = 300*/)
{
    double resolutionCorrection = dpi / 72;
    // 72 is font's internal dpi
    return (width / fontSourceResulution) * fontSize * resolutionCorrection;
}

Chiamare la funzionalità di testo di rendering

Per utilizzare le implicazioni di cui sopra, il seguente codice di esempio può essere eseguito dal metodo principale di un’applicazione basata sulla console.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
System::String fileName = dataDir + u"courier.pfb";
//Font file name with full path
    
System::SharedPtr<FontDefinition> fd = System::MakeObject<FontDefinition>(Aspose::Font::FontType::Type1, System::MakeObject<FontFileDefinition>(u"pfb", System::MakeObject<FileSystemStreamSource>(fileName)));
System::SharedPtr<Type1Font> font = System::DynamicCast_noexcept<Aspose::Font::Type1::Type1Font>(Aspose::Font::Font::Open(fd));
    
    
DrawText(u"Hello world", font, 14, System::Drawing::Brushes::get_White(), System::Drawing::Brushes::get_Black(), dataDir + u"hello1_type1_out.jpg");
DrawText(u"Hello world", font, 14, System::Drawing::Brushes::get_Yellow(), System::Drawing::Brushes::get_Red(), dataDir + u"hello2_type1_out.jpg");