Trabalhar com Transformações em PostScript | C++

Transformar um conteúdo num Documento PS

Neste artigo, veremos como realizar diferentes transformações: translação, dimensionamento, rotação e cisalhamento num percurso retangular adicionado ao PsDocument.

Dividimos um trecho de código em vários trechos: o início, o fim e cada transformação em separado. Uma transformação em PostScript é sempre realizada num estado gráfico ligado aos operadores “gsave” e “grestore”. Assim, no nosso PsDocument, existem os métodos “WriteGraphicsSave()” e “WriteGraphicsRestore()”. Entre estes métodos, podemos adicionar qualquer conteúdo, incluindo estados gráficos aninhados, e realizar quaisquer transformações ou recortes. Estas transformações não afetarão os estados gráficos externos, mas afetarão os estados gráficos aninhados.

Se realizarmos uma transformação sem os métodos “WriteGraphicsSave()” e “WriteGraphicsRestore()”, esta será feita no estado gráfico do nível superior e todo o conteúdo presente no PsDocument será submetido a esta transformação.

Um algoritmo para definir qualquer transformação no conteúdo de um documento a partir do zero inclui os seguintes passos:

1. Criar um fluxo de saída para o ficheiro PS resultante.
2. Criar PsSaveOptions.
3. Criar PsDocument com o fluxo de saída já criado e guardar as opções.
4. Guardar um estado gráfico. Assim, criámos um novo estado gráfico e o estado gráfico anterior foi colocado numa pilha de estados gráficos.
5. Adicione a transformação necessária: translação, escala, rotação, cisalhamento ou qualquer combinação das mesmas. No nosso código, mostramos a influência de cada componente da transformação em separado e, no final, 3 componentes de cada vez.
6. Adicione o conteúdo necessário para a transformação. No nosso caso, criamos um retângulo GraphicsPath a partir do retângulo e preenchemo-lo. Criamos um retângulo antes de qualquer transformação e preenchemo-lo após cada transformação no estado gráfico atual.
7. Restauramos o estado gráfico para voltar ao estado anterior, onde a(s) transformação(ões) aplicada(s) não afeta(m). No nosso caso, trata-se de um estado gráfico de nível superior.

Neste trecho de código, criamos o PsDocument a partir de um fluxo de saída e o PsSaveOptions, transladamos o estado gráfico de nível superior para os pontos 100 e 100 para deslocar o primeiro retângulo e, por fim, criamos o primeiro retângulo GraphicsPath a partir do retângulo.

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithCanvas();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"Transformations_outPS.ps", System::IO::FileMode::Create);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_0({ outPsStream});
        // ------------------------------------------
        
        try
        {
            //Create save options with default values
            System::SharedPtr<PsSaveOptions> options = System::MakeObject<PsSaveOptions>();
            
            // Create new 1-paged PS Document
            System::SharedPtr<PsDocument> document = System::MakeObject<PsDocument>(outPsStream, options, false);
            
            document->Translate(100.0f, 100.0f);
            
            //Create graphics path from the rectangle
            System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(0.0f, 0.0f, 150.0f, 100.0f));

Aqui, definimos a cor Laranja como a tinta atual para o estado gráfico de nível superior e preenchemos este retângulo.

O ficheiro PS resultante demonstrará a primeira forma localizada no estado gráfico de nível superior e que não sofreu qualquer transformação.

            ////////////////////////////////////// No transformations ///////////////////////////////////////////////////////////////
            //Set paint in graphics state on upper level
            document->SetPaint(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Orange()));
            
            //Fill the first rectangle that is on on upper level graphics state and that is without any transformations.
            document->Fill(path);
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Agora, criamos um novo estado gráfico que será transladado em 250 pontos pelo eixo X em relação ao estado gráfico de nível superior e adicionamos a este novo estado gráfico o mesmo caminho retangular pintado com a cor Azul. No final, saímos do estado gráfico atual no estado gráfico de nível superior.

            ////////////////////////////////////// Translation //////////////////////////////////////////////////////////////////////
            
            //Save graphics state in order to return back to this state after transformation
            document->WriteGraphicsSave();
            
            //Displace current graphics state on 250 to the right. So we add translation component to the current transformation.
            document->Translate(250.0f, 0.0f);
            
            //Set paint in the current graphics state
            document->SetPaint(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Blue()));
            
            //Fill the second rectangle in the current graphics state (has translation transformation)
            document->Fill(path);
            
            //Restore graphics state to the previus (upper) level
            document->WriteGraphicsRestore();
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Traduza o estado dos gráficos de nível superior para colocar os retângulos seguintes.

            //Displace on 200 to the bottom.
            document->Translate(0.0f, 200.0f);

