Trabalhar com Padrões de Hachura em PostScript | C++

Adicionar Padrão de Hachura em Documento PS

O padrão de hachura é um padrão de textura em mosaico, geralmente representado por pequenas imagens simples de duas cores (geralmente preto e branco). O conteúdo principal destas pequenas imagens são várias hachuras.

Para a pintura por hachuras, a plataforma C++ possui uma classe separada, derivada de System.Drawing.Brush, System.Drawing.HatchBrush. A sua diferença em relação a System.Drawing.TextureBrush é que tem estilos predefinidos que definem qual a imagem a utilizar para o mosaico. A plataforma C++ oferece 53 estilos de hachura e todos os 52 estilos podem ser utilizados para preenchimento ou contorno no PsDocument.

Para pintar objetos gráficos com um padrão de hachura na biblioteca Aspose.Page para C++, basta passar System.Drawing.HatchBrush 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 de hachura na biblioteca Aspose.Page para C++, é necessário criar uma nova System.Drawing.Pen com System.Drawing.HacthBrush e passá-la para SetStroke() ou um dos métodos OutlineText() ou FillAndStrokeText() que aceitam System.Drawing.Pen como parâmetro.

No exemplo abaixo, demonstramos, em primeiro lugar, como preencher uma forma com um padrão de hachura, depois todos os estilos de hachura em C++ e, por fim, como preencher e contornar um texto com um padrão de hachura.

Um algoritmo para pintar objetos gráficos com um padrão de hachura num novo documento PS inclui os seguintes passos:

1. Crie um fluxo de saída para o ficheiro PS resultante.
2. Crie PsSaveOptions.
3. Crie PsDocument com o fluxo de saída já criado e as opções de guardar.
4. Crie o caminho gráfico ou a fonte necessária, dependendo do objeto que iremos preencher ou contornar.
5. Crie um objeto de System.Drawing.HatchBrush com o estilo pretendido.
6. Defina o pincel de hachura como a tinta atual no PsDocument.
7. Preencha o percurso gráfico com a tinta atual ou preencha com texto. Se utilizarmos um dos métodos para preencher um texto que aceite System.Drawing.Brush como parâmetro, o ponto anterior pode ser ignorado.
8. Feche a página.
9. Guarde o documento.

Se precisarmos de traçar (contornar) objetos gráficos com um padrão de hachura em vez dos últimos 4 pontos, o seguinte será:

6. Crie o objeto System.Drawing.Pen com o pincel de hachura.

7. Defina esta caneta como o traço atual no PsDocument.

8. Contorne o percurso gráfico com o traço atual ou contorne o texto. Se utilizarmos um dos métodos para contornar o texto que aceita System.Drawing.Pen como parâmetro, o ponto anterior pode ser ignorado.

9. Feche a página.

10. Guarde o documento.
    

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithHatches();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"AddHatchPattern_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);
            
            int32_t x0 = 20;
            int32_t y0 = 100;
            int32_t squareSide = 32;
            int32_t width = 500;
            int32_t sumX = 0;
            
            //Restore graphics state
            document->WriteGraphicsSave();
            
            //Translate to initial point
            document->Translate(static_cast<float>(x0), static_cast<float>(y0));
            
            //Create rectngle path for every pattern square
            System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(0.0f, 0.0f, static_cast<float>(squareSide), static_cast<float>(squareSide)));
            
            //Create pen for outlining pattern square
            System::SharedPtr<System::Drawing::Pen> pen = System::MakeObject<System::Drawing::Pen>(System::Drawing::Color::get_Black(), 2.0f);
            
            //For every hatch pattern style 
            for (System::Drawing::Drawing2D::HatchStyle hatchStyle = static_cast<System::Drawing::Drawing2D::HatchStyle>(0); hatchStyle <= (System::Drawing::Drawing2D::HatchStyle)52; hatchStyle++)
            {
                //Set paint with current hatch brush style
                document->SetPaint(System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(hatchStyle, System::Drawing::Color::get_Black(), System::Drawing::Color::get_White()));
                
                //Calculate displacement in order to don't go beyond the page bounds
                int32_t x = squareSide;
                int32_t y = 0;
                if (sumX >= width)
                {
                    x = -(sumX - squareSide);
                    y += squareSide;
                }
                //Translate current graphics state
                document->Translate(static_cast<float>(x), static_cast<float>(y));
                //Fill pattern square
                document->Fill(path);
                //Set stroke
                document->SetStroke(pen);
                //Draw square outline
                document->Draw(path);
                
                //Calculate distance from X0
                if (sumX >= width)
                {
                    sumX = squareSide;
                }
                else
                {
                    sumX += x;
                }
            }
            
            //Restore graphics state
            document->WriteGraphicsRestore();
            
            //Fill text with hatch pattern
            System::SharedPtr<System::Drawing::Drawing2D::HatchBrush> brush = System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(System::Drawing::Drawing2D::HatchStyle::DiagonalCross, System::Drawing::Color::get_Red(), System::Drawing::Color::get_Yellow());
            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, brush, pen);
            
            //Outline text with hatch pattern
            brush = System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(System::Drawing::Drawing2D::HatchStyle::Percent50, System::Drawing::Color::get_Blue(), System::Drawing::Color::get_White());
            document->OutlineText(u"ABC", font, 200.0f, 400.0f, System::MakeObject<System::Drawing::Pen>(brush, 5.0f));
            
            
            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }

Veja como trabalhar com um padrão de hachura no documento PS em Java.

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

Pode descarregar exemplos e ficheiros de dados do GitHub.