Travailler avec des motifs de hachures dans PostScript | C++

Ajouter un motif de hachures dans un document PS

Le motif de hachures est un motif de carrelage texturé généralement représenté par une petite image simple en 2 couleurs (généralement en noir et blanc). Le contenu principal de ces petites images est constitué de diverses hachures.

Pour la peinture par hachures, la plate-forme C++ dispose d’une classe distincte, dérivée de System.Drawing.Brush, System.Drawing.HatchBrush. Sa différence avec System.Drawing.TextureBrush est qu’il a nommé des styles prédéfinis définissant quelle image utiliser pour le carrelage. La plate-forme C++ propose 53 styles de hachures et les 52 styles peuvent être utilisés pour le remplissage ou le contour (contour) dans PsDocument.

Afin de peindre des objets graphiques avec un motif de hachures dans la bibliothèque Aspose.Page pour C++, il suffit simplement de passer System.Drawing.HatchBrush à SetPaint() ou à l’un des FillText( ) ou FillAndStrokeText() qui acceptent System.Drawing.Brush comme paramètre.

Afin de décrire les objets graphiques avec un motif de hachures dans la bibliothèque Aspose.Page pour C++, quelqu’un doit créer un nouveau System.Drawing.Pen avec System.Drawing.HacthBrush et le transmettre à SetStroke( ) ou l’une des méthodes OutlineText() ou FillAndStrokeText() qui acceptent System.Drawing.Pen comme paramètre.

Dans l’exemple ci-dessous, nous montrons, tout d’abord, comment remplir une forme avec un motif de hachures, puis toutes les variétés de styles de hachures en C++ et, enfin, comment remplir et décrire un texte avec un motif de hachures.

Un algorithme pour peindre des objets graphiques avec un motif de hachures dans un nouveau document PS comprend les étapes suivantes :

1. Créez un flux de sortie pour le fichier PS résultant.
2. Créez PsSaveOptions.
3. Créez PsDocument avec le flux de sortie déjà créé et enregistrez les options.
4. Créez le chemin graphique ou la police nécessaire en fonction de l’objet que nous allons remplir ou décrire.
5. Créez un objet de System.Drawing.HatchBrush avec un style pieux.
6. Définissez le pinceau de hachures comme peinture actuelle dans PsDocument
7. Remplissez le chemin graphique avec la peinture actuelle ou remplissez un texte. Si nous utilisons l’une des méthodes de remplissage d’un texte qui accepte System.Drawing.Brush comme paramètre, le point précédent peut être ignoré.
8. Fermez la page.
9. Enregistrez le document.

Si nous avons besoin de tracer (décrire) des objets graphiques avec un motif de hachures au lieu des 4 derniers points, ce qui suit sera :

6. Créez un objet System.Drawing.Pen avec le pinceau de hachures.

7. Définissez ce stylet comme trait actuel dans PsDocument.

8. Décrivez le chemin graphique avec le trait actuel ou décrivez le texte. Si nous utilisons l’une des méthodes pour décrire le texte qui accepte System.Drawing.Pen comme paramètre, le point précédent peut être ignoré.

9. Fermez la page.

10. Enregistrez le document.
    

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithHatches();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"AddHatchPattern_outPS.ps", System::IO::FileMode::Create);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_0({ outPsStream});
        // ------------------------------------------
        
        try
        {
            //Create save options with A4 size
            System::SharedPtr<PsSaveOptions> options = System::MakeObject<PsSaveOptions>();
            
            // Create new 1-paged PS Document
            System::SharedPtr<PsDocument> document = System::MakeObject<PsDocument>(outPsStream, options, false);
            
            int32_t x0 = 20;
            int32_t y0 = 100;
            int32_t squareSide = 32;
            int32_t width = 500;
            int32_t sumX = 0;
            
            //Restore graphics state
            document->WriteGraphicsSave();
            
            //Translate to initial point
            document->Translate(static_cast<float>(x0), static_cast<float>(y0));
            
            //Create rectngle path for every pattern square
            System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(0.0f, 0.0f, static_cast<float>(squareSide), static_cast<float>(squareSide)));
            
            //Create pen for outlining pattern square
            System::SharedPtr<System::Drawing::Pen> pen = System::MakeObject<System::Drawing::Pen>(System::Drawing::Color::get_Black(), 2.0f);
            
            //For every hatch pattern style 
            for (System::Drawing::Drawing2D::HatchStyle hatchStyle = static_cast<System::Drawing::Drawing2D::HatchStyle>(0); hatchStyle <= (System::Drawing::Drawing2D::HatchStyle)52; hatchStyle++)
            {
                //Set paint with current hatch brush style
                document->SetPaint(System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(hatchStyle, System::Drawing::Color::get_Black(), System::Drawing::Color::get_White()));
                
                //Calculate displacement in order to don't go beyond the page bounds
                int32_t x = squareSide;
                int32_t y = 0;
                if (sumX >= width)
                {
                    x = -(sumX - squareSide);
                    y += squareSide;
                }
                //Translate current graphics state
                document->Translate(static_cast<float>(x), static_cast<float>(y));
                //Fill pattern square
                document->Fill(path);
                //Set stroke
                document->SetStroke(pen);
                //Draw square outline
                document->Draw(path);
                
                //Calculate distance from X0
                if (sumX >= width)
                {
                    sumX = squareSide;
                }
                else
                {
                    sumX += x;
                }
            }
            
            //Restore graphics state
            document->WriteGraphicsRestore();
            
            //Fill text with hatch pattern
            System::SharedPtr<System::Drawing::Drawing2D::HatchBrush> brush = System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(System::Drawing::Drawing2D::HatchStyle::DiagonalCross, System::Drawing::Color::get_Red(), System::Drawing::Color::get_Yellow());
            System::SharedPtr<System::Drawing::Font> font = System::MakeObject<System::Drawing::Font>(u"Arial", 96.0f, System::Drawing::FontStyle::Bold);
            document->FillAndStrokeText(u"ABC", font, 200.0f, 300.0f, brush, pen);
            
            //Outline text with hatch pattern
            brush = System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(System::Drawing::Drawing2D::HatchStyle::Percent50, System::Drawing::Color::get_Blue(), System::Drawing::Color::get_White());
            document->OutlineText(u"ABC", font, 200.0f, 400.0f, System::MakeObject<System::Drawing::Pen>(brush, 5.0f));
            
            
            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }

Voir Travailler avec un motif de hachures dans un document PS dans Java.

Le résultat de l’exécution de ce code apparaît comme

Vous pouvez télécharger des exemples et des fichiers de données à partir de GitHub.