Trabalhar com Texturas em PostScript | C++

Adicionar Padrão de Textura em Azulejos no Documento PS

Um padrão de textura em azulejos é uma imagem utilizada para preencher ou desenhar objetos: formas ou texto. Se o tamanho da imagem for inferior ao tamanho do objeto, esta será repetida nas direções X e Y para cobrir todas as áreas necessárias.

O processo de repetição da imagem dentro de objetos gráficos é designado por azulejo. Para definir pintura ou traço em PsDocument, devemos passar um objeto da classe System.Drawing.Brush para uma pintura e um objeto da classe System.Drawing.Pen para traçado nos respetivos métodos.

A biblioteca Aspose.Page para C++ processa todas as subclasses de System.Drawing.Brush oferecidas pela plataforma C++. São eles: System.Drawing.SolidBrush, System.Drawing.TextureBrush, System.Drawing.LinearGradientBrush, System.Drawing.PathGradientBrush e System.Drawing.HatchBrush. A classe System.Drawing.Pen não pode ser estendida porque está selada, mas contém System.Drawing.Brush como propriedade e, portanto, a biblioteca Aspose.Page para C++ também pode utilizar um conjunto completo de pincéis para desenhar linhas e contornar formas e texto.

Para pintar objetos gráficos com um padrão texturizado na biblioteca Aspose.Page para C++, basta passar System.Drawing.TextureBrush para SetPaint() ou um dos métodos FillText() ou FillAndStrokeText() que aceitam System.Drawing.Brush como parâmetro.

Para contornar os objetos gráficos com um padrão texturizado na biblioteca Aspose.Page para C++, deve criar um novo System.Drawing.Pen com System.Drawing.TextureBrush e passá-lo para SetStroke() ou um dos métodos OutlineText() ou FillAndStrokeText() que aceitem System.Drawing.Pen como parâmetro.

No exemplo abaixo, demonstramos como preencher uma forma e um texto, e contornar um texto com um padrão de mosaico texturado.

Descrição dos passos de trabalho com o Padrão de Textura e PsDocument no exemplo:

1. Crie um fluxo de saída para o ficheiro PS resultante.
2. Crie o objeto PsSaveOptions com as opções padrão.
3. Crie um PsDocument de 1 página com um fluxo de saída já criado e guarde as opções.
4. Crie um novo estado gráfico e translade-o para a posição necessária.
5. Crie System.Drawing.Bitmap a partir do ficheiro de imagem.
6. Crie System.Drawing.TextureBrush a partir da imagem.
7. Defina a transformação necessária no pincel de textura.
8. Defina o pincel de textura como a pintura atual no estado gráfico atual do PsDocument.
9. Crie um percurso retangular.
10. Preencha o retângulo com o pincel de textura.
11. Guarde a pintura atual como uma variável local para utilização futura.
12. Defina o traço atual com uma caneta vermelha.
13. Contorne o retângulo com uma caneta atual.
14. Saia do estado gráfico atual para o estado gráfico de nível superior.
15. Crie a fonte system.
16. Preencha e trace (contorne) o texto. Para preencher, utilize o pincel de textura e, para traçar, utilize caneta preta.
17. Contorne o texto na outra posição com o novo System.Drawing.Pen criado com o pincel de textura como Brush.
18. Feche a página.
19. Guarde o 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());
        }
    }

Veja como trabalhar com texturas em documentos PS em .NET ou Java.

O resultado da execução deste código é apresentado como

Pode descarregar exemplos e ficheiros de dados do GitHub.