Travailler avec la transparence dans PS | .NET

Ajouter de la transparence dans le document PS

PostScript ne prend pas en charge la transparence lors de la peinture d’objets graphiques vectoriels. Cependant, les images translucides (partiellement transparentes) peuvent être restituées sous la forme d’un ensemble de pixels entièrement transparents et entièrement opaques. De telles images sont appelées masques.

La bibliothèque Aspose.Page pour .NET propose une méthode qui ajoute l’image transparente au document PS. Quant à la peinture de graphiques vectoriels : formes ou texte, nous proposons la “pseudo-transparence”.

La « pseudo-transparence » est un processus de pâlissement des couleurs qui ont une composante Alpha inférieure à 255. Elle est atteinte par le mélange spécifique des composants rouge, vert et bleu avec l’Alpha One.

La “pseudo-transparence”, bien sûr, ne nous permet pas de voir la couche colorée inférieure sous la couche transparente supérieure, mais crée une illusion de transparence si la couche inférieure est blanche.

Ajouter une image transparente dans le document PS

Comme nous l’avons écrit précédemment, des images transparentes peuvent être ajoutées au document PS en tant que masque et la bibliothèque Aspose.Page pour .NET propose à cet effet une méthode AddTransparentImage().

Cette méthode reconnaît si l’image est totalement opaque ou entièrement transparente ou translucide. S’il est entièrement opaque, il est ajouté comme image opaque dans la méthode AddImage(), s’il est entièrement transparent, il n’est pas ajouté du tout au document, s’il s’agit d’une image translucide, il est ajouté en tant qu’image PostScript. masque.

Dans l’exemple ci-dessous, nous démontrons la différence entre l’ajout d’une image transparente dans un document PS avec AddImage() et AddTransparentImage(). Afin de voir l’image blanche translucide, nous définissons la couleur d’arrière-plan de la page sur non blanc.

Afin d’ajouter une image à un nouveau PsDocument avec la bibliothèque Aspose.Page pour .NET dans cet exemple, nous procédons comme suit :

1. Créez un flux de sortie pour le fichier PS résultant.
2. Créez un objet PsSaveOptions avec les options par défaut. Changez la couleur d’arrière-plan si nécessaire.
3. Créez un PsDocument d’une page avec un flux de sortie déjà créé et enregistrez les options.
4. Créez un nouvel état graphique.
5. Créez un Bitmap à partir du fichier image.
6. Créez la transformation nécessaire pour l’image.
7. Ajoutez l’image à PsDocument en tant qu’image entièrement opaque (en utilisant la méthode AddImage()) si nous sommes sûrs que l’image est opaque ou ajoutez-en une en tant qu’image transparente (en utilisant la méthode AddTransparentImage()) si nous ne sommes pas sûrs que l’image soit opaque.
8. Quittez l’état graphique actuel pour passer au niveau supérieur.
9. Fermez la page.
10. Enregistrez le document.

//Create an output stream for PostScript document
using (Stream outPsStream = new FileStream(dataDir + "AddTransparentImage_outPS.ps", FileMode.Create))
{
    //Create save options with A4 size
    PsSaveOptions options = new PsSaveOptions();
    //Set page's background color to see white image on it's own transparent background
    options.BackgroundColor = Color.FromArgb(211, 8, 48);

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


    document.WriteGraphicsSave();
    document.Translate(20, 100);

    //Create a bitmap from translucent image file
    using (Bitmap image = new Bitmap(dataDir + "mask1.png"))
    {
        //Add this image to the document as usual opaque RGB image
        document.DrawImage(image, new Matrix(1, 0, 0, 1, 100, 0), Color.Empty);
    }

    //Again create a bitmap from the same image file
    using (Bitmap image = new Bitmap(dataDir + "mask1.png"))
    {
        //Add this image to the document as transparent image
        document.DrawTransparentImage(image, new Matrix(1, 0, 0, 1, 350, 0), 255);
    }

    document.WriteGraphicsRestore();

    //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 les extraits de code ci-dessus et suivants, Aspose.Page.Drawing.Bitmap sera utilisé à la place de System.Drawing.Bitmap, Aspose.Page.Drawing.Drawing2D.Matrix sera utilisé à la place de System.Drawing.Drawing2D.Matrix et ainsi de suite. . Nos exemples de code sur GitHub contiennent toutes les substitutions nécessaires.

Voir comment travailler avec la transparence dans un document PS dans Java.

Le résultat de l’exécution de ce code est le suivant

Ajout d’un objet graphique vectoriel transparent

Plus tôt, nous avons écrit que la bibliothèque Aspose.Page pour .NET utilise un algorithme de pâleur pour les formes et le texte transparents, que nous avons appelé “pseudo-transparence”. Dans l’exemple ci-dessous, nous démontrons une différence entre deux formes peintes avec la même couleur, mais dans la première forme sans le composant Alpha et dans le second cas avec le composant Alpha.

//Create an output stream for PostScript document
using (Stream outPsStream = new FileStream(dataDir + "ShowPseudoTransparency_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);

    float offsetX = 50;
    float offsetY = 100;
    float width = 200;
    float height = 100;

///////////////////////////////// Create a rectangle with opaque gradient fill /////////////////////////////////////////////////////////
    GraphicsPath path = new GraphicsPath();
    path.AddRectangle(new RectangleF(50, 100, 200, 100));

    LinearGradientBrush opaqueBrush = new LinearGradientBrush(new RectangleF(0, 0, 200, 100), Color.FromArgb(0, 0, 0),
        Color.FromArgb(40, 128, 70), 0f);
    Matrix brushTransform = new Matrix(200, 0, 0, 100, 50, 100);
    opaqueBrush.Transform = brushTransform;
    Aspose.Page.EPS.GradientBrush gradientBrush = new GradientBrush(opaqueBrush);
    gradientBrush.WrapMode = WrapMode.Clamp;

    document.SetPaint(gradientBrush);
    document.Fill(path);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    offsetX = 350;

///////////////////////////////// Create a rectangle with translucent gradient fill ///////////////////////////////////////////////////
    //Create graphics path from the first rectangle
    path = new GraphicsPath();
    path.AddRectangle(new RectangleF(offsetX, offsetY, width, height));

    //Create linear gradient brush colors which transparency are not 255, but 150 and 50. So it are translucent.
    LinearGradientBrush translucentBrush = new LinearGradientBrush(new RectangleF(0, 0, width, height), Color.FromArgb(150, 0, 0, 0),
        Color.FromArgb(50, 40, 128, 70), 0f);
    //Create a transform for the brush.
    brushTransform = new Matrix(width, 0, 0, height, offsetX, offsetY);
    //Set the transform
    translucentBrush.Transform = brushTransform;
    
    //Set the paint
    document.SetPaint(translucentBrush);
    //Fill the rectangle
    document.Fill(path);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    //Close current page
    document.ClosePage();

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

Voir Travailler avec la transparence dans les documents PS dans Java et C++.

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.