Aqui, criamos um estado gráfico que será dimensionado em 0,5 no eixo X e 0,75 no eixo Y e adicionamos a estes novos estados gráficos o mesmo percurso retangular pintado com a cor Vermelho. No final, saímos do estado gráfico atual para o estado gráfico de nível superior.

            ////////////////////////////////////// Scaling //////////////////////////////////////////////////////////////////////////
            //Save graphics state in order to return back to this state after transformation
            document->WriteGraphicsSave();
            
            //Scale current graphics state on 0.5 in X axis and on 0.75f in Y axis. So we add scale component to the current transformation.
            document->Scale(0.5f, 0.75f);
            
            //Set paint in the current graphics state
            document->SetPaint(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Red()));
            
            //Fill the third rectangle in the current graphics state (has scale transformation)
            document->Fill(path);
            
            //Restore graphics state to the previus (upper) level
            document->WriteGraphicsRestore();
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Traduza o estado gráfico de nível superior para colocar os retângulos seguintes.

            //Displace upper level graphics state on 250 to the right.
            document->Translate(250.0f, 0.0f);

De seguida, criamos um novo estado gráfico que será rodado 45 graus no sentido dos ponteiros do relógio em relação ao estado gráfico de nível superior e adicionamos a este novo estado gráfico o mesmo caminho retangular pintado com a cor Verde. No final, saímos do estado gráfico atual no estado gráfico de nível superior.

            ////////////////////////////////////// Rotation //////////////////////////////////////////////////////////////////////
            //Save graphics state in order to return back to this state after transformation
            document->WriteGraphicsSave();
            
            //Rotate current graphics state on 45 degrees around origin of current graphics state (350, 300). So we add rotation component to the current transformation.
            document->Rotate(45);
            
            //Set paint in the current graphics state
            document->SetPaint(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Green()));
            
            //Fill the fourth rectangle in the current graphics state (has rotation transformation)
            document->Fill(path);
            
            //Restore graphics state to the previus (upper) level
            document->WriteGraphicsRestore();
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Traduza o estado gráfico de nível superior para colocar os retângulos seguintes no espaço em branco da página.

            //Returns upper level graphics state back to the left and displace on 200 to the bottom.
            document->Translate(-250.0f, 200.0f);

De seguida, criamos um novo estado gráfico que será distorcido e adicionamos a este novo estado gráfico o mesmo caminho retangular pintado com a cor Rosa. No final, saímos do estado gráfico atual no estado gráfico de nível superior.

            ////////////////////////////////////// Shearing //////////////////////////////////////////////////////////////////////
            //Save graphics state in order to return back to this state after transformation
            document->WriteGraphicsSave();
            
            //Shear current graphics state. So we add shear component to the current transformation.
            document->Shear(0.1f, 0.2f);
            
            //Set paint in the current graphics state
            document->SetPaint(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Pink()));
            
            //Fill the fifth rectangle in the current graphics state (has shear transformation)
            document->Fill(path);
            
            //Restore graphics state to the previus (upper) level
            document->WriteGraphicsRestore();
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Traduza o estado gráfico de nível superior para colocar os retângulos seguintes no espaço em branco da página.

            //Displace upper level graphics state on 250 to the right.
            document->Translate(250.0f, 0.0f);

Agora, criamos o último estado gráfico que irá sofrer uma transformação complexa, contendo componentes de translação, escala e rotação, e adicionamos a este novo estado gráfico o mesmo caminho retangular pintado com a cor Aquamarine. No final, saímos do estado gráfico atual para o estado gráfico de nível superior.

            ////////////////////////////////////// Complex transformation ////////////////////////////////////////////////////////
            //Save graphics state in order to return back to this state after transformation
            document->WriteGraphicsSave();
            
            //Transform current graphics state with complex transformation. So we add translation, scale and rotation components to the current transformation.
            document->Transform(System::MakeObject<System::Drawing::Drawing2D::Matrix>(1.2f, -0.965925f, 0.258819f, 1.5f, 0.f, 50.0f));
            
            //Set paint in the current graphics state
            document->SetPaint(System::MakeObject<System::Drawing::SolidBrush>(System::Drawing::Color::get_Aquamarine()));
            
            //Fill the sixth rectangle in the current graphics state (has complex transformation)
            document->Fill(path);
            
            //Restore graphics state to the previus (upper) level
            document->WriteGraphicsRestore();
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Traduza o estado gráfico de nível superior para colocar o último retângulo no espaço em branco da página.

            //Returns upper level graphics state back to the left and displace on 200 to the bottom.
            document->Translate(-250.0f, 200.0f);

O último retângulo preenchido que colocámos novamente no estado gráfico de nível superior mostra que não sofreu transformações nos estados gráficos do nível inferior nem alterações de cor. A cor laranja é a tinta atual restante.

            ////////////////////////////////////// Again no transformation ////////////////////////////////////////////////////////
            // Demonstrates that current graphics state's color is orange that was set up at the beginning of the code. 
            //Fill the seventh rectangle in the current graphics state (has no transformation)
            document->Fill(path);
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Por fim, fechamos a página atual e guardamos o documento.

            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }

Veja como trabalhar com transformações no documento PS em .NET ou Java.

O resultado da execução deste código é o seguinte:

Pode descarregar exemplos e ficheiros de dados do GitHub.