Rendu de texte à l'aide de la police Type1 | C++

Rendu du texte

Afin de restituer le texte, le sous-système de rendu nécessite l’implémentation de l’interface Aspose.Font.Rendering.IGlyphOutlinePainter pour dessiner le glyphe. Ceci peut être réalisé en suivant les étapes suivantes.

1. Implémentez les méthodes IGlyphOutlinePainter en créant une classe GlyphOutlinePainter qui nécessite un objet de type System.Drawing.Drawing2D.GraphicsPath pour les objectifs de dessin graphique. La mise en œuvre est comme illustré ci-dessous.

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. Créez la méthode DrawText() qui dessine le texte spécifié dans l’objet System.Drawing.Bitmap et enregistre le bitmap résultant sur le disque. Cela comprendra les étapes suivantes :

• Itérer tous les symboles dans la chaîne de texte .

• Obtenez l’identifiant de glyphe pour chaque symbole traité - gid .

• Créez un objet de type GlyphOutlinePainter qui est requis par le sous-système de rendu pour dessiner le glyphe actuel .

• Créez un objet de type Aspose.Font.Renderers.GlyphOutlineRenderer et transmettez l’objet de type GlyphOutlinePainter que vous venez de créer dans le constructeur de GlyphOutlineRenderer. Cet objet GlyphOutlineRenderer était destiné à restituer le glyphe spécifié .

• Rendre le glyphe traité actuel à l’aide de la méthode GlyphOutlineRenderer.RenderGlyph(). L’objet Aspose.Fonts.Matrix est utilisé pour spécifier les coordonnées du glyphe. Le glyphe à restituer est spécifié par le paramètre gid.

« Étapes auxiliaires pour cette stratégie »

• La coordonnée du glyphe pour l’axe « Y » est constante pour cet extrait de code .

• Les coordonnées du glyphe pour l’axe « X » sont calculées pour chaque glyphe traité .

• Les coordonnées ‘X’ et ‘Y’ sont transmises à l’objet Aspose.Fonts.Matrix qui est utilisé par GlyphOutlineRenderer pour dessiner un glyphe .

• La distance entre les glyphes qui viennent d’être traités et les glyphes précédents est calculée à chaque étape d’itération. Cette distance affecte chaque coordonnée « X » de glyphe .

• L’objet de type GlyphOutlinePainter dessine le glyphe à l’aide de GlyphOutlinePainter non pas directement dans Bitmap, mais dans l’objet GraphicsPath, qui a été passé au constructeur pour GlyphOutlinePainter, nous utilisons donc un objet de type System.Drawing.Graphics pour dessiner GraphicsPath dans Bitmap .

• Méthode FontWidthToImageWith() qui calcule la largeur du glyphe pour le système de coordonnées bitmap.

L’implémentation de la méthode DrawText est comme indiqué ci-dessous.

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. Créez une méthode utilitaire pour calculer la largeur de la police par rapport à la largeur de l’image, comme indiqué dans l’exemple de code ci-dessous.

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;
}

Appel de la fonctionnalité Rendu du texte

Pour utiliser les implémentations ci-dessus, l’exemple de code suivant peut être exécuté à partir de la méthode Main d’une application basée sur 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");