Travailler avec des motifs de hachures dans PS | .NET

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 .NET 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 .NET 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 .NET, 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 .NET, 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 dans .NET 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.
    

//Create an output stream for PostScript document
using (Stream outPsStream = new FileStream(dataDir + "AddHatchPattern_outPS.ps", FileMode.Create))
{
    //Create save options with A4 size
    PsSaveOptions options = new PsSaveOptions();

    // Create new 1-paged PS Document
    PsDocument document = new PsDocument(outPsStream, options, false);

    int x0 = 20;
    int y0 = 100;
    int squareSide = 32;
    int width = 500;
    int sumX = 0;

    //Create a graphics state
    document.WriteGraphicsSave();

    //Translate the graphics state to initial point
    document.Translate(x0, y0);

    //Create a rectangle path for every pattern square
    GraphicsPath path = new GraphicsPath();
    path.AddRectangle(new RectangleF(0, 0, squareSide, squareSide));

    //Create a pen for outlining pattern square
    Pen pen = new Pen(Color.Black, 2);

    //For every hatch pattern style 
    for (HatchStyle hatchStyle = 0; hatchStyle <= (HatchStyle)52; hatchStyle++)
    {
        //Set the paint with current hatch brush style
        document.SetPaint(new HatchBrush(hatchStyle, Color.Black, Color.White));

        //Calculate a displacement in order to don't go beyond the page bounds
        int x = squareSide;
        int y = 0;
        if (sumX >= width)
        {
            x = -(sumX - squareSide);
            y += squareSide;
        }
        //Translate current graphics state
        document.Translate(x, y);
        //Fill the pattern square
        document.Fill(path);
        //Set the stroke
        document.SetStroke(pen);
        //Draw the square outline
        document.Draw(path);

        //Calculate a distance from X0
        if (sumX >= width)
        {
            sumX = squareSide;
        }
        else
            sumX += x;
    }

    //Exit from current graphics state to upper level graphics state
    document.WriteGraphicsRestore();

    //Fill the text with the hatch pattern
    HatchBrush brush = new HatchBrush(HatchStyle.DiagonalCross, Color.Red, Color.Yellow);
    Font font = new Font("Arial", 96, FontStyle.Bold);
    document.FillAndStrokeText("ABC", font, 200, 300, brush, pen);

    //Outline the text with hatch pattern
    brush = new HatchBrush(HatchStyle.Percent50, Color.Blue, Color.White);                
    document.OutlineText("ABC", font, 200, 400, new Pen(brush, 5));


    //Close current page
    document.ClosePage();

    //Save the document
    document.Save();
}

Pour Linux, MacOS et autres systèmes d’exploitation non Windows, nous proposons d’utiliser notre package Nuget Aspose.Page.Drawing. Il utilise le backend Aspose.Drawing au lieu de la bibliothèque système System.Drawing.

Importez donc l’espace de noms Aspose.Page.Drawing au lieu de celui de System.Drawing. Dans l’extrait de code ci-dessus, Aspose.Page.Drawing.Rectangle sera utilisé à la place de System.Drawing.Rectangle, Aspose.Page.Drawing.Drawing2D.GraphicsPath sera utilisé à la place de System.Drawing.Drawing2D.GraphicsPath et ainsi de suite. Nos exemples de code sur GitHub contiennent toutes les substitutions nécessaires.

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.