Lavorare con le texture in PostScript | C++

Aggiungi un pattern di texture a mosaico in un documento PS

Un pattern di texture a mosaico è un’immagine utilizzata per riempire o disegnare oggetti: forme o testo. Se le dimensioni dell’immagine sono inferiori a quelle dell’oggetto, viene ripetuta nelle direzioni X e Y per coprire tutte le aree necessarie.

Il processo di ripetizione dell’immagine all’interno di oggetti grafici è chiamato mosaico. Per impostare il colore o il tratto in PsDocument, dobbiamo passare un oggetto della classe System.Drawing.Brush per un disegno e un oggetto della classe System.Drawing.Pen per il tratto ai rispettivi metodi.

La libreria Aspose.Page per C++ elabora tutte le sottoclassi di System.Drawing.Brush offerte dalla piattaforma C++. Questi sono System.Drawing.SolidBrush, System.Drawing.TextureBrush, System.Drawing.LinearGradientBrush, System.Drawing.PathGradientBrush e System.Drawing.HatchBrush. La classe System.Drawing.Pen non può essere estesa perché è sealed, ma contiene System.Drawing.Brush come proprietà e, pertanto, la libreria Aspose.Page per C++ può utilizzare anche un set completo di pennelli per disegnare linee e delineare forme e testo.

Per dipingere oggetti grafici con un pattern texturizzato nella libreria Aspose.Page per C++, è sufficiente passare System.Drawing.TextureBrush a SetPaint() o a uno dei metodi FillText() o FillAndStrokeText() che accetta System.Drawing.Brush come parametro.

Per delineare oggetti grafici con un pattern texture nella libreria Aspose.Page per C++, è necessario creare un nuovo System.Drawing.Pen con System.Drawing.TextureBrush e passarlo a SetStroke() o a uno dei metodi OutlineText() o FillAndStrokeText() che accetta System.Drawing.Pen come parametro.

Nell’esempio seguente mostriamo come riempire una forma e un testo e come delineare un testo con un pattern texture a mosaico.

Descrizione dei passaggi per lavorare con Texture Pattern e PsDocument nell’esempio:

1. Crea un flusso di output per il file PS risultante.
2. Crea un oggetto PsSaveOptions con le opzioni predefinite.
3. Crea un PsDocument a pagina singola con un flusso di output già creato e le relative opzioni di salvataggio.
4. Crea un nuovo stato grafico e traslalo nella posizione desiderata.
5. Crea System.Drawing.Bitmap dal file immagine.
6. Crea System.Drawing.TextureBrush dall’immagine.
7. Imposta la trasformazione necessaria nel pennello texture.
8. Imposta il pennello texture come pennello corrente nello stato grafico corrente del PsDocument.
9. Crea un tracciato rettangolare.
10. Riempi il rettangolo con il pennello texture.
11. Salva il pennello corrente come variabile locale per un utilizzo futuro. 12. Imposta il tratto corrente con una penna rossa.
12. Contorna il rettangolo con la penna corrente.
13. Esci dallo stato grafico corrente e torna allo stato grafico di livello superiore.
14. Crea un font system.
15. Riempi e traccia (contorna) il testo. Per il riempimento si utilizza il pennello texture e per il contorno si utilizza una penna nera.
16. Contorna il testo nell’altra posizione con il nuovo System.Drawing.Pen creato con il pennello texture come Brush.
17. Chiudi la pagina.
18. Salva il documento.

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithTextures();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"AddTextureTilingPattern_outPS.ps", System::IO::FileMode::Create);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_1({ 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);
            
            
            document->WriteGraphicsSave();
            document->Translate(200.0f, 100.0f);
            
            //Create a Bitmap object from image file
            {
                System::SharedPtr<System::Drawing::Bitmap> image = System::MakeObject<System::Drawing::Bitmap>(dataDir + u"TestTexture.bmp");
                // Clearing resources under 'using' statement
                System::Details::DisposeGuard<1> __dispose_guard_0({ image});
                // ------------------------------------------
                
                try
                {
                    //Create texture brush from the image
                    System::SharedPtr<System::Drawing::TextureBrush> brush = System::MakeObject<System::Drawing::TextureBrush>(image, System::Drawing::Drawing2D::WrapMode::Tile);
                    
                    //Add scaling in X direction to the mattern
                    System::SharedPtr<System::Drawing::Drawing2D::Matrix> transform = System::MakeObject<System::Drawing::Drawing2D::Matrix>(2.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
                    brush->set_Transform(transform);
                    
                    //Set this texture brush as current paint
                    document->SetPaint(brush);
                }
                catch(...)
                {
                    __dispose_guard_0.SetCurrentException(std::current_exception());
                }
            }
            
            //Create rectangle path
            System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(0.0f, 0.0f, 200.0f, 100.0f));
            
            //Fill rectangle
            document->Fill(path);
            
            //Get current paint
            System::SharedPtr<System::Drawing::Brush> paint = document->GetPaint();
            
            //Set red stroke
            document->SetStroke(System::MakeObject<System::Drawing::Pen>(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Red()), 2.0f));
            //Stroke the rectangle
            document->Draw(path);
            
            document->WriteGraphicsRestore();
            
            //Fill text with texture pattern                
            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, paint, System::MakeObject<System::Drawing::Pen>(System::Drawing::Color::get_Black(), 2.0f));
            
            //Outline text with texture pattern
            document->OutlineText(u"ABC", font, 200.0f, 400.0f, System::MakeObject<System::Drawing::Pen>(paint, 5.0f));
            
            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_1.SetCurrentException(std::current_exception());
        }
    }

Vedi come lavorare con le texture nei documenti PS in .NET o Java.

Il risultato dell’esecuzione di questo codice viene visualizzato come

È possibile scaricare esempi e file di dati da GitHub.