Travailler avec la transparence dans PostScript | C++

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 C++ 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 C++ 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 n’importe quelle image à un nouveau PsDocument avec la bibliothèque Aspose.Page pour C++ 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.

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithTransparency();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"AddTransparentImage_outPS.ps", System::IO::FileMode::Create);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_2({ outPsStream});
        // ------------------------------------------
        
        try
        {
            //Create save options with A4 size
            System::SharedPtr<PsSaveOptions> options = System::MakeObject<PsSaveOptions>();
            //Set page's background color to see white image on it's own transparent background
            options->set_BackgroundColor(System::Drawing::Color::FromArgb(211, 8, 48));
            
            // Create new 1-paged PS Document
            System::SharedPtr<PsDocument> document = System::MakeObject<PsDocument>(outPsStream, options, false);
            
            
            document->WriteGraphicsSave();
            document->Translate(20.0f, 100.0f);
            
            //Create bitmap from translucent image file
            {
                System::SharedPtr<System::Drawing::Bitmap> image = System::MakeObject<System::Drawing::Bitmap>(dataDir + u"mask1.png");
                // Clearing resources under 'using' statement
                System::Details::DisposeGuard<1> __dispose_guard_0({ image});
                // ------------------------------------------
                
                try
                {
                    //Add this image to document as usual opaque RGB image
                    document->DrawImage(image, System::MakeObject<System::Drawing::Drawing2D::Matrix>(1.0f, 0.0f, 0.0f, 1.0f, 100.0f, 0.0f), System::Drawing::Color::Empty);
                }
                catch(...)
                {
                    __dispose_guard_0.SetCurrentException(std::current_exception());
                }
            }
            
            //Again create bitmap from the same image file
            {
                System::SharedPtr<System::Drawing::Bitmap> image = System::MakeObject<System::Drawing::Bitmap>(dataDir + u"mask1.png");
                // Clearing resources under 'using' statement
                System::Details::DisposeGuard<1> __dispose_guard_1({ image});
                // ------------------------------------------
                
                try
                {
                    //Add this image to document as transparent image image
                    document->DrawTransparentImage(image, System::MakeObject<System::Drawing::Drawing2D::Matrix>(1.0f, 0.0f, 0.0f, 1.0f, 350.0f, 0.0f), 255);
                }
                catch(...)
                {
                    __dispose_guard_1.SetCurrentException(std::current_exception());
                }
            }
            
            document->WriteGraphicsRestore();
            
            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_2.SetCurrentException(std::current_exception());
        }
    }

Voir comment travailler avec la transparence dans un document PS dans .NET ou 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 C++ 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.

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithTransparency();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"ShowPseudoTransparency_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);
            
            float offsetX = 50.0f;
            float offsetY = 100.0f;
            float width = 200.0f;
            float height = 100.0f;
            
            ///////////////////////////////// Create rectangle with opaque gradient fill /////////////////////////////////////////////////////////
            System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(offsetX, offsetY, width, height));
            
            System::SharedPtr<System::Drawing::Drawing2D::LinearGradientBrush> opaqueBrush = System::MakeObject<System::Drawing::Drawing2D::LinearGradientBrush>(System::Drawing::RectangleF(0.0f, 0.0f, 200.0f, 100.0f), System::Drawing::Color::FromArgb(0, 0, 0), System::Drawing::Color::FromArgb(40, 128, 70), 0.f);
            System::SharedPtr<System::Drawing::Drawing2D::Matrix> brushTransform = System::MakeObject<System::Drawing::Drawing2D::Matrix>(width, 0.0f, 0.0f, height, offsetX, offsetY);
            opaqueBrush->set_Transform(brushTransform);
            System::SharedPtr<GradientBrush> gradientBrush = System::MakeObject<GradientBrush>(opaqueBrush);
            gradientBrush->set_WrapMode(System::Drawing::Drawing2D::WrapMode::Clamp);
            
            document->SetPaint(gradientBrush);
            document->Fill(path);
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            
            offsetX = 350.0f;
            
            ///////////////////////////////// Create rectangle with translucent gradient fill ///////////////////////////////////////////////////
            //Create graphics path from the first rectangle
            path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(offsetX, offsetY, width, height));
            
            //Create linear gradient brush colors which transparency are not 255, but 150 and 50. So it are translucent.
            System::SharedPtr<System::Drawing::Drawing2D::LinearGradientBrush> translucentBrush = System::MakeObject<System::Drawing::Drawing2D::LinearGradientBrush>(System::Drawing::RectangleF(0.0f, 0.0f, width, height), System::Drawing::Color::FromArgb(150, 0, 0, 0), System::Drawing::Color::FromArgb(50, 40, 128, 70), 0.f);
            //Create a transform for brush.
            brushTransform = System::MakeObject<System::Drawing::Drawing2D::Matrix>(width, 0.0f, 0.0f, height, offsetX, offsetY);
            //Set transform
            translucentBrush->set_Transform(brushTransform);
            //Create GradientBrush object containing the linear gradient brush
            gradientBrush = System::MakeObject<GradientBrush>(translucentBrush);
            gradientBrush->set_WrapMode(System::Drawing::Drawing2D::WrapMode::Clamp);
            //Set paint
            document->SetPaint(gradientBrush);
            //Fill the rectangle
            document->Fill(path);
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            
            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }

Voir Travailler avec la transparence dans les documents PS dans .NET ou 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.